dgeoutils 2.4.41 → 2.4.44

package/dist/es2015/TraceMatrix.js

@@ -1,229 +0,0 @@
-import { DPoint } from './DPoint';
-import { DPolygon, MIN_POINTS_IN_VALID_POLYGON } from './DPolygon';
-import { FastSearch } from './FastSearch';
-import { createArray } from './utils';
-export var TraceMatrixValues;
-(function (TraceMatrixValues) {
-    TraceMatrixValues[TraceMatrixValues["f"] = 0] = "f";
-    TraceMatrixValues[TraceMatrixValues["t"] = 1] = "t";
-})(TraceMatrixValues || (TraceMatrixValues = {}));
-const getByPosition = (m, p, defaultValue = TraceMatrixValues.f) => {
-    if (m[p.y] === undefined || m[p.y][p.x] === undefined) {
-        return defaultValue;
-    }
-    return m[p.y][p.x];
-};
-const setByPosition = (m, p, value) => {
-    if (m[p.y] === undefined || m[p.y][p.x] === undefined) {
-        return value;
-    }
-    m[p.y][p.x] = value;
-    return m[p.y][p.x];
-};
-export class TraceMatrix {
-    constructor(s, f) {
-        this.approximation = true;
-        this.findGroupByIndex = (m, s) => {
-            const res = new DPolygon();
-            if (s && getByPosition(m, s) === TraceMatrixValues.t) {
-                res.push(s);
-                let startIndex = 0;
-                const marked = TraceMatrix.createMatrix(this.size, () => TraceMatrixValues.f);
-                setByPosition(marked, s, TraceMatrixValues.t);
-                while (startIndex < res.length) {
-                    const r = res.at(startIndex);
-                    for (let i = -1; i < 2; i++) {
-                        for (let j = -1; j < 2; j++) {
-                            const t = new DPoint(r.x + i, r.y + j);
-                            if (getByPosition(marked, t, TraceMatrixValues.t) === TraceMatrixValues.f &&
-                                getByPosition(m, t, TraceMatrixValues.f) === TraceMatrixValues.t) {
-                                res.push(t);
-                                setByPosition(marked, t, TraceMatrixValues.t);
-                            }
-                        }
-                    }
-                    startIndex++;
-                }
-            }
-            return res;
-        };
-        this.findAllGroupsInMatrix = (m) => {
-            const firstMark = this.findMarked(m);
-            if (!firstMark) {
-                return [];
-            }
-            const group = this.findGroupByIndex(m, firstMark);
-            const groups = [group];
-            let groupSum = group.length;
-            let allGroups = [...group.points];
-            const fs = new FastSearch();
-            fs.add(allGroups);
-            while (groupSum < this.totalCountInMatrix(m)) {
-                let mark = this.findMarked(m);
-                while (mark && fs.find(mark)) {
-                    mark = this.findMarked(m, mark);
-                }
-                const nextGroup = this.findGroupByIndex(m, mark);
-                groupSum += nextGroup.length;
-                allGroups = [...allGroups, ...nextGroup.points];
-                fs.add(nextGroup.points);
-                groups.push(nextGroup);
-            }
-            return groups.filter((g) => g.length > 2);
-        };
-        this.traceGroup = (m, group) => {
-            const traceDirections = [
-                new DPoint(-1, -1),
-                new DPoint(-1, 0),
-                new DPoint(-1, 1),
-                new DPoint(0, 1),
-                new DPoint(1, 1),
-                new DPoint(1, 0),
-                new DPoint(1, -1),
-                new DPoint(0, -1)
-            ];
-            const left = (d) => (d + traceDirections.length + 1) % traceDirections.length;
-            const right = (d) => (d + traceDirections.length - 1) % traceDirections.length;
-            if (group.length < 2) {
-                const t = group.at(0).clone();
-                return new DPolygon([t, t, t]);
-            }
-            const points = new DPolygon();
-            let direction = 0;
-            let prevDirection = Infinity;
-            let p = group.at(0);
-            while (!p.equal(group.at(0)) || points.length < 2) {
-                while (true) {
-                    const nextValue = getByPosition(m, p.clone().move(traceDirections[direction]));
-                    const nextNeighbourValue = getByPosition(m, p.clone().move(traceDirections[left(direction)]));
-                    if (nextValue === TraceMatrixValues.t && nextNeighbourValue === TraceMatrixValues.f) {
-                        break;
-                    }
-                    direction = right(direction);
-                }
-                if (prevDirection !== direction) {
-                    points.push(p);
-                    prevDirection = direction;
-                }
-                p = p.clone().move(traceDirections[direction]);
-                direction = left(left(direction));
-            }
-            if (this.approximation) {
-                return points.approximation().close();
-            }
-            return points.clone().close();
-        };
-        this.createHoleMatrix = (group) => {
-            const fullTraceDirections = [
-                new DPoint(-1, 0),
-                new DPoint(0, 1),
-                new DPoint(1, 0),
-                new DPoint(0, -1)
-            ];
-            group.prepareToFastSearch();
-            const tmpMatrix = TraceMatrix
-                .createMatrix(this.size, (p) => group.fastHas(p) ? TraceMatrixValues.t : TraceMatrixValues.f);
-            const startCoords = new DPolygon();
-            for (let i = 0; i < this.size.w; i++) {
-                startCoords.push(new DPoint(i, -1));
-                startCoords.push(new DPoint(i, this.size.h));
-            }
-            for (let i = 0; i < this.size.h; i++) {
-                startCoords.push(new DPoint(-1, i));
-                startCoords.push(new DPoint(this.size.w, i));
-            }
-            while (startCoords.length) {
-                const point = startCoords.pop();
-                for (const direction of fullTraceDirections) {
-                    const tmpPoint = point.clone().move(direction);
-                    const value = getByPosition(tmpMatrix, tmpPoint, TraceMatrixValues.t);
-                    if (value === TraceMatrixValues.f) {
-                        setByPosition(tmpMatrix, tmpPoint, TraceMatrixValues.t);
-                        startCoords.push(tmpPoint);
-                    }
-                }
-            }
-            const t = this.reverseMatrix(tmpMatrix);
-            return this.totalCountInMatrix(t) ? t : null;
-        };
-        this.size = s.clone().scale(4);
-        const t = TraceMatrix.createMatrix(this.size, (p) => {
-            const { x, y } = p.clone().mod(4);
-            if ([1, 2].includes(x) && [1, 2].includes(y)) {
-                return f(p.clone().div(4));
-            }
-            return TraceMatrixValues.f;
-        });
-        this.m = TraceMatrix.createMatrix(this.size);
-        for (let i = 1; i < this.size.y - 1; i++) {
-            for (let j = 1; j < this.size.x - 1; j++) {
-                if (t[i][j] === TraceMatrixValues.t) {
-                    this.m[i - 1][j - 1] = TraceMatrixValues.t;
-                    this.m[i - 1][j] = TraceMatrixValues.t;
-                    this.m[i - 1][j + 1] = TraceMatrixValues.t;
-                    this.m[i][j - 1] = TraceMatrixValues.t;
-                    this.m[i][j] = TraceMatrixValues.t;
-                    this.m[i][j + 1] = TraceMatrixValues.t;
-                    this.m[i + 1][j - 1] = TraceMatrixValues.t;
-                    this.m[i + 1][j] = TraceMatrixValues.t;
-                    this.m[i + 1][j + 1] = TraceMatrixValues.t;
-                }
-            }
-        }
-    }
-    fullMatrixTrace() {
-        const groups = this.findAllGroupsInMatrix(this.m);
-        const paths = groups.map((g) => this.traceGroup(this.m, g));
-        const holeMatrixs = groups.map(this.createHoleMatrix);
-        const holesGroups = holeMatrixs.map((m) => m && this.findAllGroupsInMatrix(m));
-        const holesPaths = holesGroups.map((hg, index) => hg && hg.map((g) => this
-            .traceGroup(holeMatrixs[index], g)).filter((r) => r.length > MIN_POINTS_IN_VALID_POLYGON));
-        return groups.map((g, index) => {
-            const res = paths[index];
-            if (holesGroups[index] && holesGroups[index].length) {
-                res.holes = holesPaths[index];
-            }
-            return res.loop()
-                .divide(4)
-                .round()
-                .run();
-        });
-    }
-    reverseMatrix(m) {
-        return TraceMatrix.createMatrix(this.size, (p) => getByPosition(m, p) === TraceMatrixValues.f ? TraceMatrixValues.t : TraceMatrixValues.f);
-    }
-    findMarked(m, init) {
-        const s = this.size;
-        let ini = false;
-        for (let i = 0; i < s.w; i++) {
-            for (let j = 0; j < s.h; j++) {
-                if (!ini && init) {
-                    i = init.x;
-                    j = init.y;
-                    ini = true;
-                    continue;
-                }
-                if (getByPosition(m, new DPoint(i, j)) === TraceMatrixValues.t) {
-                    return new DPoint(i, j);
-                }
-            }
-        }
-        return null;
-    }
-    totalCountInMatrix(m) {
-        let res = 0;
-        const s = this.size;
-        for (let i = 0; i < s.w; i++) {
-            for (let j = 0; j < s.h; j++) {
-                if (getByPosition(m, new DPoint(i, j))) {
-                    res++;
-                }
-            }
-        }
-        return res;
-    }
-    static createMatrix(size, f = () => TraceMatrixValues.f) {
-        return createArray(size.h)
-            .map((v, i) => createArray(size.w).map((v2, j) => f(new DPoint(j, i))));
-    }
-}

