Building interactive graph visualizations with Sigma React - from basic setup to advanced customizations

A Look At Graph Visualization With Sigma React


import Image from 'next/image';
import Subscribe from '../../components/Subscribe';

Every year with my family I head out into a nearby National Forest with a saw (except when I forget to bring it) and a National Forest Motor Vehicle User Map (MVUM) to find the annual Lyon family Christmas tree. I always wondered if I could analyze the data for the MVUMs to make my own map for hunting Christmas trees - so that's what I did for this map as part of the [30 Day Map Challenge.](https://github.com/johnymontana/30-day-map-challenge/tree/main)

I also did a bit of research using aerial imagery and QGIS to find areas that might have the perfect Christmas trees, then loaded the National Forest MVUM data in [Wherobots Cloud](https://wherobots.com/wherobots-cloud/) to find the forest service roads leading to the areas I annotated in QGIS with Spatial SQL.

<Image
  src={'/static/images/finding-tree/07-navigation-final.png'}
  alt={'Finding the perfect Christmas tree'}
  width={3300}
  height={2550}
/>

To follow along create a free account in [Wherobots Cloud](https://www.wherobots.services)

<Subscribe />

## Loading National Forest Motor Vehicle User Map Data

The US Forest Service publishes the National Forest Motor Vehicle User Map (MVUM) which shows roads and trails for accessing National Forest land. These maps are usually my primary navigation method when I'm driving into a National Forest. The USFS makes this map data available for download [here](https://data-usfs.hub.arcgis.com/datasets/motor-vehicle-use-map-roads-feature-layer/explore) as GeoJSON, CSV, or Shapefile.

I downloaded the Shapefile format, then uploaded it to Wherobots Cloud via the "Files" tab, which allows me to access this data via S3.

<Image
  src={'/static/images/finding-tree/files1.png'}
  alt={'Working with files in Wherobots Cloud'}
  width={3134}
  height={1700}
/>

Now we're ready to import that Shapefile into SedonaDB.

```py
# To import a Shapefile into SedonaDB we can use the built-in ShapefileReader which will
#   give us a SpatialRDD then convert that SpatialRDD to a Spatial DataFrame
# Then we create a new view called roads with this MVUM map data
# Finally we print the schema of the roads_df DataFrame

spatialRDD = ShapefileReader.readToGeometryRDD(sedona, S3_URL_ROADS_SHP)
roads_df = Adapter.toDf(spatialRDD, sedona)
roads_df.createOrReplaceTempView("roads")
roads_df.printSchema()
```

```md
root
|-- geometry: geometry (nullable = true)
|-- OBJECTID: string (nullable = true)
|-- RTE*CN: string (nullable = true)
|-- ID: string (nullable = true)
|-- NAME: string (nullable = true)
|-- BMP: string (nullable = true)
|-- EMP: string (nullable = true)
|-- SEG_LENGTH: string (nullable = true)
|-- GIS_MILES: string (nullable = true)
|-- SYMBOL: string (nullable = true)
|-- MVUM_SYMBO: string (nullable = true)
|-- JURISDICTI: string (nullable = true)
|-- OPERATIONA: string (nullable = true)
|-- SURFACETYP: string (nullable = true)
|-- SYSTEM: string (nullable = true)
|-- SEASONAL: string (nullable = true)
|-- PASSENGERV: string (nullable = true)
|-- PASSENGE_1: string (nullable = true)
|-- HIGHCLEARA: string (nullable = true)
|-- HIGHCLEA_1: string (nullable = true)
|-- TRUCK: string (nullable = true)
|-- TRUCK_DATE: string (nullable = true)
|-- BUS: string (nullable = true)
|-- BUS_DATESO: string (nullable = true)
|-- MOTORHOME: string (nullable = true)
|-- MOTORHOME*: string (nullable = true)
|-- FOURWD*GT5: string (nullable = true)
|-- FOURWD_G_1: string (nullable = true)
|-- TWOWD_GT50: string (nullable = true)
|-- TWOWD_GT_1: string (nullable = true)
|-- TRACKED_OH: string (nullable = true)
|-- TRACKED\_\_1: string (nullable = true)
|-- OTHER_OHV*: string (nullable = true)
|-- OTHER_OH_1: string (nullable = true)
|-- ATV: string (nullable = true)
|-- ATV_DATESO: string (nullable = true)
|-- MOTORCYCLE: string (nullable = true)
|-- MOTORCYC_1: string (nullable = true)
|-- OTHERWHEEL: string (nullable = true)
|-- OTHERWHE_1: string (nullable = true)
|-- TRACKED**2: string (nullable = true)
|-- TRACKED**3: string (nullable = true)
|-- OTHER_OH_2: string (nullable = true)
|-- OTHER_OH_3: string (nullable = true)
|-- ADMINORG: string (nullable = true)
|-- SECURITYID: string (nullable = true)
|-- DISTRICTNA: string (nullable = true)
|-- FORESTNAME: string (nullable = true)
|-- FIELD_ID: string (nullable = true)
|-- SBS_SYMBOL: string (nullable = true)
|-- ROUTESTATU: string (nullable = true)
|-- GLOBALID: string (nullable = true)
|-- TA_SYMBOL: string (nullable = true)
|-- SHAPE: string (nullable = true)
|-- SHAPELEN: string (nullable = true)
```

Now that we've created a view with our roads data we can use Spatial SQL to query our MVUM data.

```py
sedona.sql("SELECT COUNT(*) AS num FROM roads").show()
```

```md
+------+
| num  |
+------+
|151457|
+------+
```

Since we're going to be hunting for Christmas trees near Santa, Idaho we know we're only interested in roads within the Idaho Panhandle National Forests.

```py
idaho_df = sedona.sql("""
SELECT geometry, NAME as name, FORESTNAME AS forest, SEASONAL AS seasonal, SYMBOL AS symbol FROM roads
WHERE FORESTNAME = 'Idaho Panhandle National Forests'
""")
idaho_df.createOrReplaceTempView("idaho")
idaho_df.show(5)
```

```md
+--------------------+-----------------+--------------------+--------+------+
| geometry           | name            | forest             |seasonal|symbol|
+--------------------+-----------------+--------------------+--------+------+
|LINESTRING (-115....| DOMINION CREEK  |Idaho Panhandle N...|yearlong|     3|
|LINESTRING (-116....| PLACER RIDGE A  |Idaho Panhandle N...|yearlong|     1|
|LINESTRING (-116....| RAINEY HILL     |Idaho Panhandle N...|yearlong|     1|
|LINESTRING (-117....| URANIUM         |Idaho Panhandle N...|yearlong|     1|
|LINESTRING (-116....|HAMILTON MOUNTAIN|Idaho Panhandle N...|yearlong|     1|
+--------------------+-----------------+--------------------+--------+------+
```

```py
SedonaKepler.create_map(idaho_df, name="Roads")
```

<Image
  src={'/static/images/finding-tree/kepler_roads.png'}
  alt={'Visualizing roads using SedonaKepler'}
  width={1530}
  height={806}
/>

That's a lot of roads! How are we going to figure out where the best Christmas trees are? Let's look at aerial imagery of the area to find what look like nice tree stands to help narrow down the hunt a bit. We'll use my favorite desktop GIS tool QGIS for this.

## Annotating Aerial Imagery In QGIS

QGIS by default includes tile layers from OpenStreetMap, but we can also add other tile server connections to bring in tile layers from other providers. [This StackExchange answer](https://gis.stackexchange.com/questions/20191/adding-basemaps-in-qgis/217670#217670) describes how to add aerial imagery from Google and Bing to QGIS.

<div style={{ margin: 'auto', maxWidth: '500px' }}>
  <Image
    src={'/static/images/finding-tree/qgis_newtiles.png'}
    alt={'Adding a new tile server to QGIS'}
    width={974}
    height={1178}
  />
</div>

<div style={{ margin: 'auto', maxWidth: '500px' }}>
  <Image
    src={'/static/images/finding-tree/qgis_google.png'}
    alt={'Adding Google aerial imagery'}
    width={1496}
    height={1300}
  />
</div>

Once we add the aerial imagery tile layer we can start to explore the area where
we hope to find some great Christmas trees, in this case in the Idaho Panhandle National
Forests. We're looking for nice heavy green tree stands, not too much vertical variation
for easy access and not near streams and rivers or hiking trails.

Let's add a new layer to our QGIS project so we can keep track of where these tree stands are. I chose a Geopackage layer with Polygon geometry because we're going to draw polygons over the aerial imagery to indicate places that we think will be good for potential trees.

<div style={{ margin: 'auto', maxWidth: '500px' }}>
  <Image
    src={'/static/images/finding-tree/qgis_newlayer.png'}
    alt={'Adding a new layer in QGIS'}
    width={1320}
    height={1652}
  />
</div>

Right-click on the layer and choose "Toggle editing" then click the icon to create
a new polygon. We can now draw polygons over the aerial imagery, each new polygon
will be added as a new feature to our new Geopackage layer. I didn't create any other
fields so the `fid` is a sequence that will be autogenerated. If you wanted to keep
notes about why you thought this area looked good you could do that by adding another
field to the layer.

<Image
  src={'/static/images/finding-tree/qgis_polygon.png'}
  alt={'Adding polygon features'}
  width={1830}
  height={1262}
/>

Once we've annotated a few areas (I found 5 or 6) we can right click on our layer and select "Save as". I exported this layer as GeoJSON, to a file called `idaho_treestands.geojson`.

<div style={{ margin: 'auto', maxWidth: '500px' }}>
  <Image
    src={'/static/images/finding-tree/qgis_exportgeojson.png'}
    alt={'LinkedIn Post'}
    width={1406}
    height={1544}
  />
</div>

## Finding Roads To Our Tree Stands With SedonaDB

Now that we've exported our polygon annotations as GeoJSON it's time to import that data into SedonaDB along with our road data so we can the Forest Service roads that will take us to our tree stands. Return to the "Files" tab in Wherobots Cloud and upload the GeoJSON file we just exported from QGIS.

<Image
  src={'/static/images/finding-tree/files2.png'}
  alt={'The Wherobots Files interface'}
  width={2674}
  height={1096}
/>

To import GeoJSON into SedonaDB we can use Spark's built-in JSON import functionality if we first define the schema used by GeoJSON.

```py
schema = "type string, name string, crs string, features array<struct<type string, geometry string, properties map<string, string>>>"
```

```py
tree_df = sedona.read.option('multiline', True).json(S3_URL_TREES, schema=schema).selectExpr("explode(features) as features").select("features.*").withColumn("geometry", expr("ST_GeomFromGeoJson(geometry)")).withColumn("fid", expr("properties['fid']")).drop("properties").drop("type")
tree_df.createOrReplaceTempView("trees")
tree_df.show(5)
```

```md
+--------------------+---+
| geometry           |fid|
+--------------------+---+
|POLYGON ((-116.52...|  1|
|POLYGON ((-116.54...|  2|
|POLYGON ((-116.12...|  3|
|POLYGON ((-116.16...|  4|
|POLYGON ((-116.09...|  5|
+--------------------+---+
only showing top 5 rows
```

```py
SedonaKepler.create_map(tree_df, name="Tree Stands")
```

<Image
  src={'/static/images/finding-tree/kepler_trees.png'}
  alt={'Visualizing the tree layer with SedonaKepler'}
  width={2008}
  height={822}
/>

As we can see above I found 6 possible tree stands I want to explore. Now we can do a spatial join operation to find the Forest Service roads nearest these tree stands. We could either use the [`ST_Distance` Spatial SQL function](https://docs.wherobots.services/1.2.0/references/sedonadb/vector-data/Function/?h=st_distance#st_distance) to find the closest roads or perhaps use [the `ST_Intersects` predicate](https://docs.wherobots.services/1.2.0/references/sedonadb/vector-data/Predicate/#st_intersects) if we just want to find the roads that go through the tree stands we annotated.

```py
routes1_df = sedona.sql("""
SELECT idaho.geometry, name, forest, seasonal, symbol
FROM idaho, trees
WHERE ST_Intersects(trees.geometry, idaho.geometry)
""")

routes1_df.show()
```

```md
+--------------------+----------------+--------------------+--------+------+
| geometry           | name           | forest             |seasonal|symbol|
+--------------------+----------------+--------------------+--------+------+
|LINESTRING (-116....| PALOUSE DIVIDE |Idaho Panhandle N...|yearlong|     1|
|LINESTRING (-116....| CLARKIA MARBLE |Idaho Panhandle N...|yearlong|     1|
|LINESTRING (-116....|BONNEVILLE POWER|Idaho Panhandle N...|yearlong|     1|
|LINESTRING (-116....| SWAN PEAK      |Idaho Panhandle N...|yearlong|     1|
|LINESTRING (-116....| CORNWALL CREEK |Idaho Panhandle N...|yearlong|     1|
|LINESTRING (-116....| LACEY CREEK    |Idaho Panhandle N...|yearlong|     1|
|LINESTRING (-116....| CRANBERRY      |Idaho Panhandle N...|yearlong|     1|
+--------------------+----------------+--------------------+--------+------+
```

```py
map = SedonaKepler.create_map(routes1_df, name="routes")
SedonaKepler.add_df(map, tree_df, name="Tree Stands")
```

<Image
  src={'/static/images/finding-tree/kepler_route1.png'}
  alt={'LinkedIn Post'}
  width={2000}
  height={816}
/>

As we can see above most of our tree stands have Forest Service roads leading right though them. We want to expand our route a bit though - we want to know what roads we need to take to turn onto the roads that intersect our tree stands. To do this we can use a SQL subquery to find roads that either intersect or touch the roads that intersect our tree stands.

```py
routes_df = sedona.sql("""
SELECT DISTINCT idaho.geometry, idaho.name, idaho.forest, idaho.seasonal
FROM (
    SELECT idaho.geometry, name, forest, seasonal, symbol
    FROM idaho, trees
    WHERE ST_Intersects(trees.geometry, idaho.geometry)) AS routes, idaho
WHERE ST_Touches(idaho.geometry, routes.geometry)
""")
routes_df.show()
```

```md
+--------------------+------------------+--------------------+--------+
| geometry           | name             | forest             |seasonal|
+--------------------+------------------+--------------------+--------+
|LINESTRING (-116....| CLARKIA MARBLE   |Idaho Panhandle N...|yearlong|
|LINESTRING (-116....| CHARLIE CREEK    |Idaho Panhandle N...|yearlong|
|LINESTRING (-116....| CRANBERRY        |Idaho Panhandle N...|yearlong|
|LINESTRING (-116....| CAMP 3           |Idaho Panhandle N...|yearlong|
|LINESTRING (-116....| PALOUSE DIVIDE   |Idaho Panhandle N...|yearlong|
|LINESTRING (-116....| 3332 E           |Idaho Panhandle N...|yearlong|
|LINESTRING (-116....| HOMESTEAD CREEK  |Idaho Panhandle N...|yearlong|
|LINESTRING (-116....| PALOUSE DIVIDE   |Idaho Panhandle N...|seasonal|
|LINESTRING (-116....| EAGLE CREEK      |Idaho Panhandle N...|yearlong|
|LINESTRING (-116....| BONNEVILLE POWER |Idaho Panhandle N...|yearlong|
|LINESTRING (-116....|CHARLIE CONNECTION|Idaho Panhandle N...|yearlong|
|LINESTRING (-116....| CRANE            |Idaho Panhandle N...|yearlong|
|LINESTRING (-116....| 3332 F           |Idaho Panhandle N...|yearlong|
|LINESTRING (-116....| HOODOO           |Idaho Panhandle N...|yearlong|
|LINESTRING (-116....| LACEY CREEK      |Idaho Panhandle N...|yearlong|
|LINESTRING (-116....| CLARKIA MARBLE   |Idaho Panhandle N...|yearlong|
|LINESTRING (-116....| CORNWALL CREEK   |Idaho Panhandle N...|yearlong|
+--------------------+------------------+--------------------+--------+
```

<Image
    src={'/static/images/finding-tree/kepler_routes.png'}
    alt={'Visualizing routes with SedonaKepler'}
    width={2002}
    height={812}
  />

That gives us a better indication of how to navigate to our tree stands! Next, we'll export our route data to GeoJSON to load back into QGIS to combine with other data from our MVUM dataset to create a navigation map so we can find our Christmas trees!

```py
routes_gdf = geopandas.GeoDataFrame(routes_df.toPandas(), geometry="geometry")
routes_gdf.to_file('routes.geojson', driver='GeoJSON')
````

And here's the final map:

<Image
  src={'/static/images/finding-tree/07-navigation-final.png'}
  alt={'Christmas Tree Hunting Near Santa, Idaho'}
  width={3300}
  height={2550}
/>

## Resources

- [Code on GitHub](https://github.com/johnymontana/30-day-map-challenge/blob/main/notebooks/07-navigation.ipynb)
- [Wherobots Cloud](https://wherobots.com/wherobots-cloud/)


Using aerial imagery and Spatial SQL to explore Forest Service road networks

Finding The Perfect Christmas Tree With USFS Motor Vehicle User Map Data, QGIS, & SedonaDB

My take on the exciting world of spatial database technology plus a look at getting started with Apache Sedona.

Why I Joined Wherobots Plus A Look At Apache Sedona


import Image from 'next/image';
import Subscribe from '../../components/Subscribe';

## Plus Writing Spatial SQL Queries With AWS Athena

In this post we take a look at the recently released public map dataset from the Overture Maps Foundation. We'll see how to select a subset of the data using AWS Athena, how to import the map data into a Neo4j graph database using Neo4j Aura's no-code visual import and data modeling tooling, and finally we'll see how to leverage other no & low-code tooling to create a dashboard using the Neodash graph app and GraphQL API using the Neo4j GraphQL Toolbox.

<Subscribe />

## Overture Maps Foundation Releases Public Dataset

The [Overture Maps Foundation](https://overturemaps.org/) is a collaboration among Meta, Microsoft, TomTom, Amazon, and others with the goal of building a public dataset of map data. It's a Linux Foundation project, similar in structure to the GraphQL Foundation which is a group I'm more familiar with having previously served as Neo4j's representative to the GraphQL Foundation for a few years. 

Overture's goal in their own words is:

> Powering current and next-generation map products by creating reliable, easy-to-use, and interoperable open map data.

<div style={{ margin: 'auto', maxWidth: '500px' }}>
  <Image
    src={'/static/images/overture-graph/overture1.png'}
    alt={'The Overture Maps Foundation'}
    width={518}
    height={428}
  />
</div>

Overture released the first alpha version of their public dataset on July 26th, 2023 so I thought this would be a good time to take a look at the structure of the data in the public dataset as well as see how we can import and analyze the data using Neo4j.

The Overture data consists of four "themes": _places_, _transport_, _admins_, and _buildings_ and is published as Parquet files available via AWS or Azure. Previously I've used Python's pandas library and the Neo4j Python Driver to parse Parquet files into Python dataframes and then import into Neo4j using Cypher (you can see an example of that approach [here where I import the Daylight Earth Table OpenStreetMap distribution into Neo4j](https://github.com/johnymontana/daylight-earth-graph/blob/main/POI_import.ipynb) from Parquet files) but for this project I wanted to stay as code-free as possible and instead use AWS Athena's serverless SQL engine to parse and query the Overture Parquet files then use Neo4j's visual data import tool. This did require that I write a bit of SQL.

You can find more detailed information about each theme in the Overture Maps documentation [here.](https://docs.overturemaps.org/)

## Querying Overture Maps Data With AWS Athena

AWS Athena is a serverless SQL engine that will allow us to execute SQL queries on the Parquet files distributed by Overture.

First, in AWS Athena we need to create a table. I'll start with creating the `places` table, which maps to the Overture places Parquet theme. To create the table in Athena I'll need to specify the schema used for the places theme.

```sql
CREATE EXTERNAL TABLE `places`(
  `id` string,
  `updateTime` string,
  `version` int,
  `names` map<string,array<map<string,string>>>,
  `categories` struct<main:string,alternate:array<string>>,
  `confidence` double,
  `websites` array<string>,
  `socials` array<string>,
  `emails` array<string>,
  `phones` array<string>,
  `brand` struct<names:map<string,array<map<string,string>>>,wikidata:string>,
  `addresses` array<map<string,string>>,
  `sources` array<map<string,string>>,
  `bbox` struct<minX:double,maxX:double,minY:double,maxY:double>,
  `geometry` binary)
PARTITIONED BY (
  `type` varchar(5))
STORED AS PARQUET
LOCATION
  's3://overturemaps-us-west-2/release/2023-07-26-alpha.0/theme=places'
```

And then to trigger building the table.

```sql
MSCK REPAIR TABLE `places`
```

Now that we've created the `places` table, let's write a SQL query to fetch a subset of the Overture places data based on some bouding box. We'll download the results as a CSV file and then use the no-code Neo4j Import tool to create our graph in Neo4j Aura by mapping fields of the CSV file to the property graph model we wish to create using a visual diagramming interface. It's really quite slick!

Let's subset the data based on the bounds of Clark County, Nevada in the US (home of Las Vegas). We can do that using a `bbox` predicate that specifies the lower-left and upper-right coordinates of our bounding box. Some of the attributes in the `places` table are json data so we'll also parse those fields as json and extract the relevant scalar values such as the name, category, and address components using `json_extract` and `json_array_get` SQL functions.

For the places theme each row will contain a point geometry, stored efficiently in the binary WKB (Well Known Binary) format. We'll use the `ST_GeomFromBinary` spatial SQL function to convert that geometry field to WKT (Well Known Text) format and then the `ST_X` and `ST_Y` functions to retrieve the point's longitude and latitude.

```sql
SELECT
    id, updatetime, version, confidence, websites, socials, emails, phones, type,
    ST_X(ST_GeomFromBinary(geometry)) as longitude,
    ST_Y(ST_GeomFromBinary(geometry)) as latitude,
    json_extract_scalar(cast(categories as json), '$.main') as category,
    json_extract(cast(categories as json), '$.alternate') as alt_categories,
    json_extract_scalar(cast(names as json), '$.common[0].value') as name,
    json_extract(json_array_get(cast(sources as json), 0), '$.dataset') as source_dataset,
    json_extract(json_array_get(cast(sources as json), 0), '$.recordid') as source_recordid,
    json_extract(json_array_get(cast(addresses as json), 0), '$.freeform') as street_address,
    json_extract(json_array_get(cast(addresses as json), 0), '$.locality') as locality,
    json_extract(json_array_get(cast(addresses as json), 0), '$.postcode') as postcode,
    json_extract(json_array_get(cast(addresses as json), 0), '$.region') as region,
    json_extract(json_array_get(cast(addresses as json), 0), '$.country') as country
FROM
    places
WHERE
        bbox.minX >  -115.896925
    AND bbox.maxX <  -114.042819
    AND bbox.minY >  35.001857
    AND bbox.maxY <  36.853662
```

<Image
  src={'/static/images/overture-graph/athena3.png'}
  alt={'Querying the Overture Maps places theme with Amazon Athena'}
  width={2954}
  height={1856}
/>

In the AWS Athena console we can select "Download data" to download a CSV file of the results. The file is 26Mb and has about 75k rows.

| "id"                                   | "updatetime"              | "version" | "confidence"          | "websites"                                 | "socials"                                    | "emails" | "phones"         | "type"  | "longitude"    | "latitude"   | "category"       | "alt_categories"                         | "name"                          | "source_dataset" | "source_recordid"      | "street_address"                | "locality"         | "postcode"       | "region" | "country" |
| -------------------------------------- | ------------------------- | --------- | --------------------- | ------------------------------------------ | -------------------------------------------- | -------- | ---------------- | ------- | -------------- | ------------ | ---------------- | ---------------------------------------- | ------------------------------- | ---------------- | ---------------------- | ------------------------------- | ------------------ | ---------------- | -------- | --------- |
| "tmp_9A5E9AA9E18DB0FD734E236DBEEB73B5" | "2023-07-24T00:00:00.000" | "0"       | "0.5052741765975952"  |                                            | "[https://www.facebook.com/140308446009738]" |          |                  | "place" | "-114.3012956" | "35.5715668" | "restaurant"     | "[""landmark_and_historical_building""]" | "Lake Mohave Ranchos Airport"   | """meta"""       | """140308446009738"""  |                                 |                    |                  |          |
| "tmp_7BCFD4C7C12B83CD5355AE15F5A3F262" | "2023-07-24T00:00:00.000" | "0"       | "0.6"                 |                                            |                                              |          |                  | "place" | "-115.0231676" | "36.0496907" |                  | "null"                                   | "Local Vape"                    | """msft"""       | """1970324838862842""" | """7685 Commercial Way Ste I""" | """Henderson"""    | """89011"""      | """NV""" | """US"""  |
| "tmp_FF0104AF0B2048DCD02320B4A096A398" | "2023-07-24T00:00:00.000" | "0"       | "0.26928654313087463" | "[http://ombremonai.com]"                  | "[https://www.facebook.com/108034485157293]" |          | "[+17029101015]" | "place" | "-115.28665"   | "36.15881"   | "beauty_and_spa" | "null"                                   | "Ombré Monai"                   | """meta"""       | """108034485157293"""  | """8751 W Charleston Blvd"""    | """Las Vegas"""    | """89117-5453""" | """NV""" | """US"""  |
| "tmp_D57D0159A70E965E96572CF6D596F1C1" | "2023-07-24T00:00:00.000" | "0"       | "0.8260171413421631"  | "[https://nevadasouthernlivesteamers.com]" | "[https://www.facebook.com/475380855987545]" |          | "[+17023757089]" | "place" | "-114.8539342" | "35.9706829" | "museum"         | "[""history_museum"",""train_station""]" | "Nevada Southern Live Steamers" | """meta"""       | """475380855987545"""  | """601 Yucca St"""              | """Boulder City""" | """89005"""      | """NV""" | """US"""  |

With our CSV file of points of interest downloaded, let's head over to [Neo4j Aura](https://dev.neo4j.com/neo4j-aura) and spin up a free Neo4j instance in the cloud to analyze our place data. After signing in and creating a free tier Neo4j Aura instance we'll use the "Import" tab to create a property graph data model mapped to the places data in our CSV file.

<div style={{ margin: 'auto', maxWidth: '750px' }}>
  <Image
    src={'/static/images/overture-graph/workspace1.png'}
    alt={"Using Neo4j Aura's Workspace developer tooling"}
    width={1386}
    height={606}
  />
</div>

## Data Import Tool

Neo4j Workspace's Import tool is designed around the idea of sketching your property graph data model in an interactive modern diagramming UI and mapping pieces of the data model diagram to fields in your CSV files.

I had worked on [a similar web-based visual graph data import tool prototype](https://github.com/neo4j-contrib/neo4j-csv-import-web) when I first joined Neo4j 8 years ago so it's great to see this functionality available directly in Neo4j Aura.

We can start either by beginning to sketch our property graph data model as we would on a whiteboard, or by selecting the CSV file we want to import. We'll start by selecting the CSV file we downloaded from AWS Athena in the previous step.

<Image
  src={'/static/images/overture-graph/workspace2.png'}
  alt={
    'Using the Neo4j Import Tool to load Overture Maps point of interest data into the Neo4j graph database.'
  }
  width={2524}
  height={1178}
/>

No data is sent to the server, but Import has parsed our CSV file and shows a preview of the values from the first row that we can use to reference when sketching our whiteboard graph model.

<Image
  src={'/static/images/overture-graph/workspace3.png'}
  alt={
    'Sketching a property graph data model using Neo4j Workspace Import tool'
  }
  width={2516}
  height={1176}
/>

If we select the "Add node label" button we can add our first node to the diagram. Let's use this first node label to represent the places of interest themselves so we'll call this node label `PointOfInterest`.

<Image
  src={'/static/images/overture-graph/workspace4.png'}
  slt={
    'Sketching a property graph data model using Neo4j Workspace Import tool'
  }
  width={2516}
  height={1178}
/>

Next, we'll want to specify the properties to include on our `PointOfInterest` nodes from the CSV file. Some of the fields from our CSV file will be extracted out into nodes and relationships of their own (like category, source, and location information) so we don't want to include _all_ fields from the CSV.

We also choose the type of each field and importantly also specify which field defines uniqueness for the node. In other words, which field is the "id" value. In the relational database world this is similar to the concept of "primary key". We need to specify this property to be able to define relationships in our graph.

<Image
  src={'/static/images/overture-graph/workspace5.png'}
  alt={
    'Sketching a property graph data model using Neo4j Workspace Import tool'
  }
  width={2520}
  height={1168}
/>

Adding relationships to the data model is as simple as dragging out from the halo around a node.

<Image
  src={'/static/images/overture-graph/workspace6.png'}
  alt={
    'Sketching a property graph data model using Neo4j Workspace Import tool'
  }
  width={2510}
  height={1170}
/>

In the labeled property graph model used by Neo4j every relationship has both a direction and single "type" that describes the relationship between the two node labels that it connects. We can add the relationship type by clicking on the dashed relationship line.

Since this relationship connects the `PointOfInterest` and `Category` node labels let's define the relationship type as `IN_CATEGORY`. By convention [PascalCase](https://en.wiktionary.org/wiki/Pascal_case) is used when defining node lables and ALL_CAPS_SNAKE_CASE is used for relationship types. You can find more Cypher style guidelines [here](https://neo4j.com/developer/cypher/style-guide/).

<Image
  src={'/static/images/overture-graph/workspace7.png'}
  alt={
    'Sketching a property graph data model using Neo4j Workspace Import tool'
  }
  width={2514}
  height={1178}
/>

To enable the Neo4j Import tool to properly connect nodes we need to specify which fields hold the id values for the "from" and "to" nodes. In this case we have an `id` property for the `PointOfInterest` node which specifies the "from" node and the `category` property value specifies the "to" node.

Notice the green checkmarks that appear as we start to fill out more pieces of the property graph model indicating that we have specified the necessary field mappings.

<Image
  src={'/static/images/overture-graph/workspace8.png'}
  alt={
    'Sketching a property graph data model using Neo4j Workspace Import tool'
  }
  width={2512}
  height={1174}
/>

Next, we continue building up our property graph model, mapping the entities to node labels and the fields that describe them to properties in the graph data model.

<Image
  src={'/static/images/overture-graph/import2.png'}
  alt={
    'Using the Neo4j Import Tool to load Overture Maps point of interest data into the Neo4j graph database.'
  }
  width={3140}
  height={1950}
/>

Here's the final graph model that I ended up with for the Overture dataset.

<Image
  src={'/static/images/overture-graph/import4.png'}
  alt={
    'Using the Neo4j Import Tool to load Overture Maps point of interest data into the Neo4j graph database.'
  }
  width={3122}
  height={1670}
/>

Once we've fully defined our graph data model and mapped to the associated fields of our CSV file we're ready to run the import into our Neo4j Aura instance.

To start the import process we'll click the "Run import" button. Behind the scenes the Neo4j Import tool will generate Cypher queries to create property constraints and then iterate over the data in our CSV file in batches to load data into our Neo4j Aura instance.

<Image
  src={'/static/images/overture-graph/import5.png'}
  alt={
    'Using the Neo4j Import Tool to load Overture Maps point of interest data into the Neo4j graph database.'
  }
  width={1836}
  height={1816}
/>

## What Now?

Now that we've loaded our geospatial data into Neo4j what can we do with it?

We can use the power of Cypher to query for points of interest near us, within certain categories for example. Or more complex queries for location-aware recommendations. For example, let's find all the wineries near me:


```cypher
MATCH (p:PointOfInterest)-[:IN_CATEGORY]->(c:Category {name: "Winery"})
WHERE point.distance(p.location, {latitude: 37.594, longitude: -122.364}) < 100
RETURN p
```

But keeping with our theme of leveraging Neo4j's low-code tools what else do we have at our disposal? I've previously covered Neo4j Bloom which is a great tool for exploring graphs visually, so let's skip Bloom for now and take a look at two of Neo4j's other low-code tools: Neodash and the Neo4j GraphQL Toolbox.

__Building Graph Dashboards With Neodash__

One of the easiest ways to work with data in Neo4j without writing code is to use [NeoDash](https://neodash.graphapp.io/) - a tool from the Neo4j Labs team for building standalone dashboards backed by Neo4j. 

Neodash has support for creating maps and integrating spatial data into dashboards. Here we've just set up a very basic map view so we can explore the Overture data visually.

<Image
  src={'/static/images/overture-graph/neodash1.png'}
  alt={'Creating a dashboard with the Neodash graph app for Neo4j.'}
  width={1174}
  height={553}
/>

__Put The Graph In GraphQL With The Neo4j GraphQL Toolbox__

<Image
  src={'/static/images/overture-graph/graphql1.png'}
  alt={'Neo4j GraphQL Toolbox'}
  width={2421}
  height={1515}
/>

Another low-code tool from Neo4j is the [Neo4j GraphQL Toolbox](https://graphql-toolbox.neo4j.io/) which allows you to create a GraphQL API backed by Neo4j without writing any code. We can just point the Toolbox at our Neo4j Aura instance and generate a fully functional GraphQL API.


This post is just a starting point for working with the Overture maps dataset in Neo4j. It's exciting to see what Overture is doing and I'll definitely be making use of their dataset for future projects. 

## Resources

- [Accessing Overture Maps' Global Dataset using Athena (AWS)](https://feyeandal.me/blog/access_overture_data_using_athena)
- [Athena setup SQL for Overture (all themes)](https://github.com/OvertureMaps/data/blob/main/athena_setup_queries.sql#L77)
- [Extracting data from JSON (AWS Athena Docs)](https://docs.aws.amazon.com/athena/latest/ug/extracting-data-from-JSON.html)
- [Geospatial SQL functions available in Trino](https://trino.io/docs/current/functions/geospatial.html)
- [Bounding Boxes for all US Counties](https://trino.io/docs/current/functions/geospatial.html)
- [Spatial Cypher cheat sheet]()


A look at loading points of interest from the Overture Maps public dataset into the Neo4j graph database, plus writing Spatial SQL queries with AWS Athena.

Importing Overture Maps Data Into Neo4j

A resource for working with geospatial data in Neo4j.

Introducing The Spatial Cypher Cheat Sheet


import Image from 'next/image';
import Subscribe from '../../components/Subscribe';
import YouTube from '../../components/YouTube';

In this post we explore some techniques for working with geospatial data in Neo4j. We will cover some basic spatial Cypher functions, spatial search, routing algorithms, and different methods of importing geospatial data into Neo4j. Be sure to sign up for my newsletter to be notified of new blog posts like these:

<Subscribe />

This post is based on my talk at [NODES 2022](https://dev.neo4j.com/nodes-videos), so you can watch the video recording instead:

<YouTube youTubeId="-fs8ozxKklQ" />

## Spatial Cypher Functions And The `Point` Type

Native geospatial functionality in Neo4j is based on support for a native `Point` type. The `Point` data type can be used to represent point data using either 3D or 2D geographic (WGS84) or cartesian coordinates reference systems (CRS). Points (or arrays of points) can be stored as properties on nodes or relationships in Neo4j. Cypher contains [several functions for working with points](https://neo4j.com/docs/cypher-manual/current/syntax/spatial/), notably:

- `point()` - for creating `Point` instances
- `point.distance()` - calculates distance between two points. Can also be used for radius distance search when used in a `WHERE` predicate
- `point.withinBBox()` - to find points within a given bounding box

Point instances can be created using the `point()` function in Cypher and passing an object that specifies latitude, longitude, and optionally height (when using geographic CRS) or x, y and optionally z (when using cartesian CRS). In this article we will focus on the 2D geographic CRS (using latitude an longitude).

Here we create a point instance by specifying latitude and longitude:

```Cypher
RETURN point(
  {latitude:49.38713, longitude:12.12711}
)
```

```md
╒════════════════════════════════════════════════╕
│"point({latitude:49.38713, longitude:12.12711})"│
╞════════════════════════════════════════════════╡
│point({srid:4326, x:12.12711, y:49.38713})      │
└────────────────────────────────────────────────┘
```

To set a point property value we can use the `SET` Cypher command. Here we create a new `PointOfInterest` node representing a bakery and set the `location` property to a point value:

```Cypher
CREATE (p:PointOfInterest)
SET p.name = "West Side Bakery",
p.location = point(
  {latitude:49.38713, longitude:12.12711}
)
RETURN p
```

<div style={{  margin: 'auto' }}>
  <Image
  src={'/static/images/nodes2022/node.png'}
  alt={'Creating a node with a location point property'}
  height={277}
  width={551}
/>


</div>


We can use the `point.distance()` function to search for our bakery. Here we search for nodes with the `PointOfInterest` label that are within 200 meters of a given latitude and longitude:

```Cypher
MATCH (p:PointOfInterest)
WHERE point.distance(
  p.location, point({latitude:49.38713, longitude:12.12711})
) < 200
RETURN p
```

Let's look at some real-world data to see how we can implement spatial search functionality in a simple web map application.

## Spatial Search With Neo4j

A common feature for web applications that deal with geospatial data involves spatial search: finding things near other things or within the bounds of a box or perhaps within a polygon. Let's see how we can use Neo4j to search for points of interest on a map using Leaflet.js for the following types of spatial search:

1. Radius distance search
2. Within Bounding Box
3. Within Polygon

<Image
  src={'/static/images/nodes2022/spatial_search.png'}
  alt={
    'Spatial search with Neo4j - radius distance, bounding box, and point in polygon'
  }
  width={1102}
  height={950}
/>

Code [on GitHub: johnymontana/geospatial-graph-demos.](https://github.com/johnymontana/geospatial-graph-demos)

I wanted to use a real world dataset, so I pulled in points of interest from the [Daylight Earth Table](https://daylightmap.org/earth/) distribution of OpenStreetMap. The Daylight Earth Table is based on the Daylight OpenStreetMap distribution, but adds a data schema that classifies OpenStreetMap tags into a three level ontology: theme, class, and subclass. We'll be using the "poi" theme.

<Image
  src={'/static/images/nodes2022/daylight.png'}
  alt={'The Daylight Earth Table OpenStreetMap distribution'}
  width={1395}
  height={843}
/>

Currently there are almost 39 million points of interest in the dataset. The Daylight Earth Table is available in Parquet files stored in S3 so I used the `pandas` Python library to read the Parquet files from S3 into a DataFrame. By converting the DataFrame to Python dicts and passing in batches as Cypher parameters we can import the dataset in a few minutes.

```Python
# Here we define a function to split our DataFrame into batches for import

def insert_data(query, rows, batch_size=10000):
    total = 0
    batch = 0
    start = time.time()
    result = None

    while batch * batch_size < len(rows):
        res = conn.query(query, parameters = {'rows': rows[batch*batch_size:(batch+1)*batch_size].to_dict('records')}, db="osmpois")
        total += res[0]['total']
        batch += 1
        result = {"total": total, "batches": batch, "time": time.time()-start}
        print(result)
    return result
```

```Cypher
def insert_pois(rows, batch_size=10000):
    print(rows)
    query = '''
    UNWIND $rows AS row
    CREATE (p:PointOfInterest {name: row.names.local})
    CREATE (g:Geometry)
    SET g.location = point({latitude: toFloat(row.point[1]), longitude: toFloat(row.point[0]) })
    CREATE (g)<-[:HAS_GEOMETRY]-(p)
    SET g:Point
    CREATE (t:Tags)
    SET t += row.original_tags_dict
    CREATE (p)-[:HAS_TAGS]->(t)
    WITH *
    CALL apoc.create.addLabels(p, [row.class, row.subclass]) YIELD node
    RETURN COUNT(*) AS total
    '''
    return insert_data(query, rows, batch_size)
```

<Image
  src={'/static/images/nodes2022/daylight_notebook.png'}
  alt={
    'Importing the Daylight Earth Table OpenStreetMap distribution into Neo4j'
  }
  width={1126}
  height={757}
/>

See the code on GitHub: [johnymontana/daylight-earth-graph](https://github.com/johnymontana/daylight-earth-graph)

### Radius Distance Search

Now that we have all points of interest loaded into Neo4j we'll create a point index to enable fast index-backed spatial search operations.

```Cypher
CREATE POINT INDEX poiIndex
FOR (p:Point) ON (p.location)
```

Our first spatial search type is radius distance search: finding all points of interest within a given distance of a point.

<div style={{  margin: 'auto' }}>
<Image
  src={'/static/images/nodes2022/radius_search.png'}
  alt={'Radius distance search with Neo4j'}
  height={323}
  width={520}
/>
</div>

Here we search for all points of interest within 200 meters of a point in Northern California.

```Cypher
PROFILE MATCH (p:Point)
WHERE
point.distance(p.location, point({latitude: 37.563434, longitude:-122.322255})) < 200
RETURN p{.*} AS point
```

By prepending `PROFILE` to our Cypher query we will render the database query plan as well as basic performance metrics for the query, such as memory usage, execution time, number of rows at each operation, and db hits. We can see that our point index is used resulting in an execution time of 1-2ms. Compare to the execution plan on the left which does not use an index and rather must scan every point of interest and takes about 4 seconds to execute. When we're dealing with millions of nodes it behooves us to make sure our spatial search operations are using an index for best performance.

<div style={{  margin: 'auto' }}>
<Image
  src={'/static/images/nodes2022/radius_index_plan.png'}
  alt={'Radius distance search query plan with and without index'}
  height={712}
  width={571}
/>
</div>

### Cypher Bounding Box Search

The next type of spatial search to consider is searching within a rectangular bounding box.

<div style={{  margin: 'auto' }}>
<Image
  src={'/static/images/nodes2022/bounding_box.png'}
  alt={'Bounding box search'}
  height={341}
  width={477}
/>
</div>

We will use the [`point.withinBBox`](https://neo4j.com/docs/cypher-manual/current/functions/spatial/#functions-withinBBox) Cypher predicate function to accomplish this. This function takes 3 arguments: a point value that defines a location and two other point values that define the bounding box's lower left and upper right points.

```Cypher
MATCH (p:Point)
WHERE point.withinBBox(
  p.location,
  point({longitude:-122.325447, latitude: 37.55948 }),  // Lower left point
  point({longitude:-122.314675 , latitude: 37.563596})) // Upper right point
RETURN p
```

We can prepend `PROFILE` to the above Cypher query to verify that we are indeed using the index for this spatial search operation.

<div style={{  margin: 'auto' }}>
<Image
  src={'/static/images/nodes2022/index2.png'}
  alt={'Query plan - using index for bounding box search'}
  height={686}
  width={362}
/>
</div>

### Point In Polygon Search

Point in polygon search will return points within the bounds of an arbitrary polygon. Point in polygon search is not natively supported in Neo4j, however with some help on the client side of our application we can accomplish a polygon search while taking advantage of the point database index to ensure the search is fast. To accomplish this we will use the following steps:

1. Convert polygon to bounding box
2. Cypher `withinBBox` query
3. Filter results to those within polygon

<div style={{  margin: 'auto' }}>
<Image
  src={'/static/images/nodes2022/point_in_polygon_search.png'}
  alt={'Node chart visualization example'}
  height={478}
  width={551}
/>
</div>

Index backed point in polygon search can be accomplished by first converting the polygon to a bounding box, using Cypher's `point.withinBBox` predicate function to find points within the bounding box (using our database index), and then filtering the results on the client to the polygon bounds. [Example code here](https://github.com/johnymontana/geospatial-graph-demos/blob/main/src/index.html#L175-L231), using [Turf.js](https://turfjs.org/):

```js
const polygon = layer.toGeoJSON();
var bbox = turf.bbox(polygon); // convert polygon to bounding box

// Within Bounding Box Cypher query
const cypher = `
    MATCH (p:Point)-[:HAS_GEOMETRY]-(poi:PointOfInterest)-[:HAS_TAGS]->(t:Tags)
    WHERE point.withinBBox(
        p.location,
        point({longitude: $lowerLeftLon, latitude: $lowerLeftLat }),
        point({longitude: $upperRightLon, latitude: $upperRightLat}))
    RETURN p { latitude: p.location.latitude,
               longitude: p.location.longitude,
               name: poi.name,
               categories: labels(poi),
               tags: t{.*}
            } AS point
          `;

var session = driver.session({
    database: "osmpois",
    defaultAccessMode: neo4j.session.READ,
});

session
    .run(cypher, {
        lowerLeftLat: bbox[1],
        lowerLeftLon: bbox[0],
        upperRightLat: bbox[3],
        upperRightLon: bbox[2],
    })
    .then((result) => {
        const bboxpois = [];
        result.records.forEach((record) => {
            const poi = record.get("point");
            var point = [poi.longitude, poi.latitude];
            bboxpois.push(point);
        });
        // filter results of bouding box query to polygon bounds
        const poisWithin = turf.pointsWithinPolygon(
            turf.points(bboxpois),
            polygon
        );

        poisWithin.features.forEach((e) => {
            L.marker([
                e.geometry.coordinates[1],
                e.geometry.coordinates[0],
            ])
            .addTo(map)
            .bindPopup("Polygon");
        })
```


You can find the code for the spatial search examples (including using the Leaflet.js web map with Neo4j) [on GitHub: johnymontana/geospatial-graph-demos](https://github.com/johnymontana/geospatial-graph-demos)

### Working With Line Geometries

So far we've been working with points, let's take a quick look at an example using line geometries. For this quick example I exported my Strava activities data and loaded into Neo4j.

<div style={{  margin: 'auto' }}>
<Image
  src={'/static/images/nodes2022/bloom2.png'}
  alt={'Node chart visualization example'}
  height={693}
  width={800}
/>
</div>

To import data, first export user data from Strava then to add activities we will use the exported `activities.csv` file and load individual activity routes from the GPX files (first converted to geojson):

```Cypher
// Create Activity Nodes
LOAD CSV WITH HEADERS FROM "file:///activities.csv" AS row
MERGE (a:Activity {activity_id: row.`Activity ID`})
SET a.filename = row.Filename,
    a.activity_type = row.`Activity Type`,
    a.distance = toFloat(row.Distance),
    a.activity_name = row.`Activity Name`,
    a.activity_data = row.`Activity Date`,
    a.activity_description = row.`Activity Description`,
    a.max_grade = toFloat(row.`Max Grade`),
    a.elevation_high = toFloat(row.`Elevation High`),
    a.elevation_loss = toFloat(row.`Elevation Loss`),
    a.elevation_gain = toFloat(row.`Elevation Gain`),
    a.elevation_low = toFloat(row.`Elevation Low`),
    a.moving_time = toFloat(row.`Moving Time`),
    a.max_speed = toFloat(row.`Max Speed`),
    a.avg_grade = toFloat(row.`Average Grade`);

// Parse geojson geometries and create Geometry:Line nodes
MATCH (a:Activity)
WITH a WHERE a.filename IS NOT NULL AND a.filename CONTAINS ".gpx"
MERGE (n:Geometry {geom_id:a.activity_id })
MERGE (n)<-[:HAS_FEATURE]-(a)
WITH n,a
CALL apoc.load.json('file:///' + replace(a.filename, '.gpx', '.geojson')) YIELD value
UNWIND value.features[0].geometry.coordinates AS coord
WITH n, collect(point({latitude: coord[1], longitude: coord[0]})) AS coords
SET n.coordinates = coords
SET n:Line;
```

We store the routes as an array of point values to represent the line geometry of each route. Now, we can use the same spatial search techniques described above with our line geometries.

<Image
  src={'/static/images/nodes2022/line_search.png'}
  alt={'Airport graph model'}
  height={933}
  width={1102}
/>

By using the list predicate `any` Cypher function in our query we can check if at least one point in the line are within the radius distance search distance.

```Cypher
WITH point({latitude: $latitude, longitude: $longitude}) AS radiusCenter
MATCH (g:Geometry)<-[:HAS_FEATURE]-(a:Activity)
WHERE any(
  p IN g.coordinates WHERE point.distance(p, radiusCenter) < $radius
)
RETURN *
```

Code for this example is available [on GitHub here](https://github.com/johnymontana/geospatial-graph-demos#line-geometry-search).

## Routing With Graph Algorithms

One more use case I'd like to touch on besides spatial search is that of routing. We'll use the [Graph Data Science Neo4j Sandbox](https://dev.neo4j.com/sandbox) to find airline routes between airports. 

<Image
  src={'/static/images/nodes2022/routing1.png'}
  alt={'Airport graph model'}
  height={696}
  width={1301}
/>

There are a number of relevant path finding algorithms we might consider. In this case we will use Dijkstra's algorithm, an extension of breadth first search that uses relationship weights to find the shortest path between two nodes, or airports in our case. Dijkstra's algorithm is one of many available in Neo4j's Graph Data Science library. First, we will project our airline route graph into an in-memory projected graph structure used by the Graph Data Science library:

```Cypher
CALL gds.graph.project(
  'routes-weighted',
  'Airport',
  'HAS_ROUTE',
  {
    relationshipProperties: 'distance'
  }
) YIELD graphName, nodeProjection, nodeCount,
  relationshipProjection, relationshipCount
```

Then, to search for the shortest path between two airports we use the [`gds.shortestPath.dijkstra` procedure](https://neo4j.com/docs/graph-data-science/current/algorithms/dijkstra-source-target/):

```Cypher
MATCH (source:Airport {iata: 'PUQ'}), (target:Airport {iata: 'HNL'})
CALL gds.shortestPath.dijkstra.stream('routes-weighted', {
  sourceNode: source,
  targetNode: target,
  relationshipWeightProperty: 'distance'
})
YIELD index, sourceNode, targetNode,
   totalCost, nodeIds, costs, path
RETURN
nodes(path) as path
```

<Image
  src={'/static/images/nodes2022/routing2.png'}
  alt={'Routing between airports using the Dijkstra algorithm'}
  height={1202}
  width={1600}
/>


In this post we introduced some of the spatial functionality natively supported by Neo4j including the point type and related Cypher functions and demonstrated how to accomplish various spatial search operations as well as a brief look at routing with graph algorithms.



## Resources

- [Cypher manual for spatial Cypher functions](https://neo4j.com/docs/cypher-manual/current/syntax/spatial/)
- [Spatial search map example code](https://github.com/johnymontana/geospatial-graph-demos)
- [Daylight Earth Table](https://daylightmap.org/earth/)
- [Importing Daylight Earth Table points of interest into Neo4j (Python code)](https://github.com/johnymontana/daylight-earth-graph)
- [Spatial search Leaflet.js + Neo4j demo code](https://github.com/johnymontana/geospatial-graph-demos)

For comments and discussion please [join the conversation for this post at Dev.to](https://dev.to/lyonwj/spatial-search-functionality-with-neo4j-1c8h)


Radius Distance, Bounding Box, and Point in Polygon Search With Graphs

A Look At Graph Visualization With Sigma React

Hi, I'm Will!

Stay Updated

Latest Posts

Finding The Perfect Christmas Tree With USFS Motor Vehicle User Map Data, QGIS, & SedonaDB

Why I Joined Wherobots Plus A Look At Apache Sedona

Importing Overture Maps Data Into Neo4j

Introducing The Spatial Cypher Cheat Sheet

Spatial Search Functionality With Neo4j

Featured Videos

Featured Projects

go-fetch

Knowledge Graph Datasets

Dgraph Client App