CompoundLineString.h

Go to the documentation of this file.

#pragma once
#include <boost/noncopyable.hpp>
#include <utility>

#include "lanelet2_core/primitives/LineString.h"
#include "lanelet2_core/utility/CompoundIterator.h"

namespace lanelet {
namespace internal {
template <typename PointT>
struct SelectCompoundLsIterator {
  using BaseIterator = internal::UniqueCompoundIterator<const ConstLineStrings3d>;
  using Iterator = internal::TransformIterator<internal::ReverseAndForwardIterator<BaseIterator>, const PointT>;
};

template <>
struct SelectCompoundLsIterator<ConstPoint3d> {
  using BaseIterator = internal::UniqueCompoundIterator<const ConstLineStrings3d>;
  using Iterator = internal::ReverseAndForwardIterator<BaseIterator>;
};

template <typename T>
using SelectCompoundLsIteratorT = typename SelectCompoundLsIterator<T>::Iterator;
}  // namespace internal

class CompoundLineStringData : boost::noncopyable {
  using BaseIter = typename internal::SelectCompoundLsIterator<ConstPoint3d>::BaseIterator;
  using Reverse = std::reverse_iterator<BaseIter>;

 public:
  using RFIter = internal::SelectCompoundLsIteratorT<ConstPoint3d>;
  explicit CompoundLineStringData(ConstLineStrings3d lineStrings) : ls_{std::move(lineStrings)} {}
  ConstPoints3d points() const { return ConstPoints3d(BaseIter::begin(ls_), BaseIter::end(ls_)); }
  const ConstLineStrings3d& lineStrings() const { return ls_; }
  RFIter pointsBegin(bool inverted) const {
    return inverted ? RFIter(Reverse(BaseIter::end(ls_))) : RFIter(BaseIter::begin(ls_));
  }
  RFIter pointsEnd(bool inverted) const {
    return inverted ? RFIter(Reverse(BaseIter::begin(ls_))) : RFIter(BaseIter::end(ls_));
  }

 private:
  const ConstLineStrings3d ls_;  // NOLINT
};

template <typename PointT>
class CompoundLineStringImpl {
  using RFIter = CompoundLineStringData::RFIter;

 public:
  // using declarations
  using DataType = CompoundLineStringData;
  using PointType = PointT;
  using BasicPointType = traits::BasicPointT<PointT>;
  using ConstPointType = traits::ConstPointT<PointT>;
  using Category = traits::LineStringTag;
  static constexpr traits::Dimensions Dimension = traits::PointTraits<PointT>::Dimension;
  using BasicIterator = internal::TransformIterator<RFIter, const BasicPointType>;
  using const_iterator =  // NOLINT
      internal::SelectCompoundLsIteratorT<ConstPointType>;
  using iterator = const_iterator;  // NOLINT
  using BasicLineString = internal::SelectBasicLineStringT<BasicPointType>;
  using SegmentType = Segment<ConstPointType>;
  explicit CompoundLineStringImpl(const ConstLineStrings3d& ls = ConstLineStrings3d())
      : data_{std::make_shared<CompoundLineStringData>(ls)} {}

  template <typename OtherT, typename = IfLS<OtherT, void>>
  explicit CompoundLineStringImpl(const std::vector<OtherT>& lss)
      : data_{std::make_shared<CompoundLineStringData>(
            utils::transform(lss, [](const auto& e) { return traits::to3D(traits::toConst(e)); }))} {}

  CompoundLineStringImpl(CompoundLineStringDataConstPtr data, bool inverted)
      : data_(std::move(data)), inverted_{inverted} {}

  template <typename OtherT>
  explicit CompoundLineStringImpl(const CompoundLineStringImpl<OtherT>& other)
      : data_(other.constData()), inverted_{other.inverted()} {}

  // default the rest (constructor above deletes copy constructors)
  CompoundLineStringImpl(CompoundLineStringImpl&& rhs) noexcept = default;
  CompoundLineStringImpl& operator=(CompoundLineStringImpl&& rhs) noexcept = default;
  CompoundLineStringImpl(const CompoundLineStringImpl& rhs) = default;
  CompoundLineStringImpl& operator=(const CompoundLineStringImpl& rhs) = default;
  ~CompoundLineStringImpl() noexcept = default;

  bool inverted() const noexcept { return inverted_; }

  size_t size() const noexcept { return std::distance(begin(), end()); }

  bool empty() const noexcept { return size() == 0; }

  const_iterator begin() const noexcept { return constData()->pointsBegin(inverted()); }
  const_iterator end() const noexcept { return constData()->pointsEnd(inverted()); }

  const PointType& front() const noexcept { return *begin(); }

  const PointType& back() const noexcept { return *std::prev(end()); }

  const PointType& operator[](size_t idx) const {
    assert(idx < size());
    return *std::next(begin(), idx);
  }

  SegmentType segment(size_t idx) const noexcept {
    assert(idx < size());
    const auto first = std::next(begin(), idx);
    const auto second = idx + 1 == size() ? begin() : std::next(first);
    return SegmentType(*first, *second);
  }

  size_t numSegments() const noexcept { return std::max(size_t(1), size()) - 1; }

  BasicIterator basicBegin() const { return constData()->pointsBegin(inverted()); }

  BasicIterator basicEnd() const { return constData()->pointsEnd(inverted()); }
  BasicLineString basicLineString() const { return {basicBegin(), basicEnd()}; }

  std::shared_ptr<const CompoundLineStringData> constData() const noexcept { return data_; }

