Proper Usage of quadtree_point_to_nearest_linestring When LineString Originates From a LineString NOT Polygon

[squisha]

I'm surely overlooking something simple and obvious here, but I can't seem to get accurate measurements when I switch from Polygon to LineString source input to quadtree_point_to_nearest_linestring. The only changes made to get it to run were using part_offset as opposed to ring_offset, and using .lines instead of .polygons to create the LineStringGeoColumnAccessor.

import overturemaps
import pandas as pd
import geopandas as gpd
import cuspatial
import cudf
from shapely import wkb
import cupy

def overture_pull(overture_type, lat_bottom, lon_left, lat_top, lon_right):

    bbox = lon_left, lat_bottom, lon_right, lat_top
    table = overturemaps.record_batch_reader(overture_type, bbox).read_all()
    table = table.combine_chunks()

    df = table.to_pandas()
    geometry = df['geometry'].map(wkb.loads)
    df = df.drop('geometry', axis=1)
    feature = gpd.GeoDataFrame(df, crs="EPSG:4326", geometry=geometry)

    return feature

overture_segments = overture_pull("segment",40, -75.2, 40.25, -75)
osm_test1 = overture_segments[overture_segments['class'] == 'motorway']

data = {'latitude': [40.19, 40.11, 40.1, 40.23], 'longitude': [-75.134, -75.15, -75.11, -75.08]}
data = pd.DataFrame.from_dict(data)
## Convert it into a geodataframe
gdf = gpd.GeoDataFrame(
    data, geometry=gpd.points_from_xy(data.longitude, data.latitude), crs="EPSG:4326"
)

cline = cuspatial.from_geopandas(osm_test1)
cgdf = cuspatial.from_geopandas(gdf)

cline_lines = cline['geometry'].lines

boundaries = cuspatial.GeoSeries.from_linestrings_xy(
    cudf.DataFrame({"x": cline_lines.x, "y": cline_lines.y}).interleave_columns(),
    cline_lines.part_offset,
    cupy.arange(len(cline_lines.part_offset))
)

scale = 5
max_depth = 7
max_size = 125

point_indices, quadtree = cuspatial.quadtree_on_points(cgdf['geometry'],
                                                       cline_lines.x.min(),
                                                       cline_lines.x.max(),
                                                       cline_lines.y.min(),
                                                       cline_lines.y.max(),
                                                       scale,
                                                       max_depth,
                                                       max_size)

poly_bboxes = cuspatial.linestring_bounding_boxes(
    boundaries,
    2.0
)

intersections = cuspatial.join_quadtree_and_bounding_boxes(
    quadtree,
    poly_bboxes,
    cline_lines.x.min(),
    cline_lines.x.max(),
    cline_lines.y.min(),
    cline_lines.y.max(),
    scale,
    max_depth
)

result = cuspatial.quadtree_point_to_nearest_linestring(
    intersections,
    quadtree,
    point_indices,
    cgdf['geometry'],
    boundaries
)

print(result.head())

[isVoid]

Hi @squisha ! In your script, the input of quadtree_on_points should accept bounding boxes of the points, not the lines, so I would replace the inputs from cline_lines.x.min() to cgdf.geometry.points.x.min(), and the same for the rest of the inputs.

Additionally, boundaries series is actually the same as cline.geometry, so you can replace all of its usage without having create it.