dgeoutils 2.4.41 → 2.4.44

package/dist/cjs/utils.js

@@ -1,280 +0,0 @@
-"use strict";
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseDegreesMinutesSeconds = exports.toDegreesMinutesSeconds = exports.div = exports.getCombinations = exports.cartesianProduct = exports.createCanvas = exports.gaussianElimination = exports.createMatrix = exports.createArray = exports.checkFunction = exports.isDefAndNotNull = exports.warn = exports.DGeo = void 0;
-var DPoint_1 = require("./DPoint");
-exports.DGeo = {
-    DEBUG: false,
-    parseFormat: 'xyz'
-};
-var warn = function () {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
-    if (exports.DGeo.DEBUG) {
-        console.warn.apply(console, __spreadArray([], __read(args), false));
-    }
-};
-exports.warn = warn;
-var isDefAndNotNull = function (a) { return a != undefined; };
-exports.isDefAndNotNull = isDefAndNotNull;
-var hook = function (scope) { return function () { return scope; }; };
-var shouldBeInt = function (scope, funcName, argName) { return function (p) {
-    if (!p.clone().round()
-        .equal(p)) {
-        (0, exports.warn)("\"".concat(funcName, "\" -> \"").concat(argName, "\" should be Int!"));
-    }
-    return scope;
-}; };
-var shouldBeUInt = function (scope, funcName, argName) { return function (p) {
-    if (!p.clone().round()
-        .equal(p) || !p.gtOrEqual(DPoint_1.DPoint.zero())) {
-        (0, exports.warn)("\"".concat(funcName, "\" -> \"").concat(argName, "\" should be UInt!"));
-    }
-    return scope;
-}; };
-var shouldBeDegree = function (scope, funcName, argName) { return function (p) {
-    if (!p.likeWorldGeodeticSystem) {
-        (0, exports.warn)("\"".concat(funcName, "\" -> \"").concat(argName, "\" should be degree!"));
-    }
-    return scope;
-}; };
-var shouldBeRadians = function (scope, funcName, argName) { return function (p) {
-    if (!p.likeRadians) {
-        (0, exports.warn)("\"".concat(funcName, "\" -> \"").concat(argName, "\" should be radians!"));
-    }
-    return scope;
-}; };
-var shouldExist = function (scope, funcName, argName) { return function (p) {
-    if (!(0, exports.isDefAndNotNull)(p)) {
-        (0, exports.warn)("\"".concat(funcName, "\" -> \"").concat(argName, "\" should exist!"));
-    }
-    return scope;
-}; };
-var shouldBeMeters = function (scope, funcName, argName) { return function (p) {
-    if (!p.likePseudoMercator) {
-        (0, exports.warn)("\"".concat(funcName, "\" -> \"").concat(argName, "\" should be meters!"));
-    }
-    return scope;
-}; };
-var checkFunction = function (funcName) { return ({
-    checkArgument: function (argName) {
-        if (!exports.DGeo.DEBUG) {
-            return {
-                shouldBeDegree: hook(this),
-                shouldBeMeters: hook(this),
-                shouldBeInt: hook(this),
-                shouldBeUInt: hook(this),
-                shouldBeRadians: hook(this),
-                shouldExist: hook(this)
-            };
-        }
-        return {
-            shouldBeDegree: shouldBeDegree(this, funcName, argName),
-            shouldBeMeters: shouldBeMeters(this, funcName, argName),
-            shouldBeInt: shouldBeInt(this, funcName, argName),
-            shouldBeUInt: shouldBeUInt(this, funcName, argName),
-            shouldBeRadians: shouldBeRadians(this, funcName, argName),
-            shouldExist: shouldExist(this, funcName, argName)
-        };
-    }
-}); };
-exports.checkFunction = checkFunction;
-var createArray = function (v, fillSymbol) {
-    if (typeof fillSymbol === 'function') {
-        return new Array(v).fill(false)
-            .map(function (_, i) { return fillSymbol(i); });
-    }
-    return new Array(v).fill(fillSymbol !== null && fillSymbol !== void 0 ? fillSymbol : 0);
-};
-exports.createArray = createArray;
-var createMatrix = function (_a, fillSymbol) {
-    var h = _a.h, w = _a.w;
-    if (typeof fillSymbol === 'function') {
-        return (0, exports.createArray)(h)
-            .map(function (_, y) { return (0, exports.createArray)(w, function (x) { return fillSymbol(x, y); }); });
-    }
-    return (0, exports.createArray)(h)
-        .map(function () { return (0, exports.createArray)(w, fillSymbol); });
-};
-exports.createMatrix = createMatrix;
-var gaussianElimination = function (matrix) {
-    var n = matrix.length;
-    var matrixClone = (0, exports.createMatrix)(new DPoint_1.DPoint(n + 1, n));
-    for (var i = 0; i < n; i++) {
-        for (var j = 0; j < n + 1; j++) {
-            matrix[i][j] = matrix[i][j] === 0 ? exports.gaussianElimination.MIN : matrix[i][j];
-            matrixClone[i][j] = matrix[i][j];
-        }
-    }
-    for (var k = 0; k < n; k++) {
-        for (var i = 0; i < n + 1; i++) {
-            matrixClone[k][i] /= matrix[k][k];
-        }
-        for (var i = k + 1; i < n; i++) {
-            var K = matrixClone[i][k] / matrixClone[k][k];
-            for (var j = 0; j < n + 1; j++) {
-                matrixClone[i][j] -= matrixClone[k][j] * K;
-            }
-        }
-        for (var i = 0; i < n; i++) {
-            for (var j = 0; j < n + 1; j++) {
-                matrix[i][j] = matrixClone[i][j];
-            }
-        }
-    }
-    for (var k = n - 1; k > -1; k--) {
-        for (var i = n; i > -1; i--) {
-            matrixClone[k][i] /= matrix[k][k];
-        }
-        for (var i = k - 1; i > -1; i--) {
-            var K = matrixClone[i][k] / matrixClone[k][k];
-            for (var j = n; j > -1; j--) {
-                matrixClone[i][j] -= matrixClone[k][j] * K;
-            }
-        }
-    }
-    var answer = (0, exports.createArray)(n);
-    for (var i = 0; i < n; i++) {
-        answer[i] = matrixClone[i][n];
-    }
-    return answer;
-};
-exports.gaussianElimination = gaussianElimination;
-exports.gaussianElimination.MIN = 1e-10;
-var createCanvas = function (a, b, c) {
-    var _a;
-    var w = 0;
-    var h = 0;
-    var offscreen = false;
-    if (a instanceof DPoint_1.DPoint) {
-        var x = a.x, y = a.y;
-        w = x;
-        h = y;
-    }
-    else {
-        w = a;
-        h = a;
-    }
-    if (typeof b === 'boolean') {
-        offscreen = b;
-    }
-    else if (typeof b === 'number') {
-        h = b;
-    }
-    if (typeof c === 'boolean') {
-        offscreen = c;
-    }
-    var canvas = offscreen ? new OffscreenCanvas(w, h) : ((_a = exports.createCanvas.document) !== null && _a !== void 0 ? _a : document).createElement('canvas');
-    if (!offscreen) {
-        canvas.width = w;
-        canvas.height = h;
-    }
-    return [canvas, canvas.getContext('2d')];
-};
-exports.createCanvas = createCanvas;
-var f = function (a, b) { return [].concat.apply([], __spreadArray([], __read(a.map(function (c) { return b.map(function (d) { return [].concat(c, d); }); })), false)); };
-var cartesianProduct = function (a, b) {
-    var c = [];
-    for (var _i = 2; _i < arguments.length; _i++) {
-        c[_i - 2] = arguments[_i];
-    }
-    return b ? exports.cartesianProduct.apply(void 0, __spreadArray([f(a, b)], __read(c), false)) : a;
-};
-exports.cartesianProduct = cartesianProduct;
-var getCombinations = function (arr) {
-    if (arr.length === 1) {
-        return arr[0];
-    }
-    var ans = [];
-    var otherCases = (0, exports.getCombinations)(arr.slice(1));
-    for (var i = 0; i < otherCases.length; i++) {
-        for (var j = 0; j < arr[0].length; j++) {
-            ans.push(__spreadArray([arr[0][j]], __read(otherCases[i]), false));
-        }
-    }
-    return ans;
-};
-exports.getCombinations = getCombinations;
-var div = function (a, b) { return Math.floor(a / b); };
-exports.div = div;
-var toDegreesMinutesSeconds = function (v) {
-    var degrees = Math.floor(v);
-    var t = (v % 1) * 60;
-    var minutes = Math.floor(t);
-    var t2 = (t % 1) * 60;
-    var seconds = t2.toFixed(2);
-    return "".concat(degrees, "\u00B0 ").concat(minutes, "' ").concat(seconds, "\"");
-};
-exports.toDegreesMinutesSeconds = toDegreesMinutesSeconds;
-var parseDegreesMinutesSeconds = function (i) {
-    var e_1, _a;
-    var _b, _c, _d, _e, _f, _g, _h;
-    var parts = i.matchAll(/(?<value>-?\d+(?<tail>\.\d{1,})?)(?<type>°|'|")/gmiu);
-    var d = 0;
-    var m = 0;
-    var s = 0;
-    try {
-        for (var parts_1 = __values(parts), parts_1_1 = parts_1.next(); !parts_1_1.done; parts_1_1 = parts_1.next()) {
-            var part = parts_1_1.value;
-            switch ((_b = part === null || part === void 0 ? void 0 : part.groups) === null || _b === void 0 ? void 0 : _b.type) {
-                case '°':
-                    d = Number((_d = (_c = part === null || part === void 0 ? void 0 : part.groups) === null || _c === void 0 ? void 0 : _c.value) !== null && _d !== void 0 ? _d : '0');
-                    break;
-                case '\'':
-                    m = Number((_f = (_e = part === null || part === void 0 ? void 0 : part.groups) === null || _e === void 0 ? void 0 : _e.value) !== null && _f !== void 0 ? _f : '0');
-                    break;
-                case '"':
-                    s = Number((_h = (_g = part === null || part === void 0 ? void 0 : part.groups) === null || _g === void 0 ? void 0 : _g.value) !== null && _h !== void 0 ? _h : '0');
-                    break;
-                default:
-            }
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (parts_1_1 && !parts_1_1.done && (_a = parts_1.return)) _a.call(parts_1);
-        }
-        finally { if (e_1) throw e_1.error; }
-    }
-    var h = d < 0 ? -1 : 1;
-    return d + h * m / 60 + h * s / 3600;
-};
-exports.parseDegreesMinutesSeconds = parseDegreesMinutesSeconds;

package/dist/es2015/DCircle.js

@@ -1,87 +0,0 @@
-import { DPoint, EARTH_RADIUS_IN_METERS } from './DPoint';
-import { DPolygon } from './DPolygon';
-import { checkFunction } from './utils';
-export class DCircle {
-    constructor(center = DPoint.zero(), r = 0) {
-        this.center = center;
-        this.r = r;
-    }
-    toString() {
-        return `(${this.center.toString()}, ${this.r})`;
-    }
-    getValue() {
-        return { center: this.center, r: this.r };
-    }
-    clone() {
-        return new DCircle(this.center, this.r);
-    }
-    findPoints(c) {
-        if (this.equal(c)) {
-            return Infinity;
-        }
-        const { center: { x: x0, y: y0 }, r: r0 } = this;
-        const { center: { x: x1, y: y1 }, r: r1 } = c;
-        const r02 = r0 * r0;
-        const d = this.center.distance(c.center);
-        const a = (r02 - r1 * r1 + d * d) / (2 * d);
-        const h = Math.sqrt(r02 - a * a);
-        const ad = a / d;
-        const dy = y1 - y0;
-        const dx = x1 - x0;
-        const hd = h / d;
-        const x2 = x0 + ad * (x1 - x0);
-        const y2 = y0 + ad * (y1 - y0);
-        const x31 = x2 + hd * dy;
-        const y31 = y2 - hd * dx;
-        const x32 = x2 - hd * dy;
-        const y32 = y2 + hd * dx;
-        const res = [];
-        if (!isNaN(x31) && !isNaN(y31)) {
-            res.push(new DPoint(x31, y31));
-        }
-        if (!isNaN(x32) && !isNaN(y32) && !(x31 === x32 && y31 === y32)) {
-            res.push(new DPoint(x32, y32));
-        }
-        return res;
-    }
-    equal({ center, r }) {
-        return this.center.equal(center) && this.r === r;
-    }
-    findPolygonInside(pointCount = 64, startAngle = 0, stopAngle = 2 * Math.PI) {
-        const step = 2 * Math.PI / pointCount;
-        const points = [];
-        let angle = startAngle;
-        while (angle < stopAngle - step) {
-            points.push(new DPoint(this.r).scale(Math.cos(angle), Math.sin(angle))
-                .move(this.center));
-            angle += step;
-        }
-        const x = this.r * Math.cos(stopAngle) + this.center.x;
-        const y = this.r * Math.sin(stopAngle) + this.center.y;
-        points.push(new DPoint(x, y));
-        return new DPolygon(points);
-    }
-    findPolygonInsideOnSphere(pointCount = 64, startAngle = 0, stopAngle = 2 * Math.PI) {
-        checkFunction('findPolygonInsideOnSphere')
-            .checkArgument('center')
-            .shouldBeDegree(this.center);
-        const step = 2 * Math.PI / pointCount;
-        const points = [];
-        let angle = startAngle;
-        while (angle < stopAngle - step) {
-            points.push(this.sphereOffset(angle));
-            angle += step;
-        }
-        points.push(this.sphereOffset(stopAngle));
-        return new DPolygon(points);
-    }
-    sphereOffset(bearing, earthRadius = EARTH_RADIUS_IN_METERS) {
-        const { x: lon1, y: lat1 } = this.center.clone().degreeToRadians();
-        const dByR = this.r / earthRadius;
-        const lat = Math.asin(Math.sin(lat1) * Math.cos(dByR) +
-            Math.cos(lat1) * Math.sin(dByR) * Math.cos(bearing));
-        const lon = lon1 +
-            Math.atan2(Math.sin(bearing) * Math.sin(dByR) * Math.cos(lat1), Math.cos(dByR) - Math.sin(lat1) * Math.sin(lat));
-        return new DPoint(lon, lat).radiansToDegrees();
-    }
-}

package/dist/es2015/DLine.js

@@ -1,290 +0,0 @@
-import { DPoint } from './DPoint';
-import { checkFunction } from './utils';
-import { DNumbers } from './DNumbers';
-import { DPolygon } from './DPolygon';
-export class DLine {
-    constructor(a, b, c, begin = DPoint.zero(), end = DPoint.zero()) {
-        this.a = a;
-        this.b = b;
-        this.c = c;
-        this.begin = begin;
-        this.end = end;
-    }
-    clone() {
-        return new DLine(this.a, this.b, this.c, this.begin.clone(), this.end.clone());
-    }
-    findPerpendicular(p) {
-        checkFunction('findPerpendicular')
-            .checkArgument('this.begin')
-            .shouldBeMeters(this.begin)
-            .checkArgument('this.end')
-            .shouldBeMeters(this.end)
-            .checkArgument('p')
-            .shouldBeMeters(p);
-        return new DLine(-this.b, this.a, this.b * p.x - this.a * p.y);
-    }
-    perpendicularDistance(p) {
-        checkFunction('perpendicularDistance')
-            .checkArgument('this.begin')
-            .shouldBeMeters(this.begin)
-            .checkArgument('this.end')
-            .shouldBeMeters(this.end)
-            .checkArgument('p')
-            .shouldBeMeters(p);
-        const perpendicularLine = this.findPerpendicular(p);
-        const targetPoint = perpendicularLine.findPoint(this);
-        return targetPoint.distance(p);
-    }
-    intersection(l, d = 0, includeOnly = false) {
-        const p = this.findPoint(l);
-        if (p) {
-            if (includeOnly) {
-                return this.insideRange(p, d) && l.insideRange(p, d) ? p : null;
-            }
-            return this.inRange(p, d) && l.inRange(p, d) ? p : null;
-        }
-        return null;
-    }
-    intersectionWithCircle(circle) {
-        const { center, r } = circle;
-        const per = this.findPerpendicular(center);
-        const t = this.findPoint(per);
-        let distance = t.distance(center);
-        if (this.begin.equal(center)) {
-            distance = 0;
-        }
-        if (this.end.equal(center)) {
-            distance = 0;
-        }
-        if (distance < r) {
-            const { a, b, c } = this;
-            if (this.isParallel) {
-                const ct = center.distance(t);
-                const move = Math.sqrt(r * r - ct * ct);
-                if (this.isParallelY) {
-                    t.x = this.begin.x;
-                    const r1 = t.clone().move(0, -move);
-                    const r2 = t.clone().move(0, move);
-                    return [r1, r2];
-                }
-                if (this.isParallelX) {
-                    t.y = this.begin.y;
-                    const r1 = t.clone().move(move, 0);
-                    const r2 = t.clone().move(-move, 0);
-                    return [r1, r2];
-                }
-            }
-            if (this.begin.like(center)) {
-                const p = this.begin.clone();
-                return [this.movePoint(p, r), this.movePoint(p, -r)];
-            }
-            if (this.end.like(center)) {
-                const p = this.end.clone();
-                return [this.movePoint(p, r), this.movePoint(p, -r)];
-            }
-            const s = a * a + b * b;
-            const d = r * r - c * c / s;
-            const mult = Math.sqrt(d / s);
-            const r1 = t.clone().move(b * mult, -a * mult);
-            const r2 = t.clone().move(-b * mult, a * mult);
-            return [r1, r2];
-        }
-        if (distance === r) {
-            return t;
-        }
-        return null;
-    }
-    inRange(p, d = 0) {
-        const { minX, minY, maxX, maxY } = this;
-        const { x, y } = p;
-        const isInX = x >= minX - d && x <= maxX + d;
-        const isInY = y >= minY - d && y <= maxY + d;
-        return isInX && isInY;
-    }
-    insideRange(p, d = 0) {
-        const { begin, end } = this;
-        return this.inRange(p, d) && !begin.like(p, 0.00001) && !end.like(p, 0.00001);
-    }
-    get center() {
-        return this.begin
-            .clone()
-            .setIfLessThan(this.end)
-            .move(this.end
-            .clone()
-            .move(this.begin
-            .clone()
-            .minus())
-            .abs()
-            .minus()
-            .divide(2));
-    }
-    get minX() {
-        return Math.min(this.begin.x, this.end.x);
-    }
-    get minY() {
-        return Math.min(this.begin.y, this.end.y);
-    }
-    get maxX() {
-        return Math.max(this.begin.x, this.end.x);
-    }
-    get maxY() {
-        return Math.max(this.begin.y, this.end.y);
-    }
-    toString() {
-        return `(${this.a}, ${this.b}, ${this.c})`;
-    }
-    getValue() {
-        return [this.a, this.b, this.c];
-    }
-    x(p) {
-        if (this.isParallelY) {
-            return new DPoint(-this.c / this.a, p.y);
-        }
-        if (this.isParallelX) {
-            return new DPoint(p.x, -this.c / this.b);
-        }
-        return new DPoint(-this.b / this.a * p.y - this.c / this.a, p.y);
-    }
-    y(p) {
-        if (this.isParallelY) {
-            return new DPoint(-this.c / this.a, p.y);
-        }
-        if (this.isParallelX) {
-            return new DPoint(p.x, -this.c / this.b);
-        }
-        return new DPoint(p.x, -this.a / this.b * p.x - this.c / this.b);
-    }
-    findPoint(l) {
-        if (this.isParallelY && l.isParallelY) {
-            return null;
-        }
-        if (this.isParallelX && l.isParallelX) {
-            return null;
-        }
-        if (this.isParallelX && l.isParallelY) {
-            return new DPoint(-l.c / l.a, -this.c / this.b);
-        }
-        if (this.isParallelY && l.isParallelX) {
-            return new DPoint(-this.c / this.a, -l.c / l.b);
-        }
-        if (this.isParallelY) {
-            const x = -this.c / this.a;
-            return l.y(new DPoint(x));
-        }
-        if (this.isParallelX) {
-            const y = -this.c / this.b;
-            return l.x(new DPoint(0, y));
-        }
-        if (l.isParallelY) {
-            const x = -l.c / l.a;
-            return this.y(new DPoint(x));
-        }
-        if (l.isParallelX) {
-            const y = -l.c / l.b;
-            return this.x(new DPoint(0, y));
-        }
-        const res = this.y(new DPoint((l.c / l.b - this.c / this.b) / (this.a / this.b - l.a / l.b)));
-        if (!isFinite(res.x) && !isFinite(res.y)) {
-            return null;
-        }
-        return res;
-    }
-    get isParallel() {
-        return this.isParallelX || this.isParallelY;
-    }
-    get isParallelY() {
-        return Math.abs(this.b) < 0.001;
-    }
-    get isParallelX() {
-        return Math.abs(this.a) < 0.001;
-    }
-    get points() {
-        return [this.begin, this.end];
-    }
-    getFi() {
-        checkFunction('getFi')
-            .checkArgument('this.begin')
-            .shouldBeMeters(this.begin)
-            .checkArgument('this.end')
-            .shouldBeMeters(this.end);
-        const { x, y } = this.end.clone().move(this.begin.clone().minus());
-        let v = Math.atan2(y, x) - Math.PI;
-        if (v > 0) {
-            v = Math.PI - v;
-        }
-        return (Math.PI - v) % (Math.PI * 2);
-    }
-    toWKT() {
-        const { begin: { x: x1, y: y1 }, end: { x: x2, y: y2 } } = this;
-        return `LINESTRING (${x1} ${y1}, ${x2} ${y2})`;
-    }
-    movePoint(i, k) {
-        const isArray = Array.isArray(i);
-        const p = isArray ? i : [i];
-        const d = (isArray ? k : [k]);
-        const fi = this.findFi(new DLine(1, 0, 0));
-        const td = this.x(new DPoint(1, 1)).distance(this.x(new DPoint(2, 2))) / 2;
-        const sinCos = new DPoint(Math.sin(fi), Math.cos(fi));
-        const dt = sinCos.clone().scale(td);
-        const p1T = p[0].clone().move(dt.clone().minus());
-        const p2T = p[0].clone().move(dt);
-        let res = [];
-        if (DNumbers.like(this.y(p1T).y, p1T.y) || DNumbers.like(this.y(p2T).y, p2T.y)) {
-            res = p.map((t, index) => t.clone()
-                .move(sinCos.clone().scale(d[index])));
-        }
-        else {
-            res = p.map((t, index) => t.clone()
-                .move(sinCos.clone().scale(d[index])
-                .setX(({ x }) => -x)));
-        }
-        return isArray ? res : res[0];
-    }
-    findFi({ a, b }, delta = 1.0001) {
-        const { a: q, b: w } = this;
-        let val = (q * a + w * b) / (Math.sqrt(q * q + w * w) * Math.sqrt(a * a + b * b));
-        if (val > 1 && val < delta) {
-            val = 1;
-        }
-        else if (val < -1 && val > -delta) {
-            val = -1;
-        }
-        return Math.acos(val);
-    }
-    vectorProduct({ a, b, c }) {
-        const { a: q, b: w, c: e } = this;
-        return new DLine(w * c - e * b, e * a - q * c, q * b - w * a);
-    }
-    bresenhamsLine() {
-        let { x: x0, y: y0 } = this.begin;
-        const { x: x1, y: y1 } = this.end;
-        const dx = Math.abs(x1 - x0);
-        const sx = x0 < x1 ? 1 : -1;
-        const dy = -Math.abs(y1 - y0);
-        const sy = y0 < y1 ? 1 : -1;
-        let error = dx + dy;
-        const res = new DPolygon();
-        while (true) {
-            res.push(new DPoint(x0, y0));
-            if (x0 === x1 && y0 === y1) {
-                break;
-            }
-            const e2 = 2 * error;
-            if (e2 >= dy) {
-                if (x0 === x1) {
-                    break;
-                }
-                error += dy;
-                x0 += sx;
-            }
-            if (e2 <= dx) {
-                if (y0 === y1) {
-                    break;
-                }
-                error += dx;
-                y0 += sy;
-            }
-        }
-        return res;
-    }
-}

package/dist/es2015/DNumbers.js

@@ -1,22 +0,0 @@
-import { DEGREE_TO_PI, DOUBLE_PI_IN_DEGREE, PI_IN_DEGREE, PI_TO_DEGREE } from './DPoint';
-const delta = 0.001;
-export class DNumbers {
-    static like(v, s, d = delta) {
-        return Math.abs(v - s) < d;
-    }
-    static likeZero(v) {
-        return DNumbers.like(v, 0);
-    }
-    static like2PI(v) {
-        return DNumbers.like(DNumbers.rad2Deg(v), DOUBLE_PI_IN_DEGREE);
-    }
-    static likePI(v) {
-        return DNumbers.like(DNumbers.rad2Deg(v), PI_IN_DEGREE);
-    }
-    static rad2Deg(v) {
-        return v * DEGREE_TO_PI;
-    }
-    static deg2Rad(v) {
-        return v * PI_TO_DEGREE;
-    }
-}