ECEFOperation.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/ECEFEdgeValidInputRange.hpp"
#include "ad/map/point/ECEFPointValidInputRange.hpp"
#include "ad/map/point/PointOperation.hpp"
 
namespace ad {
namespace map {
namespace point {
 
inline bool isValid(ECEFPoint const &point, bool const logErrors = true)
{
  return withinValidInputRange(point, logErrors);
}
 
inline bool isValid(ECEFEdge const &edge, bool const logErrors = true)
{
  return withinValidInputRange(edge, logErrors);
}
 
inline ECEFPoint createECEFPoint(double const x, double const y, double const z)
{
  ECEFPoint result;
  result.x = ECEFCoordinate(x);
  result.y = ECEFCoordinate(y);
  result.z = ECEFCoordinate(z);
  return result;
}
 
inline ECEFPoint createECEFPoint(ECEFCoordinate const x, ECEFCoordinate const y, ECEFCoordinate const z)
{
  ECEFPoint result;
  result.x = x;
  result.y = y;
  result.z = z;
  return result;
}
 
inline physics::Distance distance(ECEFPoint const &point, ECEFPoint const &other)
{
  return vectorLength(vectorSub(point, other));
}
 
physics::Distance calcLength(ECEFEdge const &edge);
 
} // namespace point
} // namespace map
} // namespace ad
 
inline double operator*(::ad::map::point::ECEFPoint const &a, ::ad::map::point::ECEFPoint const &b)
{
  return ::ad::map::point::vectorDotProduct(a, b);
}
 
inline ::ad::map::point::ECEFPoint operator*(::ad::map::point::ECEFPoint const &a, ::ad::physics::Distance const &b)
{
  return ::ad::map::point::vectorMultiplyScalar(a, b);
}
 
inline ::ad::map::point::ECEFPoint operator*(::ad::physics::Distance const &b, ::ad::map::point::ECEFPoint const &a)
{
  return ::ad::map::point::vectorMultiplyScalar(a, b);
}
 
inline ::ad::map::point::ECEFPoint operator*(::ad::map::point::ECEFPoint const &a, double const &b)
{
  return ::ad::map::point::vectorMultiplyScalar(a, b);
}
 
inline ::ad::map::point::ECEFPoint operator*(double const &b, ::ad::map::point::ECEFPoint const &a)
{
  return ::ad::map::point::vectorMultiplyScalar(a, b);
}
 
inline ::ad::map::point::ECEFPoint operator+(::ad::map::point::ECEFPoint const &a, ::ad::map::point::ECEFPoint const &b)
{
  return ::ad::map::point::vectorAdd(a, b);
}
 
inline ::ad::map::point::ECEFPoint operator-(::ad::map::point::ECEFPoint const &a, ::ad::map::point::ECEFPoint const &b)
{
  return ::ad::map::point::vectorSub(a, b);
}