mapcomplete/Logic/GeoOperations.ts

198 lines
6.2 KiB
TypeScript
Raw Normal View History

2021-04-18 14:24:30 +02:00
import * as turf from '@turf/turf'
2020-06-24 00:35:19 +02:00
2020-06-28 23:33:48 +02:00
export class GeoOperations {
2020-06-24 00:35:19 +02:00
2020-06-28 23:33:48 +02:00
static surfaceAreaInSqMeters(feature: any) {
return turf.area(feature);
}
2020-06-24 00:35:19 +02:00
2020-07-22 00:50:30 +02:00
static centerpoint(feature: any)
{
const newFeature= turf.center(feature);
newFeature.properties = feature.properties;
newFeature.id = feature.id;
return newFeature;
}
2021-02-14 20:36:20 +01:00
2021-04-18 18:23:59 +02:00
static centerpointCoordinates(feature: any): [number, number]{
// @ts-ignore
return turf.center(feature).geometry.coordinates;
2021-02-14 20:36:20 +01:00
}
2020-07-22 00:50:30 +02:00
/**
* Returns the distance between the two points in kilometers
* @param lonlat0
* @param lonlat1
*/
static distanceBetween(lonlat0: [number,number], lonlat1:[number, number]){
return turf.distance(lonlat0, lonlat1)
}
/**
* Calculates the overlap of 'feature' with every other specified feature.
* The features with which 'feature' overlaps, are returned together with their overlap area in m²
*
* If 'feature' is a point, it will return every feature the point is embedded in. Overlap will be undefined
*/
static calculateOverlap(feature: any,
otherFeatures: any[]): { feat: any, overlap: number }[] {
const featureBBox = BBox.get(feature);
const result : { feat: any, overlap: number }[] = [];
2020-06-24 00:35:19 +02:00
if (feature.geometry.type === "Point") {
const coor = feature.geometry.coordinates;
for (const otherFeature of otherFeatures) {
2020-06-24 00:35:19 +02:00
let otherFeatureBBox = BBox.get(otherFeature);
if (!featureBBox.overlapsWith(otherFeatureBBox)) {
2020-06-24 00:35:19 +02:00
continue;
}
if (this.inside(coor, otherFeatures)) {
result.push({ feat: otherFeatures, overlap: undefined })
2020-06-24 00:35:19 +02:00
}
}
return result;
2020-06-24 00:35:19 +02:00
}
2020-06-28 23:33:48 +02:00
if (feature.geometry.type === "Polygon" || feature.geometry.type === "MultiPolygon") {
2020-06-24 00:35:19 +02:00
for (const otherFeature of otherFeatures) {
const otherFeatureBBox = BBox.get(otherFeature);
const overlaps = featureBBox.overlapsWith(otherFeatureBBox)
2020-06-28 23:33:48 +02:00
if (!overlaps) {
2020-06-24 00:35:19 +02:00
continue;
}
2020-06-28 23:33:48 +02:00
// Calculate the surface area of the intersection
try {
const intersection = turf.intersect(feature, otherFeature);
2020-06-28 23:33:48 +02:00
if (intersection == null) {
continue;
2020-06-24 00:35:19 +02:00
}
const intersectionSize = turf.area(intersection); // in m²
result.push({feat: otherFeature, overlap: intersectionSize})
2020-06-28 23:33:48 +02:00
} catch (exception) {
console.log("EXCEPTION CAUGHT WHILE INTERSECTING: ", exception);
2020-06-24 00:35:19 +02:00
}
2020-06-28 23:33:48 +02:00
2020-06-24 00:35:19 +02:00
}
return result;
2020-06-24 00:35:19 +02:00
}
console.error("Could not correctly calculate the overlap of ", feature, ": unsupported type")
return result;
2020-06-24 00:35:19 +02:00
}
public static inside(pointCoordinate, feature): boolean {
2020-06-24 00:35:19 +02:00
// ray-casting algorithm based on
// http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html
if (feature.geometry.type === "Point") {
return false;
}
const x: number = pointCoordinate[0];
const y: number = pointCoordinate[1];
let poly = feature.geometry.coordinates[0];
var inside = false;
for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
2020-06-24 00:35:19 +02:00
const coori = poly[i];
const coorj = poly[j];
const xi = coori[0];
const yi = coori[1];
const xj = coorj[0];
const yj = coorj[1];
const intersect = ((yi > y) != (yj > y))
2020-06-24 00:35:19 +02:00
&& (x < (xj - xi) * (y - yi) / (yj - yi) + xi);
if (intersect) {
inside = !inside;
}
}
return inside;
};
2021-04-18 14:24:30 +02:00
static lengthInMeters(feature: any) {
return turf.length(feature) * 1000
}
2020-06-24 00:35:19 +02:00
}
class BBox{
2020-06-24 00:35:19 +02:00
readonly maxLat: number;
readonly maxLon: number;
readonly minLat: number;
readonly minLon: number;
constructor(coordinates) {
this.maxLat = Number.MIN_VALUE;
this.maxLon = Number.MIN_VALUE;
this.minLat = Number.MAX_VALUE;
this.minLon = Number.MAX_VALUE;
for (const coordinate of coordinates) {
this.maxLon = Math.max(this.maxLon, coordinate[0]);
this.maxLat = Math.max(this.maxLat, coordinate[1]);
this.minLon = Math.min(this.minLon, coordinate[0]);
this.minLat = Math.min(this.minLat, coordinate[1]);
}
2020-06-28 23:33:48 +02:00
this.check();
2020-06-24 00:35:19 +02:00
}
2020-06-28 23:33:48 +02:00
private check() {
if (isNaN(this.maxLon) || isNaN(this.maxLat) || isNaN(this.minLon) || isNaN(this.minLat)) {
console.log(this);
throw "BBOX has NAN";
}
}
2020-06-24 00:35:19 +02:00
2020-06-28 23:33:48 +02:00
public overlapsWith(other: BBox) {
this.check();
other.check();
2020-06-24 00:35:19 +02:00
if (this.maxLon < other.minLon) {
return false;
}
if (this.maxLat < other.minLat) {
return false;
}
if (this.minLon > other.maxLon) {
return false;
}
return this.minLat <= other.maxLat;
2020-06-24 00:35:19 +02:00
}
static get(feature) {
if (feature.bbox?.overlapsWith === undefined) {
2020-06-28 23:33:48 +02:00
if (feature.geometry.type === "MultiPolygon") {
let coordinates = [];
for (const coorlist of feature.geometry.coordinates) {
coordinates = coordinates.concat(coorlist[0]);
}
feature.bbox = new BBox(coordinates);
} else if (feature.geometry.type === "Polygon") {
2020-06-24 00:35:19 +02:00
feature.bbox = new BBox(feature.geometry.coordinates[0]);
} else if (feature.geometry.type === "LineString") {
feature.bbox = new BBox(feature.geometry.coordinates);
2020-06-28 23:33:48 +02:00
} else if (feature.geometry.type === "Point") {
2020-06-24 00:35:19 +02:00
// Point
feature.bbox = new BBox([feature.geometry.coordinates]);
2020-06-28 23:33:48 +02:00
} else {
throw "Cannot calculate bbox, unknown type " + feature.geometry.type;
2020-06-24 00:35:19 +02:00
}
}
return feature.bbox;
}
}