ENUOperation.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/ENUEdgeValidInputRange.hpp"
#include "ad/map/point/ENUPointValidInputRange.hpp"
#include "ad/map/point/PointOperation.hpp"
 
namespace ad {
namespace map {
namespace point {
 
inline bool isValid(ENUPoint const &point, bool const logErrors = true)
{
  return withinValidInputRange(point, logErrors);
}
 
inline bool isValid(ENUEdge const &edge, bool const logErrors = true)
{
  return withinValidInputRange(edge, logErrors);
}
 
inline ENUPoint createENUPoint(double const x, double const y, double const z)
{
  ENUPoint result;
  result.x = ENUCoordinate(x);
  result.y = ENUCoordinate(y);
  result.z = ENUCoordinate(z);
  return result;
}
 
inline ENUPoint createENUPoint(ENUCoordinate const x, ENUCoordinate const y, ENUCoordinate const z)
{
  ENUPoint result;
  result.x = x;
  result.y = y;
  result.z = z;
  return result;
}
 
inline ENUPoint getEnuEastAxis()
{
  ENUPoint result;
  result.x = ENUCoordinate(1.);
  result.y = ENUCoordinate(0.);
  result.z = ENUCoordinate(0.);
  return result;
}
 
inline ENUPoint getEnuNorthAxis()
{
  ENUPoint result;
  result.x = ENUCoordinate(0.);
  result.y = ENUCoordinate(1.);
  result.z = ENUCoordinate(0.);
  return result;
}
 
inline ENUPoint getEnuUpAxis()
{
  ENUPoint result;
  result.x = ENUCoordinate(0.);
  result.y = ENUCoordinate(0.);
  result.z = ENUCoordinate(1.);
  return result;
}
 
inline physics::Distance distance(ENUPoint const &point, ENUPoint const &other)
{
  return vectorLength(vectorSub(point, other));
}
 
physics::Distance calcLength(ENUEdge const &edge);
 
} // namespace point
} // namespace map
} // namespace ad
 
inline double operator*(::ad::map::point::ENUPoint const &a, ::ad::map::point::ENUPoint const &b)
{
  return ::ad::map::point::vectorDotProduct(a, b);
}
 
inline ::ad::map::point::ENUPoint operator*(::ad::map::point::ENUPoint const &a, ::ad::physics::Distance const &b)
{
  return ::ad::map::point::vectorMultiplyScalar(a, b);
}
 
inline ::ad::map::point::ENUPoint operator*(::ad::physics::Distance const &b, ::ad::map::point::ENUPoint const &a)
{
  return ::ad::map::point::vectorMultiplyScalar(a, b);
}
 
inline ::ad::map::point::ENUPoint operator*(::ad::map::point::ENUPoint const &a, double const &b)
{
  return ::ad::map::point::vectorMultiplyScalar(a, b);
}
 
inline ::ad::map::point::ENUPoint operator*(double const &b, ::ad::map::point::ENUPoint const &a)
{
  return ::ad::map::point::vectorMultiplyScalar(a, b);
}
 
inline ::ad::map::point::ENUPoint operator+(::ad::map::point::ENUPoint const &a, ::ad::map::point::ENUPoint const &b)
{
  return ::ad::map::point::vectorAdd(a, b);
}
 
inline ::ad::map::point::ENUPoint operator-(::ad::map::point::ENUPoint const &a, ::ad::map::point::ENUPoint const &b)
{
  return ::ad::map::point::vectorSub(a, b);
}