core-graphics/lib/utils/math.js

A core library for creating shape-based graphic editors

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.interpolateLinear = interpolateLinear;
exports.approxEqual = approxEqual;
exports.sign = sign;
exports.modulus = modulus;
exports.padNumAbs = padNumAbs;
exports.dist = dist;
exports.lenV = lenV;
exports.normalizeV = normalizeV;
exports.manhattanNormalizeV = manhattanNormalizeV;
exports.getClosestPoint = getClosestPoint;
var EPS = 1e-20;
function interpolateLinear(payload, x) {
    var a = payload.a;
    var b = payload.b;
    var c = payload.c;
    var d = payload.d;

    if (approxEqual(b, a)) {
        return c + d / 2;
    } // a ~= b leads to an undefined result
    var relative = (x - a) / (b - a);
    return relative * (d - c) + c;
}
function approxEqual(a, b) {
    return Math.abs(b - a) < EPS;
}
function sign(x) {
    if (x < 0) {
        return -1;
    }
    if (x > 0) {
        return 1;
    }
    return 0;
}
function modulus(val, base) {
    return (val % base + base) % base;
}
function padNumAbs(params) {
    var x = params.x;
    var _params$minAbs = params.minAbs;
    var minAbs = _params$minAbs === undefined ? 0 : _params$minAbs;
    var _params$maxAbs = params.maxAbs;
    var maxAbs = _params$maxAbs === undefined ? +Infinity : _params$maxAbs;

    if (x === 0) {
        return minAbs;
    }
    var abs = Math.abs(x);
    var sgn = sign(x);
    if (abs < maxAbs && abs > minAbs) {
        return x;
    }
    if (abs >= maxAbs) {
        return maxAbs * sgn;
    }
    if (abs <= minAbs) {
        return minAbs * sgn;
    }
}
function dist(a, b) {
    var dx = Math.abs(a.x - b.x);
    var dy = Math.abs(a.y - b.y);
    return Math.sqrt(dx * dx + dy * dy);
}
function lenV(v) {
    return dist(v, { x: 0, y: 0 });
}
function normalizeV(v) {
    var len = lenV(v);
    if (len < EPS) {
        return v;
    }
    return {
        x: v.x / len,
        y: v.y / len
    };
}
function manhattanNormalizeV(v) {
    var x = v.x;
    var y = v.y;

    var distX = Math.abs(x);
    var distY = Math.abs(y);
    if (distX + distY < EPS) {
        return v;
    }
    if (distX > distY) {
        return {
            x: x / distX,
            y: y / distX
        };
    } else {
        return {
            x: x / distY,
            y: y / distY
        };
    }
}
function getClosestPoint(points, to) {
    if (points.length === 0) {
        return to;
    }
    if (points.length === 1) {
        return points[0];
    }

    var _points$reduce = points.reduce(function (res, curr) {
        var currDist = dist(curr, to);
        return currDist < res.minDist ? { minDist: currDist, minPoint: curr } : res;
    }, { minDist: +Infinity, minPoint: points[0] });

    var minPoint = _points$reduce.minPoint;

    return minPoint;
}