Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Données spatiales Amazon Neptune prend désormais en charge les requêtes spatiales, ce qui vous permet de stocker et d'analyser des données géométriques dans votre graphique. Bien qu'elles soient couramment utilisées pour les emplacements géographiques (comme les coordonnées sur une carte), les entités spatiales fonctionnent avec toutes les données bidimensionnelles où la position et la proximité sont importantes. Utilisez cette fonctionnalité pour répondre à des questions telles que « Quels magasins se trouvent dans un rayon de 8 km de ce client ? » , « Trouvez tous les itinéraires de livraison qui croisent cette zone de service » ou « Quels composants de ce plan d'étage chevauchent la zone CVC ? » Neptune met en œuvre le support spatial à l'aide de fonctions de types spatiaux standard qui fonctionnent avec des points, des polygones et d'autres formes géométriques. Vous pouvez stocker les données spatiales sous forme de propriétés sur les nœuds et les arêtes, puis utiliser des fonctions spatiales pour calculer les distances, vérifier si les points se situent dans les limites ou trouver des régions qui se chevauchent, le tout dans vos requêtes OpenCypher. **Cas d’utilisation courants :** + **Applications géographiques** : recommandations basées sur la localisation, géofencing, planification d'itinéraires et analyse du territoire + **Gestion des installations et de l'espace** : disposition du plan d'étage, placement de l'équipement et couverture des zones + **Topologie du réseau** : cartographie de l'infrastructure physique, zones de couverture et limites de service + **Conception et CAO** : positionnement des composants, détection des collisions et relations spatiales dans les conceptions 2D + **Développement du jeu** : positionnement des personnages, détection des collisions et area-of-effect calculs L'implémentation des types spatiaux dans Amazon Neptune suit les directives ISO/IEC 13249-3:2016, comme les autres bases de données. Ils [Fonctions spatiales](access-graph-opencypher-22-spatial-functions.md) sont disponibles dans le langage de requête OpenCypher. ## Système de coordonnées Neptune possède un identifiant de référence spatiale (SRID) pour l'ensemble d'une base de données. L'homogénéité du système de coordonnées réduit les erreurs des utilisateurs lors des requêtes et améliore les performances de la base de données. La première version (1.4.7.0) prend en charge le système de coordonnées cartésien, également appelé SRID 0. L'implémentation Neptune du SRID 0 est compatible avec les valeurs de longitude et de latitude. `ST_DistanceSpheroid`À utiliser pour calculer les distances en fonction du WGS84 /SRID 4326. L'implémentation actuelle prend en charge le stockage de coordonnées tridimensionnelles. Les fonctions spatiales ne prennent actuellement en charge que l'utilisation des coordonnées des axes x et y (bidimensionnelles). Les coordonnées de l'axe Z ne sont actuellement pas prises en charge par les fonctions spatiales disponibles. ## Stockage des données de localisation Stockez les données de localisation sur les nœuds et les arêtes à l'aide du type de propriété Geometry. Créez des valeurs géométriques à partir du format WKT (Known Text), une méthode standard pour représenter des formes géographiques sous forme de texte. Par exemple, pour enregistrer l'emplacement d'un point : ``` CREATE (n:airport {code: 'ATL', location: ST_GeomFromText('POINT (-84.4281 33.6367)')}) ``` Lorsque vous travaillez avec des coordonnées géographiques, le premier argument (x) représente la longitude et le second argument (y) représente la latitude. Cela suit l'ordre de coordonnées standard utilisé dans les bases de données spatiales et la norme ISO 19125. **Note** Neptune prend désormais en charge un nouveau type de données appelé « Géométrie ». La propriété de géométrie d'un nœud ou d'une arête peut être créée à partir d'une chaîne WKT à l'aide de la `ST_GeomFromText` fonction. Neptune stockera automatiquement les données relatives aux points dans un index spatial spécialisé afin d'améliorer les performances des fonctions de types spatiaux. Par exemple, l'index spatial spécialisé accélère le processus `ST_Contains` utilisé pour trouver les points dans un polygone. [page Wikipedia sur la représentation textuelle bien connue de la géométrie](https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry) ## Chargement de données spatiales en masse Lorsque vous chargez des données en bloc, spécifiez le type de géométrie dans votre en-tête CSV. Neptune analysera les chaînes WKT et créera les propriétés de géométrie appropriées : ``` :ID,:LABEL,code:String,city:String,location:Geometry 21,airport,ATL,Atlanta,POINT (-84.42810059 33.63669968) 32,airport,ANC,Anchorage,POINT (-149.9960022 61.17440033) 43,airport,AUS,Austin,POINT (-97.66989899 30.19449997) ``` Pour plus de détails sur le format CSV, voir Format de [chargement groupé OpenCypher](bulk-load-tutorial-format-opencypher.md). ## Interrogation des données spatiales Les exemples de requêtes suivants utilisent le jeu de [données des routes aériennes](https://github.com/krlawrence/graph/tree/main/sample-data) pour montrer comment utiliser les fonctions spatiales dans Neptune. Si vos données possèdent des propriétés de latitude et de longitude distinctes au lieu d'une propriété de géométrie, vous pouvez les convertir en points au moment de la requête. Trouvez les 10 aéroports les plus proches d'un lieu donné : ``` MATCH (a:airport) WITH a, ST_GeomFromText('POINT (' + a.lon + ' ' + a.lat + ')') AS airportLocation WITH a, airportLocation, ST_Distance(ST_GeomFromText('POINT (-84.4281 33.6367)'), airportLocation) AS distance WHERE distance IS NOT NULL RETURN a.code, a.city, distance ORDER BY distance ASC LIMIT 10 ``` Si vous avez déjà enregistré des emplacements`ST_Point`, vous pouvez utiliser ces valeurs de position directement : 1. Définition de la propriété ``` MATCH (a:airport) SET a.location = ST_GeomFromText('POINT (' + a.lon + ' ' + a.lat + ')') ``` 1. Requête utilisant ST\$1Distance : ``` MATCH (a:airport) WHERE a.location IS NOT NULL WITH a, ST_Distance(ST_GeomFromText('POINT (-84.4281 33.6367)'), a.location) AS distance RETURN a.code, a.city, distance ORDER BY distance ASC LIMIT 10 ``` ### Utilisation du pilote Bolt La plupart des méthodes de requête renvoient les valeurs de géométrie sous forme de chaînes WKT, lisibles par l'homme. Si vous utilisez le pilote Bolt, les valeurs de géométrie sont renvoyées au format WKB (Known Binary) pour plus d'efficacité. Convertissez le WKB en objet de géométrie dans votre application : ``` try (Session session = driver.session()) { Result result = session.run("MATCH (n:airport {code: 'ATL'}) RETURN n.location as geom"); Record record = result.single(); byte[] wkbBytes = record.get("geom").asByteArray(); // Convert WKB to Geometry object using JTS library WKBReader wkbReader = new WKBReader(); Geometry geom = wkbReader.read(wkbBytes); } ``` # Fonctions spatiales Les fonctions spatiales suivantes sont disponibles dans Neptune OpenCypher pour travailler avec des types de données géométriques : + [ST\$1Point](access-graph-opencypher-22-spatial-functions-st-point.md) + [ST\$1 GeomFromText](access-graph-opencypher-22-spatial-functions-st-geomfromtext.md) + [ST\$1 AsText](access-graph-opencypher-22-spatial-functions-st-astext.md) + [ST\$1 GeometryType](access-graph-opencypher-22-spatial-functions-st-geometrytype.md) + [ST\$1Equals](access-graph-opencypher-22-spatial-functions-st-equals.md) + [ST\$1Contains](access-graph-opencypher-22-spatial-functions-st-contains.md) + [ST\$1Intersects](access-graph-opencypher-22-spatial-functions-st-intersect.md) + [ST\$1Distance](access-graph-opencypher-22-spatial-functions-st-distance.md) + [ST\$1 DistanceSpheroid](access-graph-opencypher-22-spatial-functions-st-distancespheroid.md) + [ST\$1Enveloppe](access-graph-opencypher-22-spatial-functions-st-envelope.md) + [ST\$1Buffer](access-graph-opencypher-22-spatial-functions-st-buffer.md) # ST\$1Point ST\$1Point renvoie un point à partir des valeurs de coordonnées en entrée. **Syntaxe** ``` ST_Point(x, y, z) ``` **Arguments** + `x`- Une valeur de type de données DOUBLE PRECISION qui représente une première coordonnée. + `y`- Une valeur de type de données DOUBLE PRECISION qui représente une deuxième coordonnée. + `z`- (facultatif) **Ordre de coordonnées** Lorsque vous travaillez avec des coordonnées géographiques, le premier argument (`x`) représente la **longitude** et le second (`y`) représente la **latitude**. Cela suit l'ordre de coordonnées standard utilisé dans les bases de données spatiales et la norme ISO 19125. ``` // Correct: longitude first, latitude second ST_Point(-84.4281, 33.6367) // Atlanta airport // Incorrect: latitude first, longitude second ST_Point(33.6367, -84.4281) // This will return NaN in distance calculations ``` **Plages de coordonnées valides** Pour les données géographiques, assurez-vous que les coordonnées se situent dans des plages valides : + Longitude (`x`) : -180 à 180 + Latitude (`y`) : -90 à 90 Les coordonnées situées en dehors de ces plages seront renvoyées `NaN` (ce n'est pas un nombre) lorsqu'elles sont utilisées avec des fonctions de calcul de distance telles que`ST_DistanceSpheroid`. **Type de retour** GÉOMÉTRIE du sous-type POINT Si x ou y est null, null est renvoyé. **Exemples** Ce qui suit construit une géométrie ponctuelle à partir des coordonnées en entrée. ``` RETURN ST_Point(5.0, 7.0); POINT(5 7) ``` # ST\$1 GeomFromText ST\$1 GeomFromText construit un objet géométrique à partir d'une représentation textuelle connue (WKT) d'une géométrie d'entrée. **Syntaxe** ``` ST_GeomFromText(wkt_string) ``` **Arguments** + `wkt_string`- Une valeur de type de données STRING qui est une représentation WKT d'une géométrie. **Type de retour** GEOMETRY Si wkt\$1string est null, null est renvoyé. Si wkt\$1string n'est pas valide, alors a BadRequestException est renvoyé. **Exemples** ``` RETURN ST_GeomFromText('POLYGON((0 0,0 1,1 1,1 0,0 0))') POLYGON((0 0,0 1,1 1,1 0,0 0)) ``` # ST\$1 AsText ST\$1 AsText renvoie la représentation textuelle connue (WKT) d'une géométrie d'entrée. **Syntaxe** ``` ST_AsText(geo) ``` **Arguments** + `geo`- Une valeur de type de données GEOMETRY, ou une expression qui correspond à une GEOMETRY. **Type de retour** CHAÎNE Si geo est null, null est renvoyé. Si le paramètre d'entrée n'est pas une géométrie, la valeur a BadRequestException est renvoyée. Si le résultat est supérieur à une CHAÎNE de 64 Ko, une erreur est renvoyée. **Exemples** ``` RETURN ST_AsText(ST_GeomFromText('POLYGON((0 0,0 1,1 1,1 0,0 0))')) POLYGON((0 0,0 1,1 1,1 0,0 0)) ``` # ST\$1 GeometryType ST\$1 GeometryType renvoie le type de géométrie sous forme de chaîne. **Syntaxe** ``` ST_GeometryType(geom) ``` **Arguments** + `geom`- Une valeur du type de données GEOMETRY ou une expression qui correspond à un type GEOMETRY. **Type de retour** CHAÎNE Si geom est null, null est renvoyé. Si le paramètre d'entrée n'est pas une géométrie, la valeur a BadRequestException est renvoyée. **Exemples** ``` RETURN ST_GeometryType(ST_GeomFromText('LINESTRING(77.29 29.07,77.42 29.26,77.27 29.31,77.29 29.07)')); ST_LineString ``` # ST\$1Equals ST\$1equals renvoie la valeur true si les projections 2D des géométries en entrée sont topologiquement égales. Les géométries sont considérées comme topologiquement égales si elles comportent des ensembles de points égaux. Dans des géométries topologiquement égales, l'ordre des sommets peut différer tout en maintenant cette égalité. **Syntaxe** ``` ST_Equals(geom1, geom2) ``` **Arguments** + `geom1`- Une valeur du type de données GEOMETRY ou une expression qui correspond à un type GEOMETRY. + `geom2`- Une valeur du type de données GEOMETRY ou une expression qui correspond à un type GEOMETRY. Cette valeur est comparée à geom1 afin de déterminer si elle est égale à geom1. **Type de retour** BOOLEAN Si geom1 ou geom2 est null, null est renvoyé. Si geom1 ou geom2 ne sont pas des géométries, alors a est renvoyé. BadRequestException **Exemples** ``` RETURN ST_Equals( ST_GeomFromText('POLYGON ((0 2,1 1,0 -1,0 2))'), ST_GeomFromText('POLYGON((-1 3,2 1,0 -3,-1 3))')); false ``` Ce qui suit vérifie si les deux chaînes de lignes sont géométriquement égales. ``` RETURN ST_Equals( ST_GeomFromText('LINESTRING (1 0, 10 0)'), ST_GeomFromText('LINESTRING(1 0,5 0,10 0)')); true ``` # ST\$1Contains ST\$1Contains renvoie true si la projection 2D de la première géométrie en entrée contient la projection 2D de la deuxième géométrie en entrée. La géométrie A contient la géométrie B si chaque point de B est un point de A et que leur intérieur comporte une intersection non vide. ST\$1Contains (A, B) est équivalent à ST\$1Within (B, A). **Syntaxe** ``` ST_Contains(geom1, geom2) ``` **Arguments** + `geom1`- Une valeur de type GEOMETRY ou une expression qui correspond à un type GEOMETRY. + `geom2`- Une valeur de type GEOMETRY ou une expression qui correspond à un type GEOMETRY. Cette valeur est comparée à geom1 afin de déterminer si elle est contenue dans geom1. **Type de retour** BOOLEAN Si geom1 ou geom2 est null, null est renvoyé. Si le paramètre d'entrée n'est pas une géométrie, la valeur a BadRequestException est renvoyée. **Exemples** ``` RETURN ST_Contains( ST_GeomFromText('POLYGON((0 2,1 1,0 -1,0 2))'), ST_GeomFromText('POLYGON((-1 3,2 1,0 -3,-1 3))')); false ``` # ST\$1Intersects ST\$1Intersects renvoie true si les projections 2D des deux géométries d’entrée ont au moins un point en commun. **Syntaxe** ``` ST_Intersects(geom1, geom2) ``` **Arguments** + `geom1`- Une valeur du type de données GEOMETRY ou une expression qui correspond à un type GEOMETRY. + `geom2`- Une valeur du type de données GEOMETRY ou une expression qui correspond à un type GEOMETRY. **Type de retour** BOOLEAN Si geom1 ou geom2 est null, null est renvoyé. Si le paramètre d'entrée n'est pas une géométrie, la valeur a BadRequestException est renvoyée. **Exemples** ``` RETURN ST_Intersects( ST_GeomFromText('POLYGON((0 0,10 0,10 10,0 10,0 0),(2 2,2 5,5 5,5 2,2 2))'), ST_GeomFromText('MULTIPOINT((4 4),(6 6))')); true ``` # ST\$1Distance Pour les géométries d’entrée, ST\$1Distance renvoie la distance euclidienne minimale entre les projections 2D des deux valeurs géométriques d’entrée. **Syntaxe** ``` ST_Distance(geo1, geo2) ``` **Arguments** + `geo1`- Une valeur du type de données GEOMETRY, ou une expression qui correspond à un type GEOMETRY. + `geo2`- Une valeur de type de données GEOMETRY, ou une expression qui correspond à une GEOMETRY. **Type de retour** DOUBLE PRÉCISION dans les mêmes unités que les géométries d'entrée. Si geo1 ou geo2 est nul, nul est renvoyé. Si le paramètre d'entrée n'est pas une géométrie, la valeur a BadRequestException est renvoyée. **Exemples** ``` RETURN ST_Distance( ST_GeomFromText('POLYGON((0 2,1 1,0 -1,0 2))'), ST_GeomFromText('POLYGON((-1 -3,-2 -1,0 -3,-1 -3))')); 1.4142135623731 ``` # ST\$1 DistanceSpheroid Renvoie la distance minimale en mètres entre deux lon/lat géométries. Le sphéroïde est WGS84 /SRID 4326. **Syntaxe** ``` ST_DistanceSpheroid(geom1, geom2); ``` **Arguments** + `geom1`- Une valeur du type de données GEOMETRY ou une expression qui correspond à un type GEOMETRY. + `geom2`- Une valeur du type de données GEOMETRY ou une expression qui correspond à un type GEOMETRY. **Type de retour** FLOAT Si geom est null, null est renvoyé. **Exemples** ``` RETURN ST_DistanceSpheroid( ST_GeomFromText('POINT(-110 42)'), ST_GeomFromText('POINT(-118 38)')) 814278.77 ``` # ST\$1Enveloppe ST\$1Envelope renvoie le cadre de délimitation minimal de la géométrie en entrée, comme suit : + Si la géométrie en entrée est vide, la géométrie renvoyée sera POINT EMPTY. + Si le cadre de délimitation minimal de la géométrie en entrée dégénère en un point, la géométrie renvoyée est un point. + Si aucune des réponses précédentes n'est vraie, la fonction renvoie un counter-clockwise-oriented polygone dont les sommets sont les coins du cadre de délimitation minimal. Pour toutes les entrées non vides, la fonction fonctionne sur la projection 2D de la géométrie en entrée. **Syntaxe** ``` ST_Envelope(geom) ``` **Arguments** + `geom`- Une valeur du type de données GEOMETRY ou une expression qui correspond à un type GEOMETRY. **Type de retour** GEOMETRY Si geom est null, null est renvoyé. **Exemples** ``` RETURN ST_Envelope(ST_GeomFromText("POLYGON ((2 1, 4 3, 6 1, 5 5, 3 4, 2 1))")) POLYGON ((2 1, 6 1, 6 5, 2 5, 2 1)) ``` # ST\$1Buffer ST\$1Buffer renvoie une géométrie 2D qui représente tous les points dont la distance par rapport à la géométrie d’entrée projetée sur le plan cartésien XY est inférieure ou égale à la distance d’entrée. **Syntaxe** ``` ST_Buffer(geom, distance, number_of_segments_per_quarter_circle) ``` **Arguments** + `geom`- Une valeur du type de données GEOMETRY ou une expression qui correspond à un type GEOMETRY. + `distance`- Une valeur de type de données DOUBLE PRECISION qui représente la distance (ou le rayon) de la mémoire tampon. + `number_of_segments_per_quarter_circle`- Une valeur de type INTEGER (doit être supérieure ou égale à 0). Cette valeur détermine le nombre de points à approcher d’un quart de cercle autour de chaque sommet de la géométrie d’entrée. Les valeurs négatives ont pour valeur par défaut zéro. La valeur par défaut est de 8. **Type de retour** GEOMETRY La fonction ST\$1Buffer renvoie une géométrie bidimensionnelle (2D) dans le plan cartésien XY. **Exemples** ``` RETURN ST_Buffer(ST_GeomFromText('LINESTRING (1 2,5 2,5 8)'), 2, 4); POLYGON ((3 4, 3 8, 3.1522409349774265 8.76536686473018, 3.585786437626905 9.414213562373096, 4.234633135269821 9.847759065022574, 5 10, 5.765366864730179 9.847759065022574, 6.414213562373095 9.414213562373096, 6.847759065022574 8.76536686473018, 7 8, 7 2, 6.847759065022574 1.2346331352698203, 6.414213562373095 0.5857864376269051, 5.765366864730179 0.1522409349774265, 5 0, 1 0, 0.2346331352698193 0.152240934977427, -0.4142135623730954 0.5857864376269051, -0.8477590650225737 1.2346331352698208, -1 2.0000000000000004, -0.8477590650225735 2.7653668647301797, -0.4142135623730949 3.414213562373095, 0.2346331352698206 3.8477590650225735, 1 4, 3 4)) ``` Ce qui suit renvoie la zone tampon de la géométrie du point d'entrée qui correspond approximativement à un cercle. Étant donné que la commande spécifie 3 comme nombre de segments par quart de cercle, la fonction utilise trois segments pour approcher le quart de cercle. ``` RETURN ST_Buffer(ST_GeomFromText('POINT (1 1)'), 1.0, 8)); POLYGON ((2 1, 1.9807852804032304 0.8049096779838718, 1.9238795325112867 0.6173165676349102, 1.8314696123025453 0.4444297669803978, 1.7071067811865475 0.2928932188134525, 1.5555702330196022 0.1685303876974548, 1.3826834323650898 0.0761204674887133, 1.1950903220161284 0.0192147195967696, 1 0, 0.8049096779838718 0.0192147195967696, 0.6173165676349103 0.0761204674887133, 0.444429766980398 0.1685303876974545, 0.2928932188134525 0.2928932188134524, 0.1685303876974546 0.4444297669803978, 0.0761204674887133 0.6173165676349102, 0.0192147195967696 0.8049096779838714, 0 0.9999999999999999, 0.0192147195967696 1.1950903220161284, 0.0761204674887132 1.3826834323650896, 0.1685303876974545 1.555570233019602, 0.2928932188134523 1.7071067811865475, 0.4444297669803978 1.8314696123025453, 0.6173165676349097 1.9238795325112865, 0.8049096779838714 1.9807852804032304, 0.9999999999999998 2, 1.1950903220161284 1.9807852804032304, 1.38268343236509 1.9238795325112865, 1.5555702330196017 1.8314696123025453, 1.7071067811865475 1.7071067811865477, 1.8314696123025453 1.5555702330196022, 1.9238795325112865 1.3826834323650905, 1.9807852804032304 1.1950903220161286, 2 1)) ```