@visactor/vutils 0.18.0 → 0.18.2-alpha.0

package/dist/index.js

@@ -4784,6 +4784,163 @@
 	    return { x: lng, y: lat };
 	}
 
+	const SMALL = 1e-10;
+
+	function intersectionArea(circles, stats) {
+	    const intersectionPoints = getIntersectionPoints(circles);
+	    const innerPoints = intersectionPoints.filter(function (p) {
+	        return containedInCircles(p, circles);
+	    });
+	    let arcArea = 0;
+	    let polygonArea = 0;
+	    const arcs = [];
+	    if (innerPoints.length > 1) {
+	        const center = getCenter(innerPoints);
+	        for (let i = 0; i < innerPoints.length; ++i) {
+	            const p = innerPoints[i];
+	            p.angle = Math.atan2(p.x - center.x, p.y - center.y);
+	        }
+	        innerPoints.sort(function (a, b) {
+	            return b.angle - a.angle;
+	        });
+	        let p2 = innerPoints[innerPoints.length - 1];
+	        for (let i = 0; i < innerPoints.length; ++i) {
+	            const p1 = innerPoints[i];
+	            polygonArea += (p2.x + p1.x) * (p1.y - p2.y);
+	            const midPoint = { x: (p1.x + p2.x) / 2, y: (p1.y + p2.y) / 2 };
+	            let arc = null;
+	            for (let j = 0; j < p1.parentIndex.length; ++j) {
+	                if (p2.parentIndex.indexOf(p1.parentIndex[j]) > -1) {
+	                    const circle = circles[p1.parentIndex[j]];
+	                    const a1 = Math.atan2(p1.x - circle.x, p1.y - circle.y);
+	                    const a2 = Math.atan2(p2.x - circle.x, p2.y - circle.y);
+	                    let angleDiff = a2 - a1;
+	                    if (angleDiff < 0) {
+	                        angleDiff += 2 * Math.PI;
+	                    }
+	                    const a = a2 - angleDiff / 2;
+	                    let width = PointService.distancePP(midPoint, {
+	                        x: circle.x + circle.radius * Math.sin(a),
+	                        y: circle.y + circle.radius * Math.cos(a)
+	                    });
+	                    if (width > circle.radius * 2) {
+	                        width = circle.radius * 2;
+	                    }
+	                    if (arc === null || arc.width > width) {
+	                        arc = { circle: circle, width: width, p1: p1, p2: p2 };
+	                    }
+	                }
+	            }
+	            if (arc !== null) {
+	                arcs.push(arc);
+	                arcArea += circleArea(arc.circle.radius, arc.width);
+	                p2 = p1;
+	            }
+	        }
+	    }
+	    else {
+	        let smallest = circles[0];
+	        for (let i = 1; i < circles.length; ++i) {
+	            if (circles[i].radius < smallest.radius) {
+	                smallest = circles[i];
+	            }
+	        }
+	        let disjoint = false;
+	        for (let i = 0; i < circles.length; ++i) {
+	            if (PointService.distancePP(circles[i], smallest) > Math.abs(smallest.radius - circles[i].radius)) {
+	                disjoint = true;
+	                break;
+	            }
+	        }
+	        if (disjoint) {
+	            arcArea = polygonArea = 0;
+	        }
+	        else {
+	            arcArea = smallest.radius * smallest.radius * Math.PI;
+	            arcs.push({
+	                circle: smallest,
+	                p1: { x: smallest.x, y: smallest.y + smallest.radius },
+	                p2: { x: smallest.x - SMALL, y: smallest.y + smallest.radius },
+	                width: smallest.radius * 2
+	            });
+	        }
+	    }
+	    polygonArea /= 2;
+	    if (stats) {
+	        stats.area = arcArea + polygonArea;
+	        stats.arcArea = arcArea;
+	        stats.polygonArea = polygonArea;
+	        stats.arcs = arcs;
+	        stats.innerPoints = innerPoints;
+	        stats.intersectionPoints = intersectionPoints;
+	    }
+	    return arcArea + polygonArea;
+	}
+	function containedInCircles(point, circles) {
+	    for (let i = 0; i < circles.length; ++i) {
+	        if (PointService.distancePP(point, circles[i]) > circles[i].radius + SMALL) {
+	            return false;
+	        }
+	    }
+	    return true;
+	}
+	function getIntersectionPoints(circles) {
+	    const ret = [];
+	    for (let i = 0; i < circles.length; ++i) {
+	        for (let j = i + 1; j < circles.length; ++j) {
+	            const intersect = circleCircleIntersection(circles[i], circles[j]);
+	            for (let k = 0; k < intersect.length; ++k) {
+	                const p = intersect[k];
+	                p.parentIndex = [i, j];
+	                ret.push(p);
+	            }
+	        }
+	    }
+	    return ret;
+	}
+	function circleArea(r, width) {
+	    return r * r * Math.acos(1 - width / r) - (r - width) * Math.sqrt(width * (2 * r - width));
+	}
+	function circleOverlap(r1, r2, d) {
+	    if (d >= r1 + r2) {
+	        return 0;
+	    }
+	    if (d <= Math.abs(r1 - r2)) {
+	        return Math.PI * Math.min(r1, r2) * Math.min(r1, r2);
+	    }
+	    const w1 = r1 - (d * d - r2 * r2 + r1 * r1) / (2 * d);
+	    const w2 = r2 - (d * d - r1 * r1 + r2 * r2) / (2 * d);
+	    return circleArea(r1, w1) + circleArea(r2, w2);
+	}
+	function circleCircleIntersection(p1, p2) {
+	    const d = PointService.distancePP(p1, p2);
+	    const r1 = p1.radius;
+	    const r2 = p2.radius;
+	    if (d >= r1 + r2 || d <= Math.abs(r1 - r2)) {
+	        return [];
+	    }
+	    const a = (r1 * r1 - r2 * r2 + d * d) / (2 * d);
+	    const h = Math.sqrt(r1 * r1 - a * a);
+	    const x0 = p1.x + (a * (p2.x - p1.x)) / d;
+	    const y0 = p1.y + (a * (p2.y - p1.y)) / d;
+	    const rx = -(p2.y - p1.y) * (h / d);
+	    const ry = -(p2.x - p1.x) * (h / d);
+	    return [
+	        { x: x0 + rx, y: y0 - ry },
+	        { x: x0 - rx, y: y0 + ry }
+	    ];
+	}
+	function getCenter(points) {
+	    const center = { x: 0, y: 0 };
+	    for (let i = 0; i < points.length; ++i) {
+	        center.x += points[i].x;
+	        center.y += points[i].y;
+	    }
+	    center.x /= points.length;
+	    center.y /= points.length;
+	    return center;
+	}
+
 	class TimeUtil {
 	    static getInstance() {
 	        if (!TimeUtil.instance) {
@@ -5462,6 +5619,282 @@
 	    };
 	}
 
+	function zeros(x) {
+	    const r = new Array(x);
+	    for (let i = 0; i < x; ++i) {
+	        r[i] = 0;
+	    }
+	    return r;
+	}
+	function zerosM(x, y) {
+	    return zeros(x).map(function () {
+	        return zeros(y);
+	    });
+	}
+	function dot(a, b) {
+	    let ret = 0;
+	    for (let i = 0; i < a.length; ++i) {
+	        ret += a[i] * b[i];
+	    }
+	    return ret;
+	}
+	function norm2(a) {
+	    return Math.sqrt(dot(a, a));
+	}
+	function scale(ret, value, c) {
+	    for (let i = 0; i < value.length; ++i) {
+	        ret[i] = value[i] * c;
+	    }
+	}
+	function weightedSum(ret, w1, v1, w2, v2) {
+	    for (let j = 0; j < ret.length; ++j) {
+	        ret[j] = w1 * v1[j] + w2 * v2[j];
+	    }
+	}
+	function gemv(output, A, x) {
+	    for (let i = 0; i < output.length; ++i) {
+	        output[i] = dot(A[i], x);
+	    }
+	}
+
+	function nelderMead(f, x0, parameters) {
+	    parameters = parameters || {};
+	    const maxIterations = parameters.maxIterations || x0.length * 200;
+	    const nonZeroDelta = parameters.nonZeroDelta || 1.05;
+	    const zeroDelta = parameters.zeroDelta || 0.001;
+	    const minErrorDelta = parameters.minErrorDelta || 1e-6;
+	    const minTolerance = parameters.minErrorDelta || 1e-5;
+	    const rho = parameters.rho !== undefined ? parameters.rho : 1;
+	    const chi = parameters.chi !== undefined ? parameters.chi : 2;
+	    const psi = parameters.psi !== undefined ? parameters.psi : -0.5;
+	    const sigma = parameters.sigma !== undefined ? parameters.sigma : 0.5;
+	    let maxDiff;
+	    const N = x0.length;
+	    const simplex = new Array(N + 1);
+	    simplex[0] = x0;
+	    simplex[0].fx = f(x0);
+	    simplex[0].id = 0;
+	    for (let i = 0; i < N; ++i) {
+	        const point = x0.slice();
+	        point[i] = point[i] ? point[i] * nonZeroDelta : zeroDelta;
+	        simplex[i + 1] = point;
+	        simplex[i + 1].fx = f(point);
+	        simplex[i + 1].id = i + 1;
+	    }
+	    function updateSimplex(value) {
+	        for (let i = 0; i < value.length; i++) {
+	            simplex[N][i] = value[i];
+	        }
+	        simplex[N].fx = value.fx;
+	    }
+	    const sortOrder = function (a, b) {
+	        return a.fx - b.fx;
+	    };
+	    const centroid = x0.slice();
+	    const reflected = x0.slice();
+	    const contracted = x0.slice();
+	    const expanded = x0.slice();
+	    for (let iteration = 0; iteration < maxIterations; ++iteration) {
+	        simplex.sort(sortOrder);
+	        if (parameters.history) {
+	            const sortedSimplex = simplex.map(function (x) {
+	                const state = x.slice();
+	                state.fx = x.fx;
+	                state.id = x.id;
+	                return state;
+	            });
+	            sortedSimplex.sort(function (a, b) {
+	                return a.id - b.id;
+	            });
+	            parameters.history.push({ x: simplex[0].slice(), fx: simplex[0].fx, simplex: sortedSimplex });
+	        }
+	        maxDiff = 0;
+	        for (let i = 0; i < N; ++i) {
+	            maxDiff = Math.max(maxDiff, Math.abs(simplex[0][i] - simplex[1][i]));
+	        }
+	        if (Math.abs(simplex[0].fx - simplex[N].fx) < minErrorDelta && maxDiff < minTolerance) {
+	            break;
+	        }
+	        for (let i = 0; i < N; ++i) {
+	            centroid[i] = 0;
+	            for (let j = 0; j < N; ++j) {
+	                centroid[i] += simplex[j][i];
+	            }
+	            centroid[i] /= N;
+	        }
+	        const worst = simplex[N];
+	        weightedSum(reflected, 1 + rho, centroid, -rho, worst);
+	        reflected.fx = f(reflected);
+	        if (reflected.fx < simplex[0].fx) {
+	            weightedSum(expanded, 1 + chi, centroid, -chi, worst);
+	            expanded.fx = f(expanded);
+	            if (expanded.fx < reflected.fx) {
+	                updateSimplex(expanded);
+	            }
+	            else {
+	                updateSimplex(reflected);
+	            }
+	        }
+	        else if (reflected.fx >= simplex[N - 1].fx) {
+	            let shouldReduce = false;
+	            if (reflected.fx > worst.fx) {
+	                weightedSum(contracted, 1 + psi, centroid, -psi, worst);
+	                contracted.fx = f(contracted);
+	                if (contracted.fx < worst.fx) {
+	                    updateSimplex(contracted);
+	                }
+	                else {
+	                    shouldReduce = true;
+	                }
+	            }
+	            else {
+	                weightedSum(contracted, 1 - psi * rho, centroid, psi * rho, worst);
+	                contracted.fx = f(contracted);
+	                if (contracted.fx < reflected.fx) {
+	                    updateSimplex(contracted);
+	                }
+	                else {
+	                    shouldReduce = true;
+	                }
+	            }
+	            if (shouldReduce) {
+	                if (sigma >= 1) {
+	                    break;
+	                }
+	                for (let i = 1; i < simplex.length; ++i) {
+	                    weightedSum(simplex[i], 1 - sigma, simplex[0], sigma, simplex[i]);
+	                    simplex[i].fx = f(simplex[i]);
+	                }
+	            }
+	        }
+	        else {
+	            updateSimplex(reflected);
+	        }
+	    }
+	    simplex.sort(sortOrder);
+	    return { fx: simplex[0].fx, x: simplex[0] };
+	}
+
+	function wolfeLineSearch(f, pk, current, next, a, c1, c2) {
+	    const phi0 = current.fx;
+	    const phiPrime0 = dot(current.fxprime, pk);
+	    let phi = phi0;
+	    let phi_old = phi0;
+	    let phiPrime = phiPrime0;
+	    let a0 = 0;
+	    a = a || 1;
+	    c1 = c1 || 1e-6;
+	    c2 = c2 || 0.1;
+	    function zoom(a_lo, a_high, phi_lo) {
+	        for (let iteration = 0; iteration < 16; ++iteration) {
+	            a = (a_lo + a_high) / 2;
+	            weightedSum(next.x, 1.0, current.x, a, pk);
+	            phi = next.fx = f(next.x, next.fxprime);
+	            phiPrime = dot(next.fxprime, pk);
+	            if (phi > phi0 + c1 * a * phiPrime0 || phi >= phi_lo) {
+	                a_high = a;
+	            }
+	            else {
+	                if (Math.abs(phiPrime) <= -c2 * phiPrime0) {
+	                    return a;
+	                }
+	                if (phiPrime * (a_high - a_lo) >= 0) {
+	                    a_high = a_lo;
+	                }
+	                a_lo = a;
+	                phi_lo = phi;
+	            }
+	        }
+	        return 0;
+	    }
+	    for (let iteration = 0; iteration < 10; ++iteration) {
+	        weightedSum(next.x, 1.0, current.x, a, pk);
+	        phi = next.fx = f(next.x, next.fxprime);
+	        phiPrime = dot(next.fxprime, pk);
+	        if (phi > phi0 + c1 * a * phiPrime0 || (iteration && phi >= phi_old)) {
+	            return zoom(a0, a, phi_old);
+	        }
+	        if (Math.abs(phiPrime) <= -c2 * phiPrime0) {
+	            return a;
+	        }
+	        if (phiPrime >= 0) {
+	            return zoom(a, a0, phi);
+	        }
+	        phi_old = phi;
+	        a0 = a;
+	        a *= 2;
+	    }
+	    return a;
+	}
+
+	function conjugateGradient(f, initial, params) {
+	    let current = { x: initial.slice(), fx: 0, fxprime: initial.slice() };
+	    let next = { x: initial.slice(), fx: 0, fxprime: initial.slice() };
+	    const yk = initial.slice();
+	    let temp;
+	    let a = 1;
+	    params = params || {};
+	    const maxIterations = params.maxIterations || initial.length * 20;
+	    current.fx = f(current.x, current.fxprime);
+	    const pk = current.fxprime.slice();
+	    scale(pk, current.fxprime, -1);
+	    for (let i = 0; i < maxIterations; ++i) {
+	        a = wolfeLineSearch(f, pk, current, next, a);
+	        if (params.history) {
+	            params.history.push({ x: current.x.slice(), fx: current.fx, fxprime: current.fxprime.slice(), alpha: a });
+	        }
+	        if (!a) {
+	            scale(pk, current.fxprime, -1);
+	        }
+	        else {
+	            weightedSum(yk, 1, next.fxprime, -1, current.fxprime);
+	            const delta_k = dot(current.fxprime, current.fxprime);
+	            const beta_k = Math.max(0, dot(yk, next.fxprime) / delta_k);
+	            weightedSum(pk, beta_k, pk, -1, next.fxprime);
+	            temp = current;
+	            current = next;
+	            next = temp;
+	        }
+	        if (norm2(current.fxprime) <= 1e-5) {
+	            break;
+	        }
+	    }
+	    if (params.history) {
+	        params.history.push({ x: current.x.slice(), fx: current.fx, fxprime: current.fxprime.slice(), alpha: a });
+	    }
+	    return current;
+	}
+
+	function findZeroOfFunction(f, a, b, parameters) {
+	    parameters = parameters || {};
+	    const maxIterations = parameters.maxIterations || 100;
+	    const tolerance = parameters.tolerance || 1e-10;
+	    const fA = f(a);
+	    const fB = f(b);
+	    let delta = b - a;
+	    if (fA * fB > 0) {
+	        throw 'Initial bisect points must have opposite signs';
+	    }
+	    if (fA === 0) {
+	        return a;
+	    }
+	    if (fB === 0) {
+	        return b;
+	    }
+	    for (let i = 0; i < maxIterations; ++i) {
+	        delta /= 2;
+	        const mid = a + delta;
+	        const fMid = f(mid);
+	        if (fMid * fA >= 0) {
+	            a = mid;
+	        }
+	        if (Math.abs(delta) < tolerance || fMid === 0) {
+	            return mid;
+	        }
+	    }
+	    return a + delta;
+	}
+
 	exports.AABBBounds = AABBBounds;
 	exports.Bounds = Bounds;
 	exports.Color = Color;
@@ -5488,6 +5921,7 @@
 	exports.PolarPoint = PolarPoint;
 	exports.RGB = RGB;
 	exports.SECOND = SECOND;
+	exports.SMALL = SMALL;
 	exports.SUBDIVISION_MAX_ITERATIONS = SUBDIVISION_MAX_ITERATIONS;
 	exports.SUBDIVISION_PRECISION = SUBDIVISION_PRECISION;
 	exports.TextMeasure = TextMeasure;
@@ -5501,6 +5935,9 @@
 	exports.asin = asin;
 	exports.atan2 = atan2;
 	exports.bisect = bisect;
+	exports.circleArea = circleArea;
+	exports.circleCircleIntersection = circleCircleIntersection;
+	exports.circleOverlap = circleOverlap;
 	exports.clamp = clamp;
 	exports.clampAngleByDegree = clampAngleByDegree;
 	exports.clampAngleByRadian = clampAngleByRadian;
@@ -5510,7 +5947,9 @@
 	exports.clamper = clamper;
 	exports.clone = clone;
 	exports.cloneDeep = cloneDeep;
+	exports.conjugateGradient = conjugateGradient;
 	exports.constant = constant;
+	exports.containedInCircles = containedInCircles;
 	exports.cos = cos;
 	exports.crossProduct = crossProduct;
 	exports.crossProductPoint = crossProductPoint;
@@ -5525,9 +5964,11 @@
 	exports.degreeToRadian = degreeToRadian;
 	exports.destination = destination;
 	exports.deviation = deviation;
+	exports.dot = dot;
 	exports.eastAsianCharacterInfo = eastAsianCharacterInfo;
 	exports.epsilon = epsilon;
 	exports.exponent = exponent;
+	exports.findZeroOfFunction = findZeroOfFunction;
 	exports.fixPrecision = fixPrecision;
 	exports.flattenArray = flattenArray;
 	exports.formatNumerals = formatNumerals;
@@ -5537,12 +5978,14 @@
 	exports.fullYearSetterName = fullYearSetterName;
 	exports.fuzzyEqualNumber = fuzzyEqualNumber;
 	exports.fuzzyEqualVec = fuzzyEqualVec;
+	exports.gemv = gemv;
 	exports.generateCeil = generateCeil;
 	exports.generateCount = generateCount;
 	exports.generateStepInterval = generateStepInterval;
 	exports.get = get;
 	exports.getAABBFromPoints = getAABBFromPoints;
 	exports.getAngleByPoint = getAngleByPoint;
+	exports.getCenter = getCenter;
 	exports.getContainerSize = getContainerSize;
 	exports.getContextFont = getContextFont;
 	exports.getDecimalPlaces = getDecimalPlaces;
@@ -5575,6 +6018,7 @@
 	exports.interpolateNumberRound = interpolateNumberRound;
 	exports.interpolateRgb = interpolateRgb;
 	exports.interpolateString = interpolateString;
+	exports.intersectionArea = intersectionArea;
 	exports.isArray = isArray;
 	exports.isArrayLike = isArrayLike;
 	exports.isBase64 = isBase64;
@@ -5637,6 +6081,8 @@
 	exports.monthGetterName = monthGetterName;
 	exports.monthOffset = monthOffset;
 	exports.monthSetterName = monthSetterName;
+	exports.nelderMead = nelderMead;
+	exports.norm2 = norm2;
 	exports.normalTransform = normalTransform;
 	exports.normalizePadding = normalizePadding;
 	exports.numberSpecifierReg = numberSpecifierReg;
@@ -5664,6 +6110,7 @@
 	exports.rectInsideAnotherRect = rectInsideAnotherRect;
 	exports.rgbToHex = rgbToHex;
 	exports.rgbToHsl = rgbToHsl;
+	exports.scale = scale;
 	exports.secondCount = secondCount;
 	exports.secondField = secondField;
 	exports.secondFloor = secondFloor;
@@ -5711,9 +6158,12 @@
 	exports.utcYearOffset = utcYearOffset;
 	exports.uuid = uuid;
 	exports.variance = variance;
+	exports.weightedSum = weightedSum;
 	exports.yearCount = yearCount;
 	exports.yearField = yearField;
 	exports.yearFloor = yearFloor;
 	exports.yearOffset = yearOffset;
+	exports.zeros = zeros;
+	exports.zerosM = zerosM;
 
 }));