Source code for openquake.hazardlib.geo.point

# -*- coding: utf-8 -*-
# vim: tabstop=4 shiftwidth=4 softtabstop=4
# Copyright (C) 2012-2020 GEM Foundation
# OpenQuake is free software: you can redistribute it and/or modify it
# under the terms of the GNU Affero General Public License as published
# by the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# OpenQuake is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# GNU Affero General Public License for more details.
# You should have received a copy of the GNU Affero General Public License
# along with OpenQuake. If not, see <>.

Module :mod:`openquake.hazardlib.geo.point` defines :class:`Point`.
import numpy
import shapely.geometry

from openquake.hazardlib.geo import geodetic
from openquake.hazardlib.geo import utils as geo_utils

[docs]class Point(object): """ This class represents a geographical point in terms of longitude, latitude, and depth (with respect to the Earth surface). :param longitude: Point longitude, in decimal degrees. :type longitude: float :param latitude: Point latitude, in decimal degrees. :type latitude: float :param depth: Point depth (default to 0.0), in km. Depth > 0 indicates a point below the earth surface, and depth < 0 above the earth surface. :type depth: float """ #: The distance between two points for them to be considered equal, #: in km. EQUALITY_DISTANCE = 1e-3 def __init__(self, longitude, latitude, depth=0.0): if not depth < geodetic.EARTH_RADIUS: raise ValueError("The depth must be less than " "the Earth's radius (6371.0 km)") if not depth > geodetic.EARTH_ELEVATION: raise ValueError("The depth must be greater than the maximum " "elevation on Earth's surface (-8.848 km)") if not -180.0 <= longitude <= 180.0: raise ValueError("longitude %.6f outside range" % longitude) if not -90.0 <= latitude <= 90.0: raise ValueError("latitude %.6f outside range" % latitude) self.depth = depth self.latitude = latitude self.longitude = longitude @property def x(self): """Alias for .longitude""" return self.longitude @property def y(self): """Alias for .latitude""" return self.latitude @property def z(self): """Alias for .depth""" return self.depth @property def wkt2d(self): """ Generate WKT (Well-Known Text) to represent this point in 2 dimensions (ignoring depth). """ return 'POINT(%s %s)' % (self.longitude, self.latitude)
[docs] def point_at(self, horizontal_distance, vertical_increment, azimuth): """ Compute the point with given horizontal, vertical distances and azimuth from this point. :param horizontal_distance: Horizontal distance, in km. :type horizontal_distance: float :param vertical_increment: Vertical increment, in km. When positive, the new point has a greater depth. When negative, the new point has a smaller depth. :type vertical_increment: float :type azimuth: Azimuth, in decimal degrees. :type azimuth: float :returns: The point at the given distances. :rtype: Instance of :class:`Point` """ lon, lat = geodetic.point_at(self.longitude, self.latitude, azimuth, horizontal_distance) return Point(lon, lat, self.depth + vertical_increment)
[docs] def azimuth(self, point): """ Compute the azimuth (in decimal degrees) between this point and the given point. :param point: Destination point. :type point: Instance of :class:`Point` :returns: The azimuth, value in a range ``[0, 360)``. :rtype: float """ return geodetic.azimuth(self.longitude, self.latitude, point.longitude, point.latitude)
[docs] 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)
[docs] def distance_to_mesh(self, mesh, with_depths=True): """ Compute distance (in km) between this point and each point of ``mesh``. :param mesh: :class:`~openquake.hazardlib.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 __str__(self): """ >>> str(Point(1, 2, 3)) '<Latitude=2.000000, Longitude=1.000000, Depth=3.0000>' >>> str(Point(1.0 / 3.0, -39.999999999, 1.6666666666)) '<Latitude=-40.000000, Longitude=0.333333, Depth=1.6667>' """ return "<Latitude=%.6f, Longitude=%.6f, Depth=%.4f>" % ( self.latitude, self.longitude, self.depth ) def __repr__(self): """ >>> str(Point(1, 2, 3)) == repr(Point(1, 2, 3)) True """ return self.__str__() def __eq__(self, other): """ >>> Point(1e-4, 1e-4) == Point(0, 0) False >>> Point(1e-6, 1e-6) == Point(0, 0) True >>> Point(0, 0, 1) == Point(0, 0, 0) False >>> Point(4, 5, 1e-3) == Point(4, 5, 0) True >>> Point(-180 + 1e-7, 0) == Point(180 - 1e-7, 0) True """ if other is None: return False return abs(self.distance(other)) <= self.EQUALITY_DISTANCE def __ne__(self, other): return not self.__eq__(other)
[docs] def on_surface(self): """ Check if this point is defined on the surface (depth is 0.0). :returns bool: True if this point is on the surface, false otherwise. """ return self.depth == 0.0
[docs] def equally_spaced_points(self, point, distance): """ Compute the set of points equally spaced between this point and the given point. :param point: Destination point. :type point: Instance of :class:`Point` :param distance: Distance between points (in km). :type distance: float :returns: The list of equally spaced points. :rtype: list of :class:`Point` instances """ lons, lats, depths = geodetic.intervals_between( self.longitude, self.latitude, self.depth, point.longitude, point.latitude, point.depth, distance) return [Point(lons[i], lats[i], depths[i]) for i in range(len(lons))]
[docs] def to_polygon(self, radius): """ Create a circular polygon with specified radius centered in the point. :param radius: Required radius of a new polygon, in km. :returns: Instance of :class:`~openquake.hazardlib.geo.polygon.Polygon` that approximates a circle around the point with specified radius. """ assert radius > 0 # avoid circular imports from openquake.hazardlib.geo.polygon import Polygon # get a projection that is centered in the point proj = geo_utils.OrthographicProjection( self.longitude, self.longitude, self.latitude, self.latitude) # create a shapely object from a projected point coordinates, # which are supposedly (0, 0) point = shapely.geometry.Point(*proj(self.longitude, self.latitude)) # extend the point to a shapely polygon using buffer() # and create openquake.hazardlib.geo.polygon.Polygon object from it return Polygon._from_2d(point.buffer(radius), proj)
[docs] def closer_than(self, mesh, radius): """ Check for proximity of points in the ``mesh``. :param mesh: :class:`openquake.hazardlib.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:`~openquake.hazardlib.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
[docs] @classmethod def from_vector(cls, vector): """ Create a point object from a 3d vector in Cartesian space. :param vector: Tuple, list or numpy array of three float numbers representing point coordinates in Cartesian 3d space. :returns: A :class:`Point` object created from those coordinates. """ return cls(*geo_utils.cartesian_to_spherical(vector))