package/dist/es2015/index.js

@@ -1,11 +0,0 @@
-export * from './DCircle';
-export * from './DLine';
-export * from './DNumbers';
-export * from './DPoint';
-export * from './DPolygon';
-export * from './FastSearch';
-export * from './TraceMatrix';
-export * from './InterpolationMatrix';
-export * from './DPolygonLoop';
-export * from './DPlane';
-export { gaussianElimination, createCanvas, createArray, createMatrix, isDefAndNotNull, cartesianProduct, getCombinations, parseDegreesMinutesSeconds, DGeo } from './utils';

package/dist/es2015/utils.js

@@ -1,207 +0,0 @@
-import { DPoint } from './DPoint';
-export const DGeo = {
-    DEBUG: false,
-    parseFormat: 'xyz'
-};
-export const warn = (...args) => {
-    if (DGeo.DEBUG) {
-        console.warn(...args);
-    }
-};
-export const isDefAndNotNull = (a) => a != undefined;
-const hook = (scope) => () => scope;
-const shouldBeInt = (scope, funcName, argName) => (p) => {
-    if (!p.clone().round()
-        .equal(p)) {
-        warn(`"${funcName}" -> "${argName}" should be Int!`);
-    }
-    return scope;
-};
-const shouldBeUInt = (scope, funcName, argName) => (p) => {
-    if (!p.clone().round()
-        .equal(p) || !p.gtOrEqual(DPoint.zero())) {
-        warn(`"${funcName}" -> "${argName}" should be UInt!`);
-    }
-    return scope;
-};
-const shouldBeDegree = (scope, funcName, argName) => (p) => {
-    if (!p.likeWorldGeodeticSystem) {
-        warn(`"${funcName}" -> "${argName}" should be degree!`);
-    }
-    return scope;
-};
-const shouldBeRadians = (scope, funcName, argName) => (p) => {
-    if (!p.likeRadians) {
-        warn(`"${funcName}" -> "${argName}" should be radians!`);
-    }
-    return scope;
-};
-const shouldExist = (scope, funcName, argName) => (p) => {
-    if (!isDefAndNotNull(p)) {
-        warn(`"${funcName}" -> "${argName}" should exist!`);
-    }
-    return scope;
-};
-const shouldBeMeters = (scope, funcName, argName) => (p) => {
-    if (!p.likePseudoMercator) {
-        warn(`"${funcName}" -> "${argName}" should be meters!`);
-    }
-    return scope;
-};
-export const checkFunction = (funcName) => ({
-    checkArgument: function (argName) {
-        if (!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)
-        };
-    }
-});
-export const createArray = (v, fillSymbol) => {
-    if (typeof fillSymbol === 'function') {
-        return new Array(v).fill(false)
-            .map((_, i) => fillSymbol(i));
-    }
-    return new Array(v).fill(fillSymbol !== null && fillSymbol !== void 0 ? fillSymbol : 0);
-};
-export const createMatrix = ({ h, w }, fillSymbol) => {
-    if (typeof fillSymbol === 'function') {
-        return createArray(h)
-            .map((_, y) => createArray(w, (x) => fillSymbol(x, y)));
-    }
-    return createArray(h)
-        .map(() => createArray(w, fillSymbol));
-};
-export const gaussianElimination = (matrix) => {
-    const n = matrix.length;
-    const matrixClone = createMatrix(new DPoint(n + 1, n));
-    for (let i = 0; i < n; i++) {
-        for (let j = 0; j < n + 1; j++) {
-            matrix[i][j] = matrix[i][j] === 0 ? gaussianElimination.MIN : matrix[i][j];
-            matrixClone[i][j] = matrix[i][j];
-        }
-    }
-    for (let k = 0; k < n; k++) {
-        for (let i = 0; i < n + 1; i++) {
-            matrixClone[k][i] /= matrix[k][k];
-        }
-        for (let i = k + 1; i < n; i++) {
-            const K = matrixClone[i][k] / matrixClone[k][k];
-            for (let j = 0; j < n + 1; j++) {
-                matrixClone[i][j] -= matrixClone[k][j] * K;
-            }
-        }
-        for (let i = 0; i < n; i++) {
-            for (let j = 0; j < n + 1; j++) {
-                matrix[i][j] = matrixClone[i][j];
-            }
-        }
-    }
-    for (let k = n - 1; k > -1; k--) {
-        for (let i = n; i > -1; i--) {
-            matrixClone[k][i] /= matrix[k][k];
-        }
-        for (let i = k - 1; i > -1; i--) {
-            const K = matrixClone[i][k] / matrixClone[k][k];
-            for (let j = n; j > -1; j--) {
-                matrixClone[i][j] -= matrixClone[k][j] * K;
-            }
-        }
-    }
-    const answer = createArray(n);
-    for (let i = 0; i < n; i++) {
-        answer[i] = matrixClone[i][n];
-    }
-    return answer;
-};
-gaussianElimination.MIN = 1e-10;
-export const createCanvas = (a, b, c) => {
-    var _a;
-    let w = 0;
-    let h = 0;
-    let offscreen = false;
-    if (a instanceof DPoint) {
-        const { x, y } = a;
-        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;
-    }
-    const canvas = offscreen ? new OffscreenCanvas(w, h) : ((_a = createCanvas.document) !== null && _a !== void 0 ? _a : document).createElement('canvas');
-    if (!offscreen) {
-        canvas.width = w;
-        canvas.height = h;
-    }
-    return [canvas, canvas.getContext('2d')];
-};
-const f = (a, b) => [].concat(...a.map((c) => b.map((d) => [].concat(c, d))));
-export const cartesianProduct = (a, b, ...c) => b ? cartesianProduct(f(a, b), ...c) : a;
-export const getCombinations = (arr) => {
-    if (arr.length === 1) {
-        return arr[0];
-    }
-    const ans = [];
-    const otherCases = getCombinations(arr.slice(1));
-    for (let i = 0; i < otherCases.length; i++) {
-        for (let j = 0; j < arr[0].length; j++) {
-            ans.push([arr[0][j], ...otherCases[i]]);
-        }
-    }
-    return ans;
-};
-export const div = (a, b) => Math.floor(a / b);
-export const toDegreesMinutesSeconds = (v) => {
-    const degrees = Math.floor(v);
-    const t = (v % 1) * 60;
-    const minutes = Math.floor(t);
-    const t2 = (t % 1) * 60;
-    const seconds = t2.toFixed(2);
-    return `${degrees}° ${minutes}' ${seconds}"`;
-};
-export const parseDegreesMinutesSeconds = (i) => {
-    var _a, _b, _c, _d, _e, _f, _g;
-    const parts = i.matchAll(/(?<value>-?\d+(?<tail>\.\d{1,})?)(?<type>°|'|")/gmiu);
-    let d = 0;
-    let m = 0;
-    let s = 0;
-    for (const part of parts) {
-        switch ((_a = part === null || part === void 0 ? void 0 : part.groups) === null || _a === void 0 ? void 0 : _a.type) {
-            case '°':
-                d = Number((_c = (_b = part === null || part === void 0 ? void 0 : part.groups) === null || _b === void 0 ? void 0 : _b.value) !== null && _c !== void 0 ? _c : '0');
-                break;
-            case '\'':
-                m = Number((_e = (_d = part === null || part === void 0 ? void 0 : part.groups) === null || _d === void 0 ? void 0 : _d.value) !== null && _e !== void 0 ? _e : '0');
-                break;
-            case '"':
-                s = Number((_g = (_f = part === null || part === void 0 ? void 0 : part.groups) === null || _f === void 0 ? void 0 : _f.value) !== null && _g !== void 0 ? _g : '0');
-                break;
-            default:
-        }
-    }
-    const h = d < 0 ? -1 : 1;
-    return d + h * m / 60 + h * s / 3600;
-};

package/dist/esm/DCircle.js

@@ -1,99 +0,0 @@
-import { DPoint, EARTH_RADIUS_IN_METERS } from './DPoint';
-import { DPolygon } from './DPolygon';
-import { checkFunction } from './utils';
-var DCircle = (function () {
-    function DCircle(center, r) {
-        if (center === void 0) { center = DPoint.zero(); }
-        if (r === void 0) { r = 0; }
-        this.center = center;
-        this.r = r;
-    }
-    DCircle.prototype.toString = function () {
-        return "(".concat(this.center.toString(), ", ").concat(this.r, ")");
-    };
-    DCircle.prototype.getValue = function () {
-        return { center: this.center, r: this.r };
-    };
-    DCircle.prototype.clone = function () {
-        return new DCircle(this.center, this.r);
-    };
-    DCircle.prototype.findPoints = function (c) {
-        if (this.equal(c)) {
-            return Infinity;
-        }
-        var _a = this, _b = _a.center, x0 = _b.x, y0 = _b.y, r0 = _a.r;
-        var _c = c.center, x1 = _c.x, y1 = _c.y, r1 = c.r;
-        var r02 = r0 * r0;
-        var d = this.center.distance(c.center);
-        var a = (r02 - r1 * r1 + d * d) / (2 * d);
-        var h = Math.sqrt(r02 - a * a);
-        var ad = a / d;
-        var dy = y1 - y0;
-        var dx = x1 - x0;
-        var hd = h / d;
-        var x2 = x0 + ad * (x1 - x0);
-        var y2 = y0 + ad * (y1 - y0);
-        var x31 = x2 + hd * dy;
-        var y31 = y2 - hd * dx;
-        var x32 = x2 - hd * dy;
-        var y32 = y2 + hd * dx;
-        var 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;
-    };
-    DCircle.prototype.equal = function (_a) {
-        var center = _a.center, r = _a.r;
-        return this.center.equal(center) && this.r === r;
-    };
-    DCircle.prototype.findPolygonInside = function (pointCount, startAngle, stopAngle) {
-        if (pointCount === void 0) { pointCount = 64; }
-        if (startAngle === void 0) { startAngle = 0; }
-        if (stopAngle === void 0) { stopAngle = 2 * Math.PI; }
-        var step = 2 * Math.PI / pointCount;
-        var points = [];
-        var angle = startAngle;
-        while (angle < stopAngle - step) {
-            points.push(new DPoint(this.r).scale(Math.cos(angle), Math.sin(angle))
-                .move(this.center));
-            angle += step;
-        }
-        var x = this.r * Math.cos(stopAngle) + this.center.x;
-        var y = this.r * Math.sin(stopAngle) + this.center.y;
-        points.push(new DPoint(x, y));
-        return new DPolygon(points);
-    };
-    DCircle.prototype.findPolygonInsideOnSphere = function (pointCount, startAngle, stopAngle) {
-        if (pointCount === void 0) { pointCount = 64; }
-        if (startAngle === void 0) { startAngle = 0; }
-        if (stopAngle === void 0) { stopAngle = 2 * Math.PI; }
-        checkFunction('findPolygonInsideOnSphere')
-            .checkArgument('center')
-            .shouldBeDegree(this.center);
-        var step = 2 * Math.PI / pointCount;
-        var points = [];
-        var angle = startAngle;
-        while (angle < stopAngle - step) {
-            points.push(this.sphereOffset(angle));
-            angle += step;
-        }
-        points.push(this.sphereOffset(stopAngle));
-        return new DPolygon(points);
-    };
-    DCircle.prototype.sphereOffset = function (bearing, earthRadius) {
-        if (earthRadius === void 0) { earthRadius = EARTH_RADIUS_IN_METERS; }
-        var _a = this.center.clone().degreeToRadians(), lon1 = _a.x, lat1 = _a.y;
-        var dByR = this.r / earthRadius;
-        var lat = Math.asin(Math.sin(lat1) * Math.cos(dByR) +
-            Math.cos(lat1) * Math.sin(dByR) * Math.cos(bearing));
-        var 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();
-    };
-    return DCircle;
-}());
-export { DCircle };