iwmlib/lib/pixi/maps/geojson.js

349 lines
11 KiB
JavaScript

import { GeoGraphics, GeoShape, GeoMultiShape, GeoLine, GeoPoint } from './geographics.js'
/**
* Helper class for handling GeoJson data.
* As specified by [RFC7946](https://tools.ietf.org/html/rfc7946).
*
* @static
* @export
* @class
*/
export default class GeoJson {
static isLineType(type) {
return type == 'LineString' || type == 'MultiLineString'
}
static _getFormatStringOfType(type) {
let description = ', where p represents a coordinate point'
let format = ''
switch (type) {
case 'Point':
format = 'p'
break
case 'LineString':
format = '[p1,p2,p3,...,pn]'
break
case 'Polygon':
format = '[ [p1,p2,...,pn], [h1,h2,...,hn] ]'
description += ' and h also represents a coordinate point, but it creates a hole.'
break
default:
format = type
description = " is either not valid or not yet implemented in method '_getFormatStringOfType(type)'."
}
return format + ' - ' + description
}
static get types() {
return ['Point', 'LineString', 'Polygon', 'MultiPoint', 'MultiLineString', 'MultiPolygon']
}
/**
* Takes a JSON object that contains a FeatureCollection and returns an array
* of GeoJson objects.
*
* @static
* @param {array} featureCollection - Array of GeoJSON objects that were contained in the feature collection.
* @returns {array} Returns an array of geo json objects.
* @memberof GeoJson
*/
static unwrapFeatureCollection(featureCollection) {
if (featureCollection.features == null) {
console.error(
'Error at GeoJson.unrwapFeatureCollection(collection): Provided object was no valid FeatureCollection.',
featureCollection
)
return
}
let list = []
featureCollection.features.forEach(feature => {
let { type, coordinates } = feature
if (feature.type.toLowerCase() == 'feature') {
;({ type, coordinates } = feature.geometry)
}
list.push({ type, coordinates })
})
return list
}
/**
* Validates and converts one set of coordinates of a specific type.
*
* @static
* @param {string} type - Type of the GeoJson.
* @param {array} coordinates - array of points.
* @returns {array}
* @memberof GeoJson
*/
static validateAndConvert(type, coordinates) {
let converted = null
if (!GeoJson.validateType(type)) throw new GeoJson.InvalidTypeError(type)
else {
if (GeoJson.validateCoordinates(type, coordinates)) {
converted = GeoJson.convert(type, coordinates)
} else {
console.error(
`Coordinates are invalid. They must be in format of type '${type} - ${GeoJson._getFormatStringOfType(
type
)}'`
)
}
}
return converted
}
static validateType(type) {
return GeoJson.types.indexOf(type) != -1
}
static validateCoordinates(type, coordinates) {
let valid = false
switch (type) {
case 'Point':
valid = !!GeoJson.validateAndConvertPoint(coordinates)
break
case 'LineString':
valid = GeoJson.validateLineString(coordinates)
break
case 'Polygon':
valid = GeoJson.validatePolygon(coordinates)
break
case 'MultiPolygon':
valid = true
for (let i = 0; i < coordinates.length; i++) {
if (!GeoJson.validatePolygon(coordinates[i])) {
valid = false
break
}
}
break
case 'MultiPoint':
case 'MultiLineString':
default:
console.error('Type was not yet implemented: ', type)
}
return valid
}
/**
* Validates a point if it's an valid coordinate.
*
* NOTE: Here we are not following the GeoJSON standard.
* For convenience multiple forms of representing a coordinate are
* considered valid. A complete list is provided in the GeoUtils.
*
* @param {object} point - The point that is tested for validity.
* @returns {boolean}
* @memberof GeoJson
*/
static validateAndConvertPoint(point) {
return GeoUtils.validateCoordinate(point)
}
/**
*Validates if the given points represent a 'LineString'.
*
* @param {array} points - A list of coordinates that represent a line.
* @returns {boolean} - Returns true, if the array is in formes as: [x1,x2,x3,...,xn]. Where x# represent a valid coordinate.
* @memberof GeoJson
*/
static validateLineString(points) {
let valid = false
if (Array.isArray(points)) valid = points.every(GeoJson.validateAndConvertPoint)
return valid
}
static validatePolygon(points) {
let valid = false
if ((Array.isArray(points) && points.length >= 1) || points.length <= 2)
valid = points.every(this.validateLineString)
return valid
}
static convert(type, coordinates) {
let converted = null
switch (type) {
case 'Point':
converted = GeoJson.validateAndConvertPoint(coordinates)
break
case 'LineString':
converted = GeoJson._convertLineString(coordinates)
break
case 'Polygon':
converted = GeoJson._convertPolygon(coordinates)
break
case 'MultiPolygon':
converted = GeoJson._convertMultiPolygon(coordinates)
break
default:
throw new GeoJson.InvalidTypeError(type)
}
return converted
}
static _convertLineString(coordinates) {
return coordinates.map(point => {
return GeoJson.validateAndConvertPoint(point)
})
}
static _convertPolygon(coordinates) {
return coordinates.map(shape => {
return GeoJson._convertLineString(shape)
})
}
static _convertMultiPolygon(coordinates) {
return coordinates.map(polygon => {
return GeoJson._convertPolygon(polygon)
})
}
}
GeoJson.InvalidTypeError = class extends Error {
constructor(type) {
super(`The requested Type was not implemented: ${type}.`)
}
}
/**
* GeoUtils contains a collection of useful functions when working with maps.
*
* @static
*/
export class GeoUtils {
static transformToGeoGraphics(list) {
let geographicsList = []
list.forEach(item => {
if (item.type == 'FeatureCollection') {
item.features.forEach(feature => {
let { type, coordinates } = feature
if (type.toLowerCase() == 'feature') ({ type, coordinates } = feature.geometry)
coordinates = GeoJson.validateAndConvert(type, coordinates)
let geographics = this.fromGeoJsonToGeoGraphics(type, coordinates)
if (geographics) geographicsList.push(geographics)
})
} else {
let geo = fromGeoJsonToGeoGraphics(item.type, item.geometry)
if (geo) geographicsList.push(geo)
}
})
return geographicsList
}
static resolveFeatureCollection(collection) {
if (!collection.features) {
console.error(
'Error in GeoUtils.resolveFeatureCollection(colelction): Passed parameter was no feature collection.',
collection
)
return
}
let geojson = []
collection.features.forEach(feature => {
let { type, coordinates } = feature
if (feature.type == feature) {
coordinates = feature.geometry.coordinates
type = feature.geometry.type
}
geojson.push({ type, coordinates })
})
return geojson
}
/**
* Creates the appropriate GeoGraphics object from a GeoJson type.
* The coordinates need to be alread in the appropriate PIXI format.
* If not already - this can be achieved by calling 'GeoJson.validateAndConvert(type, points)'
* beforehand.
*
* @static
* @param {string} type - Any of the GeoJson types ('Point', 'LineString', 'Polygon', 'MultiPoint', 'MultiLineString', 'MultiPolygon').
* @param {array} coordinates - Array of coordinates that fit the type. The positions within these must be in PIXI format: {x:a, y:b}.
* @returns {GeoGraphics} - Returns a GeoGraphics object. If the conversion fails, it returns null.
* @memberof GeoGraphics
*/
static fromGeoJsonToGeoGraphics(type, coordinates, opts = {}) {
let geographics = null
/**
* TODO: REMOVE
* Just for initial debugging purposes
*/
Object.assign(opts, {
debug: true
})
switch (type) {
case 'Polygon':
geographics = new GeoShape(coordinates, opts)
break
case 'MultiPolygon':
geographics = new GeoMultiShape(coordinates, opts)
break
case 'LineString':
geographics = new GeoLine(coordinates, opts)
break
case 'Point':
geographics = new GeoPoint(coordinates, opts)
break
default:
console.log('Could not create Geographics for type: ' + type + '. This was not implemented yet.')
//Nothing
}
return geographics
}
/**
* Validates an object, if it's an coordinate object.
* Coordinate objects can be in the following forms:
*
* [lng, lat] - GeoJSON array format. !Attention lng and lat are swapped compared to the x,y format.
* {x: lat, y: lng} - 'correct' PIXI.format
* {lat, lng}
* {latitude: lat, longitude: lng}
*
* @static
* @param {object|array} coordinate - Coordinate to be tested, if it is an valid coordinate.
* @returns - Returns the coordinate properly transformed. If transformation was not possible, it returns null.
* @memberof GeoGraphics
*/
static validateCoordinate(coordinate) {
if (Array.isArray(coordinate)) {
if (coordinate.length == 2 && typeof coordinate[0] == 'number' && typeof coordinate[1] == 'number')
return new PIXI.Point(coordinate[1], coordinate[0])
else return false
} else {
const latvalues = ['x', 'lat', 'latitude']
const lngvalues = ['y', 'lng', 'longitude']
let result = {}
for (let key of Object.keys(coordinate)) {
let target = key.toLowerCase()
if (latvalues.indexOf(target) !== -1) result.x = coordinate[key]
else if (lngvalues.indexOf(target) !== -1) result.y = coordinate[key]
}
if (result.hasOwnProperty('x') && result.hasOwnProperty('y')) return new PIXI.Point(result.x, result.y)
else return false
}
}
}