def distance_to_mesh(self, mesh, with_depths=True):
"""
Compute distance (in km) between this point and each point of ``mesh``.
:param mesh:
:class:`~nhlib.geo.mesh.Mesh` of points to calculate distance to.
:param with_depths:
If ``True`` (by default), distance is calculated between actual
point and the mesh, geodetic distance of projections is combined
with vertical distance (difference of depths). If this is set
to ``False``, only geodetic distance between projections
is calculated.
:returns:
Numpy array of floats of the same shape as ``mesh`` with distance
values in km in respective indices.
"""
if with_depths:
if mesh.depths is None:
mesh_depths = numpy.zeros_like(mesh.lons)
else:
mesh_depths = mesh.depths
return geodetic.distance(self.longitude, self.latitude, self.depth,
mesh.lons, mesh.lats, mesh_depths)
else:
return geodetic.geodetic_distance(self.longitude, self.latitude,
mesh.lons, mesh.lats)
def _test(self, mlons, mlats, mdepths, slons, slats, sdepths,
expected_mpoint_indices):
mlons, mlats, mdepths = [
numpy.array(arr, float) for arr in (mlons, mlats, mdepths)
]
slons, slats, sdepths = [
numpy.array(arr, float) for arr in (slons, slats, sdepths)
]
actual_indices = geodetic.min_distance(mlons,
mlats,
mdepths,
slons,
slats,
sdepths,
indices=True)
numpy.testing.assert_equal(actual_indices, expected_mpoint_indices)
dists = geodetic.min_distance(mlons, mlats, mdepths, slons, slats,
sdepths)
expected_closest_mlons = mlons.flat[expected_mpoint_indices]
expected_closest_mlats = mlats.flat[expected_mpoint_indices]
expected_closest_mdepths = mdepths.flat[expected_mpoint_indices]
expected_distances = geodetic.distance(expected_closest_mlons,
expected_closest_mlats,
expected_closest_mdepths, slons,
slats, sdepths)
self.assertTrue((dists == expected_distances).all())
# testing min_geodetic_distance with the same lons and lats
min_geod_distance = geodetic.min_geodetic_distance(
mlons, mlats, slons, slats)
min_geo_distance2 = geodetic.min_distance(mlons, mlats, mdepths * 0,
slons, slats, sdepths * 0)
numpy.testing.assert_almost_equal(min_geod_distance, min_geo_distance2)
def distance_to_mesh(self, mesh, with_depths=True):
"""
Compute distance (in km) between this point and each point of ``mesh``.
:param mesh:
:class:`~nhlib.geo.mesh.Mesh` of points to calculate distance to.
:param with_depths:
If ``True`` (by default), distance is calculated between actual
point and the mesh, geodetic distance of projections is combined
with vertical distance (difference of depths). If this is set
to ``False``, only geodetic distance between projections
is calculated.
:returns:
Numpy array of floats of the same shape as ``mesh`` with distance
values in km in respective indices.
"""
if with_depths:
if mesh.depths is None:
mesh_depths = numpy.zeros_like(mesh.lons)
else:
mesh_depths = mesh.depths
return geodetic.distance(self.longitude, self.latitude, self.depth,
mesh.lons, mesh.lats, mesh_depths)
else:
return geodetic.geodetic_distance(self.longitude, self.latitude,
mesh.lons, mesh.lats)
def _test(self, mlons, mlats, mdepths, slons, slats, sdepths,
expected_mpoint_indices):
mlons, mlats, mdepths = [numpy.array(arr, float)
for arr in (mlons, mlats, mdepths)]
slons, slats, sdepths = [numpy.array(arr, float)
for arr in (slons, slats, sdepths)]
actual_indices = geodetic.min_distance(mlons, mlats, mdepths,
slons, slats, sdepths,
indices=True)
numpy.testing.assert_equal(actual_indices, expected_mpoint_indices)
dists = geodetic.min_distance(mlons, mlats, mdepths,
slons, slats, sdepths)
expected_closest_mlons = mlons.flat[expected_mpoint_indices]
expected_closest_mlats = mlats.flat[expected_mpoint_indices]
expected_closest_mdepths = mdepths.flat[expected_mpoint_indices]
expected_distances = geodetic.distance(
expected_closest_mlons, expected_closest_mlats,
expected_closest_mdepths,
slons, slats, sdepths
)
self.assertTrue((dists == expected_distances).all())
# testing min_geodetic_distance with the same lons and lats
min_geod_distance = geodetic.min_geodetic_distance(mlons, mlats,
slons, slats)
min_geo_distance2 = geodetic.min_distance(mlons, mlats, mdepths * 0,
slons, slats, sdepths * 0)
numpy.testing.assert_almost_equal(min_geod_distance, min_geo_distance2)
def _test(self, mlons, mlats, mdepths, slons, slats, sdepths,
expected_mpoint_indexes):
mlons, mlats, mdepths = map(numpy.array, (mlons, mlats, mdepths))
dists = geodetic.min_distance(mlons, mlats, mdepths,
slons, slats, sdepths)
expected_closest_mlons = mlons[expected_mpoint_indexes]
expected_closest_mlats = mlats[expected_mpoint_indexes]
expected_closest_mdepths = mdepths[expected_mpoint_indexes]
expected_distances = geodetic.distance(
expected_closest_mlons, expected_closest_mlats,
expected_closest_mdepths,
slons, slats, sdepths
)
self.assertTrue((dists == expected_distances).all())
def distance(self, point):
"""
Compute the distance (in km) between this point and the given point.
Distance is calculated using pythagoras theorem, where the
hypotenuse is the distance and the other two sides are the
horizontal distance (great circle distance) and vertical
distance (depth difference between the two locations).
:param point:
Destination point.
:type point:
Instance of :class:`Point`
:returns:
The distance.
:rtype:
float
"""
return geodetic.distance(self.longitude, self.latitude, self.depth,
point.longitude, point.latitude, point.depth)
def distance(self, point):
"""
Compute the distance (in km) between this point and the given point.
Distance is calculated using pythagoras theorem, where the
hypotenuse is the distance and the other two sides are the
horizontal distance (great circle distance) and vertical
distance (depth difference between the two locations).
:param point:
Destination point.
:type point:
Instance of :class:`Point`
:returns:
The distance.
:rtype:
float
"""
return geodetic.distance(self.longitude, self.latitude, self.depth,
point.longitude, point.latitude, point.depth)
def closer_than(self, mesh, radius):
"""
Check for proximity of points in the ``mesh``.
:param mesh:
:class:`nhlib.geo.mesh.Mesh` instance.
:param radius:
Proximity measure in km.
:returns:
Numpy array of boolean values in the same shape as the mesh
coordinate arrays with ``True`` on indexes of points that
are not further than ``radius`` km from this point. Function
:func:`~nhlib.geo.geodetic.distance` is used to calculate
distances to points of the mesh. Points of the mesh that
lie exactly ``radius`` km away from this point also have
``True`` in their indices.
"""
dists = geodetic.distance(self.longitude, self.latitude, self.depth,
mesh.lons, mesh.lats,
0 if mesh.depths is None else mesh.depths)
return dists <= radius
def closer_than(self, mesh, radius):
"""
Check for proximity of points in the ``mesh``.
:param mesh:
:class:`nhlib.geo.mesh.Mesh` instance.
:param radius:
Proximity measure in km.
:returns:
Numpy array of boolean values in the same shape as the mesh
coordinate arrays with ``True`` on indexes of points that
are not further than ``radius`` km from this point. Function
:func:`~nhlib.geo.geodetic.distance` is used to calculate
distances to points of the mesh. Points of the mesh that
lie exactly ``radius`` km away from this point also have
``True`` in their indices.
"""
dists = geodetic.distance(self.longitude, self.latitude, self.depth,
mesh.lons, mesh.lats,
0 if mesh.depths is None else mesh.depths)
return dists <= radius
def test(self):
p1 = (0, 0, 10)
p2 = (0.5, -0.3, 5)
distance = geodetic.distance(*(p1 + p2))
self.assertAlmostEqual(distance, 65.0295143)
def test(self):
p1 = (0, 0, 10)
p2 = (0.5, -0.3, 5)
distance = geodetic.distance(*(p1 + p2))
self.assertAlmostEqual(distance, 65.0295143)
