geoCoord.h File Reference

Geodetic (lat/lon) functions. More...

#include "QueryEngine/ExtensionFunctions/h3lib/include/constants.h"
#include "QueryEngine/ExtensionFunctions/h3lib/include/h3api.h"
#include "QueryEngine/ExtensionFunctions/h3lib/lib/geoCoord.hpp"

Include dependency graph for geoCoord.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
EXTENSION_INLINE double	constrainLng (double lng)
EXTENSION_NOINLINE double	_posAngleRads (double rads)
EXTENSION_NOINLINE double	_geoAzimuthRads (const GeoCoord(p1), const GeoCoord(p2))
EXTENSION_NOINLINE bool	_geoAzDistanceRads (const GeoCoord(p1), double az, double distance, GeoCoord(p2))

Detailed Description

Geodetic (lat/lon) functions.

Definition in file geoCoord.h.

Function Documentation

EXTENSION_NOINLINE bool _geoAzDistanceRads	(	const	GeoCoordp1,
		double	az,
		double	distance,
		GeoCoord(p2)
	)

Computes the point on the sphere a specified azimuth and distance from another point.

Parameters

p1	The first spherical coordinates.
az	The desired azimuth from p1.
distance	The desired distance from p1, must be non-negative.
p2	The spherical coordinates at the desired azimuth and distance from p1.

Definition at line 204 of file geoCoord.hpp.

References _posAngleRads(), constrainLng(), EPSILON, GeoCoordCopy, LAT_INDEX, LON_INDEX, M_PI, and M_PI_2.

Referenced by _hex2dToGeo().

                                                         {
  if (distance < EPSILON) {
    GeoCoordCopy(p2, p1);
    return true;
  }

  double sinlat, sinlon, coslon;

  az = _posAngleRads(az);

  // check for due north/south azimuth
  if (az < EPSILON || fabs(az - M_PI) < EPSILON) {
    if (az < EPSILON)  // due north
      p2[LAT_INDEX] = p1[LAT_INDEX] + distance;
    else  // due south
      p2[LAT_INDEX] = p1[LAT_INDEX] - distance;

    if (fabs(p2[LAT_INDEX] - M_PI_2) < EPSILON)  // north pole
    {
      p2[LAT_INDEX] = M_PI_2;
      p2[LON_INDEX] = 0.0;
    } else if (fabs(p2[LAT_INDEX] + M_PI_2) < EPSILON)  // south pole
    {
      p2[LAT_INDEX] = -M_PI_2;
      p2[LON_INDEX] = 0.0;
    } else
      p2[LON_INDEX] = constrainLng(p1[LON_INDEX]);
  } else  // not due north or south
  {
    sinlat =
        sin(p1[LAT_INDEX]) * cos(distance) + cos(p1[LAT_INDEX]) * sin(distance) * cos(az);
    if (sinlat > 1.0)
      sinlat = 1.0;
    if (sinlat < -1.0)
      sinlat = -1.0;
    p2[LAT_INDEX] = asin(sinlat);
    if (fabs(p2[LAT_INDEX] - M_PI_2) < EPSILON)  // north pole
    {
      p2[LAT_INDEX] = M_PI_2;
      p2[LON_INDEX] = 0.0;
    } else if (fabs(p2[LAT_INDEX] + M_PI_2) < EPSILON)  // south pole
    {
      p2[LAT_INDEX] = -M_PI_2;
      p2[LON_INDEX] = 0.0;
    } else {
      sinlon = sin(az) * sin(distance) / cos(p2[LAT_INDEX]);
      coslon = (cos(distance) - sin(p1[LAT_INDEX]) * sin(p2[LAT_INDEX])) /
               cos(p1[LAT_INDEX]) / cos(p2[LAT_INDEX]);
      if (sinlon > 1.0)
        sinlon = 1.0;
      if (sinlon < -1.0)
        sinlon = -1.0;
      if (coslon > 1.0)
        coslon = 1.0;
      if (coslon < -1.0)
        coslon = -1.0;
      p2[LON_INDEX] = constrainLng(p1[LON_INDEX] + atan2(sinlon, coslon));
    }
  }
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

EXTENSION_NOINLINE double _geoAzimuthRads	(	const	GeoCoordp1,
		const	GeoCoordp2
	)

The great circle distance in radians between two spherical coordinates.

This function uses the Haversine formula. For math details, see: https://en.wikipedia.org/wiki/Haversine_formula https://www.movable-type.co.uk/scripts/latlong.html

Parameters

a	the first lat/lng pair (in radians)
b	the second lat/lng pair (in radians)

Returns

the great circle distance in radians between a and b The great circle distance in kilometers between two spherical coordinates. The great circle distance in meters between two spherical coordinates. Determines the azimuth to p2 from p1 in radians.

Parameters

p1	The first spherical coordinates.
p2	The second spherical coordinates.

Returns

The azimuth in radians from p1 to p2.

Definition at line 187 of file geoCoord.hpp.

References LAT_INDEX, and LON_INDEX.

Referenced by _geoToHex2d().

                                                                                  {
  return atan2(
      cos(p2[LAT_INDEX]) * sin(p2[LON_INDEX] - p1[LON_INDEX]),
      cos(p1[LAT_INDEX]) * sin(p2[LAT_INDEX]) -
          sin(p1[LAT_INDEX]) * cos(p2[LAT_INDEX]) * cos(p2[LON_INDEX] - p1[LON_INDEX]));
}

Here is the caller graph for this function:

EXTENSION_NOINLINE double _posAngleRads

(

double

rads

)

Normalizes radians to a value between 0.0 and two PI.

Parameters

rads	The input radians value.

Returns

The normalized radians value.

Definition at line 35 of file geoCoord.hpp.

References M_2PI.

Referenced by _geoAzDistanceRads(), _geoToHex2d(), and _hex2dToGeo().

                                                     {
  double tmp = ((rads < 0.0) ? rads + M_2PI : rads);
  if (rads >= M_2PI)
    tmp -= M_2PI;
  return tmp;
}

Here is the caller graph for this function:

EXTENSION_INLINE double constrainLng

(

double

lng

)

epsilon of ~0.1mm in degrees epsilon of ~0.1mm in radians

constrainLat makes sure latitudes are in the proper bounds

Parameters

lat	The original lat value

Returns

The corrected lat value constrainLng makes sure longitudes are in the proper bounds

Parameters

lng	The origin lng value

Returns

The corrected lng value

Definition at line 134 of file geoCoord.hpp.

References M_PI.

Referenced by _geoAzDistanceRads().

                                                 {
  while (lng > M_PI) {
    lng = lng - (2 * M_PI);
  }
  while (lng < -M_PI) {
    lng = lng + (2 * M_PI);
  }
  return lng;
}

Here is the caller graph for this function: