geolib
v3.3.4
Bibliothèque pour fournir des opérations géospatiales de base comme le calcul de la distance, la conversion des coordonnées décimales en sexagesimal et vice versa, etc. Cette bibliothèque est actuellement 2D , ce qui signifie que l'altitude / élévation n'est encore prise en charge par aucune de ses fonctions!
Un modificateur détaillé peut être trouvé dans changelog.md
npm install geolibyarn add geolibIl y a une construction UMD et une construction de module ES . Vous pouvez soit utiliser la version UMD dans le nœud comme n'importe quelle autre bibliothèque:
const geolib = require ( 'geolib' ) ;ou dans le navigateur en utilisant un élément de script simple:
< script src =" lib/geolib.js " > </ script > Si vous le chargez dans le navigateur, vous pouvez accéder à toutes les fonctions via window.geolib .
Si vous travaillez avec un bundler (comme WebPack ou Parcel) ou avez un environnement qui prend en charge les modules ES nativement, vous pouvez soit importer directement certaines fonctions à partir du package:
import { getDistance } from 'geolib' ;ou chargez toute la bibliothèque:
import * as geolib from 'geolib' ;ou vous pouvez importer des fonctions uniques directement pour utiliser potentiellement le treehaking (recommandé):
import getDistance from 'geolib/es/getDistance' ; Cette bibliothèque est écrite en dactylographie. Vous n'avez pas à connaître TypeScript pour utiliser le géolib, mais les définitions de type vous donnent des informations précieuses sur l'utilisation générale, les paramètres d'entrée, etc.
Toutes les méthodes qui travaillent avec les coordonnées acceptent soit un objet avec un lat / latitude et une propriété lon / lng / longitude , soit un tableau de coordonnées Geojson, comme: [lon, lat] . Toutes les valeurs peuvent être soit au format décimal ( 53.471 ) ou sexagesimal ( 53° 21' 16" ).
Les valeurs de distance sont toujours flottantes et représentent la distance en mètres .
getDistance(start, end, accuracy = 1)Calcule la distance entre deux coordonnées géo.
Cette fonction prend jusqu'à 3 arguments. Les 2 premiers arguments doivent être valides GeolibInputCoordinates (par exemple {latitude: 52.518611, longitude: 13.408056} ). Les coordonnées peuvent être en format sexage simage ou décimal. Le troisième argument est la précision (en mètres). Par défaut, la précision est de 1 mètre. Si vous avez besoin d'un résultat plus précis, vous pouvez le définir à une valeur inférieure, par exemple à 0.01 pour la précision des centimètres. Vous pouvez le régler plus haut pour que le résultat soit arrondi à la valeur suivante qui est divisible par la précision de votre choix (par exemple 25428 avec une précision de 100 devient 25400 ).
getDistance (
{ latitude : 51.5103 , longitude : 7.49347 } ,
{ latitude : "51° 31' N" , longitude : "7° 28' E" }
) ; // Working with W3C Geolocation API
navigator . geolocation . getCurrentPosition (
( position ) => {
console . log (
'You are ' ,
geolib . getDistance ( position . coords , {
latitude : 51.525 ,
longitude : 7.4575 ,
} ) ,
'meters away from 51.525, 7.4575'
) ;
} ,
( ) => {
alert ( 'Position could not be determined.' ) ;
}
) ;Renvoie la distance en mètres sous forme de valeur numérique.
getPreciseDistance(start, end, accuracy = 1) Calcule la distance entre deux coordonnées géo. Cette méthode est plus précise que getDistance , en particulier pour les longues distances, mais elle est également plus lente. Il utilise la formule inverse de Viny pour les ellipsoïdes.
Il faut la même (jusqu'à 3) arguments que getDistance .
geolib . getPreciseDistance (
{ latitude : 51.5103 , longitude : 7.49347 } ,
{ latitude : "51° 31' N" , longitude : "7° 28' E" }
) ;getCenter(coords)Calcule le centre géographique de tous les points d'une collection de coordonnées géo. Prend un tableau de coordonnées et calcule le centre de celui-ci.
geolib . getCenter ( [
{ latitude : 52.516272 , longitude : 13.377722 } ,
{ latitude : 51.515 , longitude : 7.453619 } ,
{ latitude : 51.503333 , longitude : - 0.119722 } ,
] ) ;Renvoie un objet:
{
"latitude" : centerLat ,
"longitude" : centerLon
}getCenterOfBounds(coords)Calcule le centre des limites des coordonnées géo.
Prend un tableau de coordonnées, calculez la bordure de ceux-ci et rend le centre de ce rectangle.
Sur les polygones comme les frontières politiques (par exemple, les États), cela peut donner un résultat plus étroit aux attentes humaines, que getCenter , car cette fonction peut être perturbée par une distribution inégale de points dans différents côtés.
Imaginez l'Oklahoma de l'État américain: getCenter qui donne un point sud, car la frontière sud contient beaucoup plus de nœuds que les autres.
geolib . getCenterOfBounds ( [
{ latitude : 51.513357512 , longitude : 7.45574331 } ,
{ latitude : 51.515400598 , longitude : 7.45518541 } ,
{ latitude : 51.516241842 , longitude : 7.456494328 } ,
{ latitude : 51.516722545 , longitude : 7.459863183 } ,
{ latitude : 51.517443592 , longitude : 7.463232037 } ,
] ) ;Renvoie un objet:
{
"latitude" : centerLat ,
"longitude" : centerLng
}getBounds(points)Calcule les limites des coordonnées géo.
geolib . getBounds ( [
{ latitude : 52.516272 , longitude : 13.377722 } ,
{ latitude : 51.515 , longitude : 7.453619 } ,
{ latitude : 51.503333 , longitude : - 0.119722 } ,
] ) ;Il renvoie la latitude minimale et maximale et la longitude minimale et maximale comme objet:
{
"minLat" : minimumLatitude ,
"maxLat" : maximumLatitude ,
"minLng" : minimumLongitude ,
"maxLng" : maximumLongitude ,
}isPointInPolygon(point, polygon)Vérifie si un point est à l'intérieur d'un polygone ou non.
geolib . isPointInPolygon ( { latitude : 51.5125 , longitude : 7.485 } , [
{ latitude : 51.5 , longitude : 7.4 } ,
{ latitude : 51.555 , longitude : 7.4 } ,
{ latitude : 51.555 , longitude : 7.625 } ,
{ latitude : 51.5125 , longitude : 7.625 } ,
] ) ; Renvoie true ou false
isPointWithinRadius(point, centerPoint, radius)Vérifie si un point est à l'intérieur d'un cercle ou non.
// checks if 51.525/7.4575 is within a radius of 5 km from 51.5175/7.4678
geolib . isPointWithinRadius (
{ latitude : 51.525 , longitude : 7.4575 } ,
{ latitude : 51.5175 , longitude : 7.4678 } ,
5000
) ; Renvoie true ou false
getRhumbLineBearing(origin, destination)Obtient un portage de la ligne Rhumb de deux points. Découvrez la différence entre la ligne de rhumb et le grand cercle roulement sur Wikipedia. La ligne Rhumb devrait être bien dans la plupart des cas:
http://en.wikipedia.org/wiki/Rhumb_line#general_and_mathematical_description
La fonction est fortement basée sur la grande version PHP de Doug Vanderweide (licenciée sous GPL 3.0) http://www.dougv.com/2009/07/13/calculating-the-bearing-and-pals-rose-derection-between-two-latitude-longitude-coordinats-in-php/
geolib . getRhumbLineBearing (
{ latitude : 52.518611 , longitude : 13.408056 } ,
{ latitude : 51.519475 , longitude : 7.46694444 }
) ;Renvoie le roulement calculé comme numéro.
getGreatCircleBearing(origin, destination)Obtient un grand cercle de deux points. Ceci est plus précis que le roulement de la ligne rhumb mais aussi plus lent.
geolib . getGreatCircleBearing (
{ latitude : 52.518611 , longitude : 13.408056 } ,
{ latitude : 51.519475 , longitude : 7.46694444 }
) ;Renvoie le roulement calculé comme numéro.
getCompassDirection(origin, destination, bearingFunction = getRhumbLineBearing) Obtient la direction de la boussole d'une coordonnée d'origine à une coordonnée de destination. Facultativement, une fonction pour déterminer le roulement peut être transmise sous forme de troisième paramètre. La valeur par défaut est getRhumbLineBearing .
geolib . getCompassDirection (
{ latitude : 52.518611 , longitude : 13.408056 } ,
{ latitude : 51.519475 , longitude : 7.46694444 }
) ; Renvoie la direction (par exemple NNE , SW , E ,…) comme chaîne.
orderByDistance(point, arrayOfPoints)Trie un tableau de coords par distance à une coordonnée de référence.
geolib . orderByDistance ( { latitude : 51.515 , longitude : 7.453619 } , [
{ latitude : 52.516272 , longitude : 13.377722 } ,
{ latitude : 51.518 , longitude : 7.45425 } ,
{ latitude : 51.503333 , longitude : - 0.119722 } ,
] ) ;Renvoie un tableau de points ordonnés par leur distance au point de référence.
findNearest(point, arrayOfPoints) Trouve le point le plus proche d'une coordonnée de référence. Il s'agit en fait d'une méthode de commodité qui utilise orderByDistance sous le capot et renvoie le premier résultat.
geolib . findNearest ( { latitude : 52.456221 , longitude : 12.63128 } , [
{ latitude : 52.516272 , longitude : 13.377722 } ,
{ latitude : 51.515 , longitude : 7.453619 } ,
{ latitude : 51.503333 , longitude : - 0.119722 } ,
{ latitude : 55.751667 , longitude : 37.617778 } ,
{ latitude : 48.8583 , longitude : 2.2945 } ,
{ latitude : 59.3275 , longitude : 18.0675 } ,
{ latitude : 59.916911 , longitude : 10.727567 } ,
] ) ;Renvoie le point le plus proche du point de référence.
getPathLength(points, distanceFunction = getDistance) Calcule la longueur d'une collection de coordonnées. Attend un tableau de points comme premier argument et éventuellement une fonction pour déterminer la distance comme deuxième argument. La valeur par défaut est getDistance .
geolib . getPathLength ( [
{ latitude : 52.516272 , longitude : 13.377722 } ,
{ latitude : 51.515 , longitude : 7.453619 } ,
{ latitude : 51.503333 , longitude : - 0.119722 } ,
] ) ;Renvoie la longueur du chemin en mètres en tant que numéro.
getDistanceFromLine(point, lineStart, lineEnd, accuracy = 1)Obtient la distance minimale d'un point à une ligne de deux points.
geolib . getDistanceFromLine (
{ latitude : 51.516 , longitude : 7.456 } ,
{ latitude : 51.512 , longitude : 7.456 } ,
{ latitude : 51.516 , longitude : 7.459 }
) ;Renvoie la distance la plus courte à la ligne donnée comme numéro.
Remarque: Si tous les points sont trop proches les uns des autres, la fonction peut renvoyer NAN. Dans ce cas, cela aide généralement à augmenter légèrement la précision (par exemple 0.01 ).
getBoundsOfDistance(point, distance)Calcule les coordonnées de délimitation de tous les points à la surface de la terre inférieure ou égale à la grande distance du cercle spécifié.
geolib . getBoundsOfDistance (
{ latitude : 34.090166 , longitude : - 118.276736555556 } ,
1000
) ;Renvoie un tableau avec les coordonnées du sud-ouest et du nord-est.
isPointInLine(point, lineStart, lineEnd)Calcule si le point donné se trouve dans une ligne formée par début et fin.
geolib . isPointInLine (
{ latitude : 0 , longitude : 10 } ,
{ latitude : 0 , longitude : 0 } ,
{ latitude : 0 , longitude : 15 }
) ;sexagesimalToDecimal(value)Convertit une coordonnée sexagesimal au format décimal
geolib . sexagesimalToDecimal ( `51° 29' 46" N` ) ;Renvoie la nouvelle valeur en tant que numéro décimal.
decimalToSexagesimal(value)Convertit une coordonnée décimale au format sexagesimal
geolib . decimalToSexagesimal ( 51.49611111 ) ; // -> 51° 29' 46`Renvoie la nouvelle valeur sous forme de chaîne sexagesimal.
geolib.getLatitude(point, raw = false)geolib.getLongitude(point, raw = false)Renvoie la latitude / longitude pour un point donné et la convertit en décimal. Si le deuxième argument est défini sur true, il ne convertit pas la valeur en décimal.
geolib . getLatitude ( { lat : 51.49611 , lng : 7.38896 } ) ; // -> 51.49611
geolib . getLongitude ( { lat : 51.49611 , lng : 7.38896 } ) ; // -> 7.38896Renvoie la valeur comme décimal ou dans son format d'origine si le deuxième argument était défini sur true.
toDecimal(point) Vérifie si une coordonnée est déjà au format décimal et, sinon, le convertit en. Fonctionne avec des valeurs uniques (par exemple 51° 32' 17" ) et des coordonnées complètes (par exemple {lat: 1, lon: 1} ) tant qu'elle dans un format pris en charge.
geolib . toDecimal ( `51° 29' 46" N` ) ; // -> 51.59611111
geolib . toDecimal ( 51.59611111 ) ; // -> 51.59611111Renvoie une valeur décimale pour la valeur d'entrée donnée.
computeDestinationPoint(point, distance, bearing, radius = earthRadius)Calcule le point de destination étant donné un point initial, une distance (en mètres) et un roulement (en degrés). Si aucun rayon n'est donné, il est par défaut du rayon terrestre moyen de 6 371 000 mètres.
ATTENTION: Cette formule n'est pas précise à 100% (mais très proche).
geolib . computeDestinationPoint (
{ latitude : 52.518611 , longitude : 13.408056 } ,
15000 ,
180
) ; geolib . computeDestinationPoint (
[ 13.408056 , 52.518611 ]
15000 ,
180
) ;Renvoie la destination dans le même format que les coordonnées d'entrée. Donc, si vous passez un point Geojson, vous obtiendrez un point Geojson.
getAreaOfPolygon(points)Calcule la surface d'un polygone.
geolib . getAreaOfPolygon ( [
[ 7.453635617650258 , 51.49320556213869 ] ,
[ 7.454583481047989 , 51.49328893754685 ] ,
[ 7.454778172179346 , 51.49240881084831 ] ,
[ 7.453832678225655 , 51.49231619246726 ] ,
[ 7.453635617650258 , 51.49320556213869 ] ,
] ) ;Renvoie le résultat en tant que numéro en mètres carrés.
getCoordinateKeys(point)Obtient les noms de propriété de ceux qui sont utilisés dans le point sous une forme normalisée:
geolib . getCoordinateKeys ( { lat : 1 , lon : 1 } ) ;
// -> { latitude: 'lat', longitude: 'lon' } Renvoie un objet avec une latitude et une propriété longitude . Leurs valeurs sont les noms de propriétés pour la latitude et la longitude qui sont utilisés dans le point passé. Ne devrait probablement être utilisé qu'à l'intérieur.
getCoordinateKey(point, keysToLookup) Est utilisé par getCoordinateKeys sous le capot et renvoie le nom de la propriété dans une liste de noms possibles.
geolib . getCoordinateKey ( { latitude : 1 , longitude : 2 } , [ 'lat' , 'latitude' ] ) ;
// -> latitude Renvoie le nom de la propriété en tant que chaîne ou undefined s'il n'y avait pas de correspondance.
isValidCoordinate(point)Vérifie si un point donné a au moins une latitude et une longitude et est dans un format pris en charge.
// true:
geolib . isValidCoordinate ( { latitude : 1 , longitude : 2 } ) ;
// false, longitude is missing:
geolib . isValidCoordinate ( { latitude : 1 } ) ;
// true, GeoJSON format:
geolib . isValidCoordinate ( [ 2 , 1 ] ) ; Renvoie true ou false .
getSpeed(startPointWithTime, endPointWithTime)Calcule la vitesse entre deux points dans une période de temps donnée.
geolib . getSpeed (
{ latitude : 51.567294 , longitude : 7.38896 , time : 1360231200880 } ,
{ latitude : 52.54944 , longitude : 13.468509 , time : 1360245600880 }
) ;Renvoyez la vitesse en mètres par seconde en tant que numéro.
convertSpeed(value, unit) Convertit le résultat de getSpeed en un format plus amical plus humain. Les unités actuellement disponibles sont mph et kmh .
unit peut être l'une des:
geolib . convertSpeed ( 29.8678 , 'kmh' ) ;Renvoie la valeur convertie en numéro.
convertDistance(value, unit)Convertit une distance donnée (en mètres) en une autre unité.
unit peut être l'une des:
geolib . convertDistance ( 14200 , 'km' ) ; // 14.2
geolib . convertDistance ( 500 , 'km' ) ; // 0.5Renvoie la distance convertie en numéro.
convertArea(value, unit) Convertit le résultat de getAreaForPolygon en une autre unité.
unit peut être l'une des:
geolib . convertArea ( 298678 , 'km2' ) ) ;Renvoie la zone convertie comme numéro.
wktToPolygon(wkt)Convertit le texte bien connu (aka wkt) en polygone que Geolib comprend. https://en.wikipedia.org/wiki/well-known_text_representation_of_geometry#geometric_objects
geolib . wktToPolygon ( 'POLYGON ((30 10.54321, 40 40, 20 40, 10 20, 30 10))' ) ;
// [
// { latitude: 10.54321, longitude: 30 },
// { latitude: 40, longitude: 40 },
// { latitude: 40, longitude: 20 },
// { latitude: 20, longitude: 10 },
// { latitude: 10, longitude: 30 },}
// ]Renvoie le tableau des coordonnées.
Dans la version 3.0.0, j'essaie de revenir un peu aux racines . Le géolib a été démarré une fois parce que j'avais besoin d'une poignée de méthodes pour effectuer des tâches liées à Geo très spécifiques comme obtenir la distance ou la direction entre deux points. Comme c'était l'une des toutes premières bibliothèques sur NPM à l'époque pour faire ce genre de choses d'une manière très simple, elle est devenue très populaire (avec plus de 300 000 téléchargements par mois en avril 2019!) Et en conséquence, il a obtenu beaucoup de contributions au fil des ans. Beaucoup dont je viens de fusionner aussi longtemps qu'ils avaient des tests d'accompagnement, sans regarder la cohérence, les conventions, la complexité, le style de codage ou même la qualité globale des fonctions que je ne comprenais parfois même pas pleinement.
J'ai maintenant nettoyé complètement la base de code, reconstruit toute la bibliothèque "à partir de zéro", unifié tous les arguments de la fonction, supprimé quelques fonctions où je ne savais pas s'ils devaient être ici (n'hésitez pas à les ajouter de votre utilisation!) Ou s'ils étaient même utilisés (fait quelques recherches sur github pour les noms de fonction, il y a eu des résultats zéro).
Le support d'altitude a été abandonné, ainsi que quelques fonctions qui ont inutilement rendu la bibliothèque de taille vraiment grande (par exemple, isPointInsideRobust était supérieure à 700 [!] Les lignes de code et ont été prélevées dans une bibliothèque différente).
J'ai supprimé le grognement du processus de construction, ajouté des outils "modernes" comme Eslint et plus jolis. Je suis passé de Travis CI à Coucle CI et je suis en train d'automatiser davantage le processus de version de nouvelles versions en utilisant semantic-release et conventional-commits . Je suis également passé de Pure JavaScript à TypeScript car je pense qu'il a certains avantages.
getDistance par défaut, de la fonction lente et précise de la fonction rapide et légèrement inexacte. L'ancienne fonction getDistance est désormais nommée getPreciseDistance tandis que l'ancienne fonction getDistanceSimple est désormais la fonction getDistance par défaut. Vous pouvez cependant passer getPreciseDistance comme argument à toute fonction qui utilise le calcul de la distance en interne.getBoundsOfDistance() renvoie désormais les coordonnées exactes dues à la suppression de la limitation artificielle de 8 décimalesgetCompassDirection() ne renvoie plus un objet avec une direction exacte et rugueuse mais uniquement la direction exacte comme chaînegetCompassDirection() n'est plus une chaîne ("cercle", "line") mais une fonction pour déterminer le roulement (vous pouvez passer getRhumbLineBearing ou getGreatCircleBearing ). La fonction reçoit l'origine et la destination comme premier et deuxième argument. Si aucun argument de la troisième année n'a été donné, getRhumbLineBearing(origin, dest) est utilisé par défaut.roughCompassDirection(exact) si vous n'avez vraiment besoin que d'une direction très rugueuse (et potentiellement inexacte ou inappropriée). Mieux vaut ne pas l'utiliser.orderByDistance() ne modifie plus son entrée, donc n'ajoute pas de distance et de propriété key aux coordonnées retournées.getSpeed() est désormais toujours renvoyé sous forme de mètres par seconde . Il peut être converti à l'aide de la nouvelle fonction de commodité convertSpeed(mps, targetUnit)findNearest() ne prend plus les arguments offset et limit les arguments. Ce n'est qu'une méthode de commodité pour obtenir le point le plus proche d'un ensemble de coordonnées. Si vous en avez besoin, jetez un œil à l'implémentation et implémentez votre propre logique en utilisant orderByDistance52° 46' 21.0004" dans de rares cas, mais il est également plus précis qu'auparavant.computeDestinationPointgetBoundsgetBoundsOfDistancegetCentergetCenterOfBoundsgetCompassDirectiongetDistanceFromLinegetPathLengthgetRhumbLineBearinggetSpeedisDecimalisPointInLineisPointNearLineisSexagesimalorderByDistancegetKeys renommés pour getCoordinateKeysvalidate renommé isValidCoordinategetLat renommé de getLatitudegetLon renommé de getLongitudelatitude -> renommé getLatitudelongitude -> renommé de getLongitudeconvertUnit -> comanché à convertDistance, car le nom était trop ambiguuseDecimal en toDecimaldecimal2sexagesimal renommé de decimalToSexagesimalsexagesimal2decimal renommé sexagesimalToDecimalgetDistance renommée pour getPreciseDistancegetDistanceSimple Imple renommée à getDistanceisPointInside renommé isPointInPolygonisPointInCircle renommé isPointWithinRadiusgetBearing renommé pour getGreatCircleBearing pour être plus explicitegetElev -> suppriméelevation -> supprimécoords -> REPLIÉS (pourrait être réadapté en tant que getcoordinate ou getNormalizedCoORNINate)ll -> supprimé (parce que wtf?)preparePolygonForIsPointInsideOptimized -> supprimé en raison de la documentation manquante et des tests manquantsisPointInsideWithPreparedPolygon -> supprimé en raison de la documentation manquanteisInside Alias -> supprimé (trop ambigu) - Utilisez isPointInPolygon ou isPointWithinRadiuswithinRadius -> supprimé, utilisez isPointWithinRadiusgetDirection Alias -> Supprimé (encombrement inutile) - Utilisez getCompassDirectiongetAreaOfPolygon pour calculer la zone d'un polygonegetCoordinateKey pour obtenir un nom de propriété (par exemple, lat ou lng d'un objet basé sur un tableau de noms possibles)
