geometry/LineString.h

Go to the documentation of this file.

#pragma once
#include <boost/geometry/algorithms/intersects.hpp>
#include <boost/geometry/algorithms/length.hpp>
#include <boost/geometry/geometries/register/linestring.hpp>
#include <boost/geometry/geometries/register/segment.hpp>

#include "lanelet2_core/Forward.h"
#include "lanelet2_core/geometry/BoundingBox.h"
#include "lanelet2_core/geometry/GeometryHelper.h"
#include "lanelet2_core/geometry/Point.h"
#include "lanelet2_core/primitives/CompoundLineString.h"
#include "lanelet2_core/primitives/LineString.h"

/***********************************************************************
 *                   BOOST GEOMETRY REGISTRATIONS                      *
 ***********************************************************************/

BOOST_GEOMETRY_REGISTER_LINESTRING(lanelet::BasicLineString3d)
BOOST_GEOMETRY_REGISTER_LINESTRING(lanelet::BasicLineString2d)
BOOST_GEOMETRY_REGISTER_LINESTRING(lanelet::LineString3d)
BOOST_GEOMETRY_REGISTER_LINESTRING(lanelet::LineString2d)
BOOST_GEOMETRY_REGISTER_LINESTRING(lanelet::ConstLineString3d)
BOOST_GEOMETRY_REGISTER_LINESTRING(lanelet::ConstLineString2d)
BOOST_GEOMETRY_REGISTER_LINESTRING(lanelet::ConstHybridLineString3d)
BOOST_GEOMETRY_REGISTER_LINESTRING(lanelet::ConstHybridLineString2d)
BOOST_GEOMETRY_REGISTER_LINESTRING(lanelet::CompoundLineString2d)
BOOST_GEOMETRY_REGISTER_LINESTRING(lanelet::CompoundLineString3d)
BOOST_GEOMETRY_REGISTER_LINESTRING(lanelet::CompoundHybridLineString2d)
BOOST_GEOMETRY_REGISTER_LINESTRING(lanelet::CompoundHybridLineString3d)
BOOST_GEOMETRY_REGISTER_SEGMENT_TEMPLATIZED(lanelet::Segment, first, second)

namespace lanelet {
namespace geometry {

using boost::geometry::intersects;
using boost::geometry::length;
using boost::geometry::overlaps;
using boost::geometry::touches;

template <typename LineStringIterator>
double rangedLength(LineStringIterator start, LineStringIterator end);

template <typename LineStringT>
std::vector<double> lengthRatios(const LineStringT& lineString);

template <typename LineStringT>
std::vector<double> accumulatedLengthRatios(const LineStringT& lineString);

template <typename LineString3dT>
double signedDistance(const LineString3dT& lineString, const BasicPoint3d& p);

template <typename LineString2dT>
double signedDistance(const LineString2dT& lineString, const BasicPoint2d& p);

template <typename Point2dT>
double curvature2d(const Point2dT& p1, const Point2dT& p2, const Point2dT& p3);

template <typename LineString2dT>
ArcCoordinates toArcCoordinates(const LineString2dT& lineString, const BasicPoint2d& point);

template <typename LineStringT>
traits::BasicPointT<traits::PointType<LineStringT>> interpolatedPointAtDistance(LineStringT lineString, double dist);

template <typename LineStringT>
traits::PointType<LineStringT> nearestPointAtDistance(LineStringT lineString, double dist);

template <typename LineString3dT>
IfLS<LineString3dT, BoundingBox3d> boundingBox3d(const LineString3dT& lineString);

template <typename LineString2dT>
IfLS<LineString2dT, BoundingBox2d> boundingBox2d(const LineString2dT& lineString);

template <typename LineString3dT, typename = std::enable_if_t<traits::is3D<LineString3dT>()>>
BasicPoint3d project(const LineString3dT& lineString, const BasicPoint3d& pointToProject);

template <typename LineString2dT, typename = std::enable_if_t<traits::is2D<LineString2dT>()>>
BasicPoint2d project(const LineString2dT& lineString, const BasicPoint2d& pointToProject);

BasicPoint2d project(const BasicSegment2d& segment, const BasicPoint2d& pointToProject);
BasicPoint3d project(const BasicSegment3d& segment, const BasicPoint3d& pointToProject);

template <typename LineString2dT>
IfLS<LineString2dT, std::pair<BasicPoint2d, BasicPoint2d>> projectedPoint2d(const LineString2dT& l1,
                                                                            const LineString2dT& l2);

template <typename LineString3dT>
IfLS<LineString3dT, std::pair<BasicPoint3d, BasicPoint3d>> projectedPoint3d(const LineString3dT& l1,
                                                                            const LineString3dT& l2);

template <typename LineString3dT>
IfLS<LineString3dT, bool> intersects3d(const LineString3dT& linestring, const LineString3dT& otherLinestring,
                                       double heightTolerance = 3.);

template <typename LineString1T, typename LineString2T>
std::pair<LineString1T, LineString2T> align(LineString1T left, LineString2T right);

template <typename LineString2dT>
BasicPoint2d fromArcCoordinates(const LineString2dT& lineString, const ArcCoordinates& arcCoords);

template <typename LineString2dT>
BasicLineString2d offset(const LineString2dT& lineString, double distance);

template <typename LineString2dT>
BasicLineString2d offsetNoThrow(const LineString2dT& lineString, double distance);

Segment<BasicPoint2d> closestSegment(const BasicLineString2d& lineString, const BasicPoint2d& pointToProject);

Segment<BasicPoint3d> closestSegment(const BasicLineString3d& lineString, const BasicPoint3d& pointToProject);
Segment<ConstPoint2d> closestSegment(const ConstLineString2d& lineString, const BasicPoint2d& pointToProject);
Segment<ConstPoint3d> closestSegment(const ConstLineString3d& lineString, const BasicPoint3d& pointToProject);
Segment<BasicPoint2d> closestSegment(const ConstHybridLineString2d& lineString, const BasicPoint2d& pointToProject);
Segment<BasicPoint3d> closestSegment(const ConstHybridLineString3d& lineString, const BasicPoint3d& pointToProject);
Segment<ConstPoint2d> closestSegment(const CompoundLineString2d& lineString, const BasicPoint2d& pointToProject);
Segment<ConstPoint3d> closestSegment(const CompoundLineString3d& lineString, const BasicPoint3d& pointToProject);
Segment<BasicPoint2d> closestSegment(const CompoundHybridLineString2d& lineString, const BasicPoint2d& pointToProject);
Segment<BasicPoint3d> closestSegment(const CompoundHybridLineString3d& lineString, const BasicPoint3d& pointToProject);
}  // namespace geometry
}  // namespace lanelet

#include "impl/LineString.h"