dgeoutils 2.4.1 → 2.4.2

package/dist/es2015/DPolygonLoop.js

@@ -1,392 +0,0 @@
-var LoopFunctions;
-(function (LoopFunctions) {
-    LoopFunctions[LoopFunctions["getTileFromCoords"] = 0] = "getTileFromCoords";
-    LoopFunctions[LoopFunctions["getCoordsFromTile"] = 1] = "getCoordsFromTile";
-    LoopFunctions[LoopFunctions["height"] = 2] = "height";
-    LoopFunctions[LoopFunctions["setX"] = 3] = "setX";
-    LoopFunctions[LoopFunctions["setY"] = 4] = "setY";
-    LoopFunctions[LoopFunctions["setZ"] = 5] = "setZ";
-    LoopFunctions[LoopFunctions["rotate"] = 6] = "rotate";
-    LoopFunctions[LoopFunctions["rotate3dX"] = 7] = "rotate3dX";
-    LoopFunctions[LoopFunctions["rotate3dY"] = 8] = "rotate3dY";
-    LoopFunctions[LoopFunctions["rotate3dZ"] = 9] = "rotate3dZ";
-    LoopFunctions[LoopFunctions["move"] = 10] = "move";
-    LoopFunctions[LoopFunctions["round"] = 11] = "round";
-    LoopFunctions[LoopFunctions["ceil"] = 12] = "ceil";
-    LoopFunctions[LoopFunctions["floor"] = 13] = "floor";
-    LoopFunctions[LoopFunctions["toFixed"] = 14] = "toFixed";
-    LoopFunctions[LoopFunctions["abs"] = 15] = "abs";
-    LoopFunctions[LoopFunctions["scale"] = 16] = "scale";
-    LoopFunctions[LoopFunctions["divide"] = 17] = "divide";
-    LoopFunctions[LoopFunctions["degreeToRadians"] = 18] = "degreeToRadians";
-    LoopFunctions[LoopFunctions["radiansToDegrees"] = 19] = "radiansToDegrees";
-    LoopFunctions[LoopFunctions["radiansToMeters"] = 20] = "radiansToMeters";
-    LoopFunctions[LoopFunctions["metersToRadians"] = 21] = "metersToRadians";
-    LoopFunctions[LoopFunctions["hipPoint"] = 22] = "hipPoint";
-    LoopFunctions[LoopFunctions["xPoint"] = 23] = "xPoint";
-    LoopFunctions[LoopFunctions["yPoint"] = 24] = "yPoint";
-    LoopFunctions[LoopFunctions["wPoint"] = 25] = "wPoint";
-    LoopFunctions[LoopFunctions["hPoint"] = 26] = "hPoint";
-    LoopFunctions[LoopFunctions["setIfLessThan"] = 27] = "setIfLessThan";
-    LoopFunctions[LoopFunctions["minus"] = 28] = "minus";
-    LoopFunctions[LoopFunctions["degreeToMeters"] = 29] = "degreeToMeters";
-    LoopFunctions[LoopFunctions["metersToDegree"] = 30] = "metersToDegree";
-    LoopFunctions[LoopFunctions["flipVertically"] = 31] = "flipVertically";
-})(LoopFunctions || (LoopFunctions = {}));
-const decodePoolRecord = (a, { functionName, pointArg, numberPointArg, numberArg, setterArg }) => {
-    let res = a;
-    switch (functionName) {
-        case LoopFunctions.getTileFromCoords:
-            res = (k) => a(k)
-                .getTileFromCoords(numberArg);
-            break;
-        case LoopFunctions.getCoordsFromTile:
-            res = (k) => a(k)
-                .getCoordsFromTile(numberArg);
-            break;
-        case LoopFunctions.height:
-            res = (k) => a(k)
-                .height(numberArg);
-            break;
-        case LoopFunctions.setX:
-            res = (k) => a(k)
-                .setX(setterArg);
-            break;
-        case LoopFunctions.setY:
-            res = (k) => a(k)
-                .setY(setterArg);
-            break;
-        case LoopFunctions.setZ:
-            res = (k) => a(k)
-                .setZ(setterArg);
-            break;
-        case LoopFunctions.rotate:
-            res = (k) => a(k)
-                .rotate(numberArg);
-            break;
-        case LoopFunctions.rotate3dX:
-            res = (k) => a(k)
-                .rotate3dX(numberArg);
-            break;
-        case LoopFunctions.rotate3dY:
-            res = (k) => a(k)
-                .rotate3dY(numberArg);
-            break;
-        case LoopFunctions.rotate3dZ:
-            res = (k) => a(k)
-                .rotate3dZ(numberArg);
-            break;
-        case LoopFunctions.move:
-            res = (k) => a(k)
-                .move(numberPointArg, numberArg);
-            break;
-        case LoopFunctions.round:
-            res = (k) => a(k)
-                .round();
-            break;
-        case LoopFunctions.ceil:
-            res = (k) => a(k)
-                .ceil();
-            break;
-        case LoopFunctions.floor:
-            res = (k) => a(k)
-                .floor();
-            break;
-        case LoopFunctions.toFixed:
-            res = (k) => a(k)
-                .toFixed(numberArg);
-            break;
-        case LoopFunctions.abs:
-            res = (k) => a(k)
-                .abs();
-            break;
-        case LoopFunctions.scale:
-            res = (k) => a(k)
-                .scale(numberPointArg, numberArg);
-            break;
-        case LoopFunctions.divide:
-            res = (k) => a(k)
-                .divide(numberPointArg, numberArg);
-            break;
-        case LoopFunctions.degreeToRadians:
-            res = (k) => a(k)
-                .degreeToRadians();
-            break;
-        case LoopFunctions.radiansToDegrees:
-            res = (k) => a(k)
-                .radiansToDegrees();
-            break;
-        case LoopFunctions.radiansToMeters:
-            res = (k) => a(k)
-                .radiansToMeters();
-            break;
-        case LoopFunctions.metersToRadians:
-            res = (k) => a(k)
-                .metersToRadians();
-            break;
-        case LoopFunctions.hipPoint:
-            res = (k) => a(k)
-                .hipPoint;
-            break;
-        case LoopFunctions.xPoint:
-            res = (k) => a(k)
-                .xPoint;
-            break;
-        case LoopFunctions.yPoint:
-            res = (k) => a(k)
-                .yPoint;
-            break;
-        case LoopFunctions.wPoint:
-            res = (k) => a(k)
-                .wPoint;
-            break;
-        case LoopFunctions.hPoint:
-            res = (k) => a(k)
-                .hPoint;
-            break;
-        case LoopFunctions.setIfLessThan:
-            res = (k) => a(k)
-                .setIfLessThan(pointArg);
-            break;
-        case LoopFunctions.minus:
-            res = (k) => a(k)
-                .minus();
-            break;
-        case LoopFunctions.degreeToMeters:
-            res = (k) => a(k)
-                .degreeToMeters();
-            break;
-        case LoopFunctions.metersToDegree:
-            res = (k) => a(k)
-                .metersToDegree();
-            break;
-        case LoopFunctions.flipVertically:
-            res = (k) => a(k)
-                .flipVertically(numberPointArg);
-            break;
-    }
-    return res;
-};
-export class DPolygonLoop {
-    constructor(parent) {
-        this.parent = parent;
-        this.pool = [];
-    }
-    getLoopFunction() {
-        return this.pool.reduce(decodePoolRecord, (k) => k);
-    }
-    run() {
-        return this.parent.map(this.getLoopFunction());
-    }
-    getTileFromCoords(zoom) {
-        this.pool.push({
-            functionName: LoopFunctions.getTileFromCoords,
-            numberArg: zoom
-        });
-        return this;
-    }
-    getCoordsFromTile(zoom) {
-        this.pool.push({
-            functionName: LoopFunctions.getCoordsFromTile,
-            numberArg: zoom
-        });
-        return this;
-    }
-    height(z) {
-        this.pool.push({
-            functionName: LoopFunctions.height,
-            numberArg: z
-        });
-        return this;
-    }
-    setX(x) {
-        this.pool.push({
-            functionName: LoopFunctions.setX,
-            setterArg: x
-        });
-        return this;
-    }
-    setY(y) {
-        this.pool.push({
-            functionName: LoopFunctions.setY,
-            setterArg: y
-        });
-        return this;
-    }
-    setZ(z) {
-        this.pool.push({
-            functionName: LoopFunctions.setZ,
-            setterArg: z
-        });
-        return this;
-    }
-    rotate(a) {
-        this.pool.push({
-            functionName: LoopFunctions.rotate,
-            numberArg: a
-        });
-        return this;
-    }
-    rotate3dX(a) {
-        this.pool.push({
-            functionName: LoopFunctions.rotate3dX,
-            numberArg: a
-        });
-        return this;
-    }
-    rotate3dY(a) {
-        this.pool.push({
-            functionName: LoopFunctions.rotate3dY,
-            numberArg: a
-        });
-        return this;
-    }
-    rotate3dZ(a) {
-        this.pool.push({
-            functionName: LoopFunctions.rotate3dZ,
-            numberArg: a
-        });
-        return this;
-    }
-    move(x, y = x) {
-        this.pool.push({
-            functionName: LoopFunctions.move,
-            numberPointArg: x,
-            numberArg: y
-        });
-        return this;
-    }
-    round() {
-        this.pool.push({
-            functionName: LoopFunctions.round
-        });
-        return this;
-    }
-    ceil() {
-        this.pool.push({
-            functionName: LoopFunctions.ceil
-        });
-        return this;
-    }
-    floor() {
-        this.pool.push({
-            functionName: LoopFunctions.floor
-        });
-        return this;
-    }
-    toFixed(n = 2) {
-        this.pool.push({
-            functionName: LoopFunctions.toFixed,
-            numberArg: n
-        });
-        return this;
-    }
-    abs() {
-        this.pool.push({
-            functionName: LoopFunctions.abs
-        });
-        return this;
-    }
-    scale(x, y = x) {
-        this.pool.push({
-            functionName: LoopFunctions.scale,
-            numberPointArg: x,
-            numberArg: y
-        });
-        return this;
-    }
-    divide(x, y) {
-        this.pool.push({
-            functionName: LoopFunctions.divide,
-            numberPointArg: x,
-            numberArg: y
-        });
-        return this;
-    }
-    degreeToRadians() {
-        this.pool.push({
-            functionName: LoopFunctions.degreeToRadians
-        });
-        return this;
-    }
-    radiansToDegrees() {
-        this.pool.push({
-            functionName: LoopFunctions.radiansToDegrees
-        });
-        return this;
-    }
-    radiansToMeters() {
-        this.pool.push({
-            functionName: LoopFunctions.radiansToMeters
-        });
-        return this;
-    }
-    metersToRadians() {
-        this.pool.push({
-            functionName: LoopFunctions.metersToRadians
-        });
-        return this;
-    }
-    getHipPoint() {
-        this.pool.push({
-            functionName: LoopFunctions.hipPoint
-        });
-        return this;
-    }
-    getXPoint() {
-        this.pool.push({
-            functionName: LoopFunctions.xPoint
-        });
-        return this;
-    }
-    getYPoint() {
-        this.pool.push({
-            functionName: LoopFunctions.yPoint
-        });
-        return this;
-    }
-    getWPoint() {
-        this.pool.push({
-            functionName: LoopFunctions.wPoint
-        });
-        return this;
-    }
-    getHPoint() {
-        this.pool.push({
-            functionName: LoopFunctions.hPoint
-        });
-        return this;
-    }
-    setIfLessThan(p) {
-        this.pool.push({
-            functionName: LoopFunctions.setIfLessThan,
-            pointArg: p
-        });
-        return this;
-    }
-    minus() {
-        this.pool.push({
-            functionName: LoopFunctions.minus
-        });
-        return this;
-    }
-    degreeToMeters() {
-        this.pool.push({
-            functionName: LoopFunctions.degreeToMeters
-        });
-        return this;
-    }
-    metersToDegree() {
-        this.pool.push({
-            functionName: LoopFunctions.metersToDegree
-        });
-        return this;
-    }
-    flipVertically(size) {
-        this.pool.push({
-            functionName: LoopFunctions.flipVertically,
-            numberPointArg: size
-        });
-        return this;
-    }
-}

package/dist/es2015/FastSearch.js

@@ -1,25 +0,0 @@
-export class FastSearch {
-    constructor() {
-        this.searchStore = {};
-    }
-    add(points) {
-        for (const { x, y, z } of points) {
-            if (!this.searchStore[x]) {
-                this.searchStore[x] = {};
-            }
-            if (!this.searchStore[x][y]) {
-                this.searchStore[x][y] = {};
-            }
-            this.searchStore[x][y][z || 'undefined'] = true;
-        }
-    }
-    find({ x, y, z }) {
-        if (!this.searchStore[x]) {
-            return false;
-        }
-        if (!this.searchStore[x][y]) {
-            return false;
-        }
-        return this.searchStore[x][y][z || 'undefined'];
-    }
-}

package/dist/es2015/TraceMatrix.js

@@ -1,200 +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(size, f) {
-        this.size = size;
-        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));
-            }
-            return points.approximation().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.m = TraceMatrix.createMatrix(this.size, f);
-    }
-    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;
-        });
-    }
-    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,10 +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 './DPolygonLoop';
-export * from './DPlane';
-export { gaussianElimination, createCanvas, createArray, createMatrix, isDefAndNotNull, cartesianProduct, getCombinations, DGeo } from './utils';