  ConstLineStrings3d lineStrings() const {
    return inverted()
               ? utils::invert(utils::transform(data_->lineStrings(), [](const auto& ls) { return ls.invert(); }))
               : data_->lineStrings();
  }

  Ids ids() const {
    auto ids = utils::transform(data_->lineStrings(), [](const auto& ls) { return ls.id(); });
    if (inverted()) {
      return utils::invert(ids);
    }
    return ids;
  }

 private:
  CompoundLineStringDataConstPtr data_;
  bool inverted_{false};
};

class CompoundLineString2d : public CompoundLineStringImpl<ConstPoint2d> {
 public:
  using TwoDType = CompoundLineString2d;
  using ThreeDType = CompoundLineString3d;
  using HybridType = CompoundHybridLineString2d;
  using ConstType = CompoundLineString2d;
  using MutableType = void;
  using CompoundLineStringImpl::CompoundLineStringImpl;

  explicit CompoundLineString2d(const CompoundLineStrings2d& other)
      : CompoundLineString2d(utils::concatenate(other, [](auto& cls) { return cls.lineStrings(); })) {}
  CompoundLineString2d() = default;  // Not inherited from base class

  CompoundLineString2d invert() const noexcept { return CompoundLineString2d{constData(), !inverted()}; }
};

class CompoundLineString3d : public CompoundLineStringImpl<ConstPoint3d> {
 public:
  using TwoDType = CompoundLineString2d;
  using ThreeDType = CompoundLineString3d;
  using HybridType = CompoundHybridLineString3d;
  using ConstType = CompoundLineString3d;
  using MutableType = void;
  using CompoundLineStringImpl::CompoundLineStringImpl;
  explicit CompoundLineString3d(const CompoundLineStrings3d& other)
      : CompoundLineString3d(utils::concatenate(other, [](auto& cls) { return cls.lineStrings(); })) {}
  CompoundLineString3d() = default;  // Not inherited from base class

  CompoundLineString3d invert() const noexcept { return CompoundLineString3d{constData(), !inverted()}; }
};

class CompoundHybridLineString2d : public CompoundLineStringImpl<BasicPoint2d> {
 public:
  using TwoDType = CompoundHybridLineString2d;
  using ThreeDType = CompoundHybridLineString3d;
  using HybridType = CompoundHybridLineString2d;
  using ConstType = CompoundHybridLineString2d;
  using MutableType = void;
  using CompoundLineStringImpl::CompoundLineStringImpl;
  explicit CompoundHybridLineString2d(const CompoundHybridLineStrings2d& other)
      : CompoundHybridLineString2d(utils::concatenate(other, [](auto& cls) { return cls.lineStrings(); })) {}
  CompoundHybridLineString2d() = default;  // Not inherited from base class

  CompoundHybridLineString2d invert() const noexcept { return CompoundHybridLineString2d{constData(), !inverted()}; }
};

class CompoundHybridLineString3d : public CompoundLineStringImpl<BasicPoint3d> {
 public:
  using TwoDType = CompoundHybridLineString2d;
  using ThreeDType = CompoundHybridLineString3d;
  using HybridType = CompoundHybridLineString3d;
  using ConstType = CompoundHybridLineString3d;
  using MutableType = void;
  using CompoundLineStringImpl::CompoundLineStringImpl;
  explicit CompoundHybridLineString3d(const CompoundHybridLineStrings3d& other)
      : CompoundHybridLineString3d(utils::concatenate(other, [](auto& cls) { return cls.lineStrings(); })) {}
  CompoundHybridLineString3d() = default;  // Not inherited from base class

  CompoundHybridLineString3d invert() const noexcept { return CompoundHybridLineString3d{constData(), !inverted()}; }
};

namespace utils {
template <typename PointT>
bool has(const CompoundLineStringImpl<PointT>& ls, Id id) {
  return std::any_of(ls.begin(), ls.end(), [&id](const auto& elem) { return elem.id() == id; });
}
}  // namespace utils

template <typename Point1T, typename Point2T>
bool operator==(const CompoundLineStringImpl<Point1T>& lhs, const CompoundLineStringImpl<Point2T>& rhs) {
  return lhs.lineStrings() == rhs.lineStrings();
}

template <typename Point1T, typename Point2T>
bool operator!=(const CompoundLineStringImpl<Point1T>& lhs, const CompoundLineStringImpl<Point2T>& rhs) {
  return !(rhs == lhs);
}
template <typename Point1T, typename Point2T>
bool operator==(const CompoundLineStringImpl<Point1T>& lhs, const std::vector<Point2T>& rhs) {
  return lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin());
}

template <typename Point1T, typename Point2T>
bool operator==(const std::vector<Point1T>& lhs, const CompoundLineStringImpl<Point2T>& rhs) {
  return rhs == lhs;
}

template <typename Point1T, typename Point2T>
bool operator!=(const CompoundLineStringImpl<Point1T>& lhs, const std::vector<Point2T>& rhs) {
  return !(lhs == rhs);
}

template <typename Point1T, typename Point2T>
bool operator!=(const std::vector<Point1T>& lhs, const CompoundLineStringImpl<Point2T>& rhs) {
  return !(lhs == rhs);
}

template <typename PointT>
inline std::ostream& operator<<(std::ostream& stream, const CompoundLineStringImpl<PointT>& obj) {
  auto ids = obj.ids();
  stream << "[";
  if (!ids.empty()) {
    stream << "ids: ";
    std::copy(ids.begin(), ids.end(), std::ostream_iterator<Id>(stream, " "));
  }
  if (obj.inverted()) {
    stream << ", inverted";
  }
  return stream << "]";
}
}  // namespace lanelet