GeoOperation.hpp

Go to the documentation of this file.

// ----------------- BEGIN LICENSE BLOCK ---------------------------------
//
// Copyright (C) 2018-2021 Intel Corporation
//
// SPDX-License-Identifier: MIT
//
// ----------------- END LICENSE BLOCK -----------------------------------
#pragma once
 
#include "ad/map/point/GeoEdgeValidInputRange.hpp"
#include "ad/map/point/GeoPointValidInputRange.hpp"
#include "ad/map/point/PointOperation.hpp"
#include "ad/physics/Distance.hpp"
 
namespace ad {
namespace map {
namespace point {
 
extern Altitude const AltitudeUnknown;
 
inline bool isValid(GeoPoint const &point, bool const logErrors = true)
{
  return withinValidInputRange(point, logErrors);
}
 
inline bool isValid(GeoEdge const &edge, bool const logErrors = true)
{
  return withinValidInputRange(edge, logErrors);
}
 
inline double degree2radians(double degree)
{
  return degree * M_PI / 180.0;
}
 
inline double radians2degree(double radians)
{
  return radians * 180.0 / M_PI;
}
 
inline double toRadians(Latitude const &latitude)
{
  return degree2radians(static_cast<double>(latitude));
}
 
inline double toRadians(Longitude const &longitude)
{
  return degree2radians(static_cast<double>(longitude));
}
 
inline GeoPoint createGeoPoint(Longitude const longitude, Latitude const latitude, Altitude const altitude)
{
  GeoPoint result;
  result.longitude = longitude;
  result.latitude = latitude;
  result.altitude = altitude;
  return result;
}
 
physics::Distance distance(GeoPoint const &point, GeoPoint const &other);
 
GeoPoint zeroAltitude(GeoPoint const &point);
 
physics::Distance flatDistance(GeoPoint const &point, const GeoPoint &other);
 
GeoPoint approxAltitude(GeoPoint const &point, const GeoEdge &pts);
 
bool isOnTheLeft(GeoPoint const &point, const GeoPoint &pt0, const GeoPoint &pt1);
 
bool haveSameOrientation(const GeoEdge &pts0, const GeoEdge &pts1);
 
bool isOnTheLeft(const GeoEdge &pts0, const GeoEdge &pts1);
 
physics::Distance calcLength(GeoEdge const &edge);
 
template <> inline GeoPoint vectorExtrapolate(GeoPoint const &a, GeoPoint const &b, double const &scalar)
{
  GeoPoint result;
  result.longitude = (1 - scalar) * a.longitude + scalar * b.longitude;
  result.latitude = (1 - scalar) * a.latitude + scalar * b.latitude;
  result.altitude = (1 - scalar) * a.altitude + scalar * b.altitude;
  return result;
}
 
} // namespace point
} // namespace map
} // namespace ad