def directed_hausdorff_distance(x, y, count):
""" Compute the directed Hausdorff distances between all pairs of
trajectories.
params
x: x coordinates
y: y coordinates
count: size of each trajectory
Parameters
----------
{params}
Example
-------
The directed Hausdorff distance from one trajectory to another is the
greatest of all the distances from a point in the first trajectory to
the closest point in the second.
[Wikipedia](https://en.wikipedia.org/wiki/Hausdorff_distance)
Consider a pair of lines on a grid.
|
o
-oxx-
|
o = [[0, 0], [0, 1]]
x = [[1, 0], [2, 0]]
o[0] is the closest point in o to x. The distance from o[0] to the farthest
point in x = 2.
x[0] is the closest point in x to o. The distance from x[0] to the farthest
point in o = 1.414.
result = cuspatial.directed_hausdorff_distance(
cudf.Series([0, 1, 0, 0]),
cudf.Series([0, 0, 1, 2]),
cudf.Series([2, 2,]),
)
print(result)
0 1
0 0.0 1.414214
1 2.0 0.000000
Returns
-------
DataFrame: The pairwise directed distance matrix with one row and one
column per input trajectory; the value at row i, column j represents the
hausdorff distance from trajectory i to trajectory j.
"""
result = cpp_directed_hausdorff_distance(x, y, count)
dim = len(count)
return DataFrame.from_gpu_matrix(
result.data.to_gpu_array().reshape(dim, dim)
)
def _check_input(self, X, is_categories=False):
"""
If input is cupy, convert it to a DataFrame with 0 copies
"""
if isinstance(X, cp.ndarray):
self._set_input_type('array')
if is_categories:
X = X.transpose()
return DataFrame.from_gpu_matrix(X)
else:
self._set_input_type('df')
return X
def directed_hausdorff_distance(xs, ys, points_per_space):
"""Compute the directed Hausdorff distances between all pairs of
spaces.
Parameters
----------
xs
column of x-coordinates
ys
column of y-coordinates
points_per_space
number of points in each space
Returns
-------
result : cudf.DataFrame
The pairwise directed distance matrix with one row and one
column per input space; the value at row i, column j represents the
hausdorff distance from space i to space j.
Examples
--------
The directed Hausdorff distance from one space to another is the greatest
of all the distances between any point in the first space to the closest
point in the second.
`Wikipedia <https://en.wikipedia.org/wiki/Hausdorff_distance>`_
Consider a pair of lines on a grid::
:
x
-----xyy---
:
:
x\\ :sub:`0` = (0, 0), x\\ :sub:`1` = (0, 1)
y\\ :sub:`0` = (1, 0), y\\ :sub:`1` = (2, 0)
x\\ :sub:`0` is the closest point in ``x`` to ``y``. The distance from
x\\ :sub:`0` to the farthest point in ``y`` is 2.
y\\ :sub:`0` is the closest point in ``y`` to ``x``. The distance from
y\\ :sub:`0` to the farthest point in ``x`` is 1.414.
Compute the directed hausdorff distances between a set of spaces
>>> result = cuspatial.directed_hausdorff_distance(
[0, 1, 0, 0], # xs
[0, 0, 1, 2], # ys
[2, 2], # points_per_space
)
>>> print(result)
0 1
0 0.0 1.414214
1 2.0 0.000000
"""
num_spaces = len(points_per_space)
if num_spaces == 0:
return DataFrame()
xs, ys = normalize_point_columns(as_column(xs), as_column(ys))
result = cpp_directed_hausdorff_distance(
xs, ys, as_column(points_per_space, dtype="int32"),
)
result = result.data_array_view
result = result.reshape(num_spaces, num_spaces)
return DataFrame.from_gpu_matrix(result)
def point_in_polygon_bitmap(
x_points,
y_points,
polygon_ids,
polygon_end_indices,
polygons_x,
polygons_y,
):
""" Compute from a set of points and a set of polygons which points fall
within which polygons. Note that `polygons_(x,y)` must be specified as
closed polygons: the first and last coordinate of each polygon must be
the same.
params
x_points: x coordinates of points to test
y_points: y coordinates of points to test
polygon_ids: a unique integer id for each polygon
polygon_end_indices: the (n+1)th vertex of the final coordinate of each
polygon in the next parameters
polygons_x: x closed coordinates of all polygon points
polygons_y: y closed coordinates of all polygon points
Parameters
----------
{params}
Examples
--------
result = cuspatial.point_in_polygon_bitmap(
cudf.Series([0, -8, 6.0]), # x coordinates of 3 query points
cudf.Series([0, -8, 6.0]), # y coordinates of 3 query points
cudf.Series([1, 2]), # unique id of two polygons
cudf.Series([5, 10]), # position of last vertex in each polygon
# polygon coordinates, x and y. Note [-10, -10] and [0, 0] repeat
# the start/end coordinate of the two polygons.
cudf.Series([-10.0, 5, 5, -10, -10, 0, 10, 10, 0, 0]),
cudf.Series([-10.0, -10, 5, 5, -10, 0, 0, 10, 10, 0]),
)
# The result of point_in_polygon_bitmap is a DataFrame of Boolean
# values indicating whether each point (rows) falls within
# each polygon (columns).
print(result)
in_polygon_1 in_polygon_2
0 True True
1 True False
2 False True
# Point 0: (0, 0) falls in both polygons
# Point 1: (-8, -8) falls in the first polygon
# Point 2: (6.0, 6.0) falls in the second polygon
returns
DataFrame: a DataFrame of Boolean values indicating whether each point
falls within each polygon.
"""
bitmap_result = cpp_point_in_polygon_bitmap(
x_points,
y_points,
polygon_ids,
polygon_end_indices,
polygons_x,
polygons_y,
)
result_binary = gis_utils.pip_bitmap_column_to_binary_array(
polygon_bitmap_column=bitmap_result, width=len(polygon_ids)
)
result_bools = DataFrame.from_gpu_matrix(
result_binary
)._apply_support_method("astype", dtype="bool")
result_bools.columns = [
f"in_polygon_{x}" for x in list(reversed(polygon_ids))
]
result_bools = result_bools[list(reversed(result_bools.columns))]
return result_bools
def point_in_polygon(
test_points_x,
test_points_y,
poly_offsets,
poly_ring_offsets,
poly_points_x,
poly_points_y,
):
""" Compute from a set of points and a set of polygons which points fall
within which polygons. Note that `polygons_(x,y)` must be specified as
closed polygons: the first and last coordinate of each polygon must be
the same.
Parameters
----------
test_points_x
x-coordinate of test points
test_points_y
y-coordinate of test points
poly_offsets
beginning index of the first ring in each polygon
poly_ring_offsets
beginning index of the first point in each ring
poly_points_x
x closed-coordinate of polygon points
poly_points_y
y closed-coordinate of polygon points
Examples
--------
Test whether 3 points fall within either of two polygons
>>> result = cuspatial.point_in_polygon(
[0, -8, 6.0], # test_points_x
[0, -8, 6.0], # test_points_y
cudf.Series([0, 1], index=['nyc', 'hudson river']), # poly_offsets
[0, 3], # ring_offsets
[-10, 5, 5, -10, 0, 10, 10, 0], # poly_points_x
[-10, -10, 5, 5, 0, 0, 10, 10], # poly_points_y
)
# The result of point_in_polygon is a DataFrame of Boolean
# values indicating whether each point (rows) falls within
# each polygon (columns).
>>> print(result)
nyc hudson river
0 True True
1 True False
2 False True
# Point 0: (0, 0) falls in both polygons
# Point 1: (-8, -8) falls in the first polygon
# Point 2: (6.0, 6.0) falls in the second polygon
note
input Series x and y will not be index aligned, but computed as
sequential arrays.
Returns
-------
result : cudf.DataFrame
A DataFrame of boolean values indicating whether each point falls
within each polygon.
"""
if len(poly_offsets) == 0:
return DataFrame()
(
test_points_x,
test_points_y,
poly_points_x,
poly_points_y,
) = normalize_point_columns(
as_column(test_points_x),
as_column(test_points_y),
as_column(poly_points_x),
as_column(poly_points_y),
)
result = cpp_point_in_polygon(
test_points_x,
test_points_y,
as_column(poly_offsets, dtype="int32"),
as_column(poly_ring_offsets, dtype="int32"),
poly_points_x,
poly_points_y,
)
result = gis_utils.pip_bitmap_column_to_binary_array(
polygon_bitmap_column=result, width=len(poly_offsets)
)
result = DataFrame.from_gpu_matrix(result)
result = result._apply_support_method("astype", dtype="bool")
result.columns = [x for x in list(reversed(poly_offsets.index))]
result = result[list(reversed(result.columns))]
return result
