nrenner/62428.geojson

import pointInPolygon from "robust-point-in-polygon";

export class GeoJsonTools
{
    public getBoundingBox(ring: any)
    {
        let xs = ring.map((a) => a[0]);
        let ys = ring.map((a) => a[1]);
        let minX = Math.min.apply(Math, xs);
        let minY = Math.min.apply(Math, ys);
        let maxX = Math.max.apply(Math, xs);
        let maxY = Math.max.apply(Math, ys);
        return {minX: minX, minY: minY, maxX: maxX, maxY: maxY};

    }

    public containsBbox(outer: any, inner: any)
    {
        let outerBox = this.getBoundingBox(outer);
        let innerBox = this.getBoundingBox(inner);
        return (
            innerBox.minX >= outerBox.minX
            && innerBox.minY >= outerBox.minY
            && innerBox.maxX <= outerBox.maxX
            && innerBox.maxY <= outerBox.maxY
        );
    }


    public contains(outer: any, inner: any)
    {
        if (!this.containsBbox(outer, inner)) {
            return false;
        }
        for (let point of inner) {
            if (!pointInPolygon(outer, point)) {
                return false;
            }
        }

        return true;

    }

    // simply check containment - they never intersect in correct data
    public findSmallestPolygon(polygons: any)
    {
        let smallest = polygons[0];
        for (let i = 1; i < polygons.length; i++) {
            if (this.containsBbox(smallest[0], polygons[i][0])) {
                smallest = polygons[i][0];
            }
        }
        return smallest;
    }


    public reverseMultipolygon(multiPolygon: any)
    {
        const reversedPolygon: any = Object.assign({}, multiPolygon);

        let outerRings = multiPolygon.coordinates.map((a)=>a[0].slice().reverse());
        let holeRings = [];
        for (let row of multiPolygon.coordinates) {
            for (let i = 1; i < row.length; i++) {
                holeRings.push(row[i].slice().reverse());
            }
        }

        let newPolygons = holeRings.map((a)=>[a]); //create nested arrays to append holes to.
        let newHoles = outerRings;


        //add whole-world polygon
        newPolygons.push([[
            [ -180, 90 ],
            [ -180, -90 ],
            [ 180, -90 ],
            [ 180, 90 ],
            [ -180, 90 ]
        ]]);


        //match holes with the smallest outer rings containing them
        for (let hole of newHoles) {
            let containingPolygons = [];
            for (let newPolygon of newPolygons) {
                if (this.contains(newPolygon[0], hole)) {
                    containingPolygons.push(newPolygon)
                }
            }
            if (containingPolygons.length) {
                let smallestContainingPolygon = this.findSmallestPolygon(containingPolygons);
                smallestContainingPolygon.push(hole)
            }
        }

        const reversedMultiPolygon: any = Object.assign({}, multiPolygon);
        reversedMultiPolygon.coordinates = newPolygons;
        return reversedMultiPolygon;
        
    }

}