def rhumb_distance(start, to, units="km"): """ Calculates the distance along a rhumb line between two points in degrees, radians, miles, or kilometers. :param start: Start Point or Point Feature from which distance to be calculated. :param to: End Point or Point Feature upto which distance to be calculated. :param units: Units in which distance to be calculated, values can be 'deg', 'rad', 'mi', 'km' :return: Distance calculated from provided start to end Point. Example: >>> from turfpy.measurement import rhumb_distance >>> from geojson import Point, Feature >>> start = Feature(geometry=Point((-75.343, 39.984))) >>> end = Feature(geometry=Point((-75.534, 39.123))) >>> rhumb_distance(start, end,'mi') """ origin = get_coord(start) dest = get_coord(to) if dest[0] - origin[0] > 180: temp = -360 elif origin[0] - dest[0] > 180: temp = 360 else: temp = 0 dest[0] += temp distance_in_meters = _calculate_rhumb_distance(origin, dest) ru_distance = convert_length(distance_in_meters, "m", units) return ru_distance
def rhumb_destination(origin, distance, bearing, options) -> Feature: """ Returns the destination Point having travelled the given distance along a Rhumb line from the origin Point with the (varant) given bearing. :param origin: Starting Point :param distance: Distance from the starting point :param bearing: Varant bearing angle ranging from -180 to 180 degrees from north :param options: A dict of two values 'units' for the units of distance provided and 'properties' that are to be passed to the Destination Feature Point Example :- {'units':'mi', 'properties': {"marker-color": "F00"}} :return: Destination Feature Point Example: >>> from turfpy.measurement import rhumb_destination >>> from geojson import Point, Feature >>> start = Feature(geometry=Point((-75.343, 39.984)), properties={"marker-color": "F00"}) >>> distance = 50 >>> bearing = 90 >>> rhumb_destination(start, distance, bearing, {'units':'mi', 'properties': {"marker-color": "F00"}}) """ was_negative_distance = distance < 0 distance_in_meters = convert_length(abs(distance), options.get("units", ""), "m") if was_negative_distance: distance_in_meters = -1 * (abs(distance_in_meters)) coords = get_coord(origin) destination_point = _calculate_rhumb_destination(coords, distance_in_meters, bearing) return Feature( geometry=Point(destination_point), properties=options.get("properties", ""), )
def point_to_line_distance(point: Feature, line: Feature, units="km", method="geodesic"): """ Returns the minimum distance between a Point and any segment of the LineString. :param point: Point Feature from which distance to be measured. :param line: Point LineString from which distance to be measured. :param units: units for distance 'km', 'm', 'mi, 'ft', 'in', 'deg', 'cen', 'rad', 'naut', 'yd' :param method: Method which is used to calculate, values can be 'geodesic' or 'planar' :return: Approximate distance between the LineString and Point Example: >>> from turfpy.measurement import point_to_line_distance >>> from geojson import LineString, Point, Feature >>> point = Feature(geometry=Point((0, 0))) >>> linestring = Feature(geometry=LineString([(1, 1),(-1, 1)])) >>> point_to_line_distance(point, linestring) """ if method != "geodesic" and method != "planar": raise Exception( "method name is incorrect ot should be either geodesic or planar") options = {"units": units, "method": method} if not point: raise Exception("pt is required") if isinstance(point, list): point = Feature(geometry=Point(point)) elif point["type"] == "Point": point = Feature(point) else: feature_of(point, "Point", "point") if not line: raise Exception("line is required") if isinstance(point, list): line = Feature(geometry=LineString(line)) elif line["type"] == "LineString": line = Feature(geometry=line) else: feature_of(line, "LineString", "line") distance = float("inf") p = point["geometry"]["coordinates"] def _callback_segment_each( current_segment, feature_index, multi_feature_index, geometry_index, segment_index, ): nonlocal options, distance a = current_segment["geometry"]["coordinates"][0] b = current_segment["geometry"]["coordinates"][1] d = distance_to_segment(p, a, b, options) if d < distance: distance = d segment_each(line, _callback_segment_each) return convert_length(distance, "deg", options.get("units", ""))