point.hpp

Go to the documentation of this file.

#pragma once
 
#include "core/transformation.hpp"

 
#include <cassert>
#include <cmath>
#include <concepts>
#include <cstddef>
#include <functional>
#include <optional>
#include <ostream>
#include <type_traits>
#include <utility>
#include <array>
#include <vector>
 
 
namespace pgl {

struct NoLabel {};
 
template <class Number = int, class Label = NoLabel>
struct Point;
 
Point() -> Point<int>;
 
template <class Number>
Point(Number, Number) -> Point<Number>;
 
template <class Number, class Label>
Point(Number, Number, Label) -> Point<Number, std::decay_t<Label>>;
 
namespace detail {
    template <class Label>
    inline constexpr bool has_label_v = !std::same_as<Label, NoLabel>;
 

    template <class Label>
    struct LabelStorage {
        [[no_unique_address]] mutable Label value_{};
 
        constexpr LabelStorage() = default;
 
        template <class A>
            requires(std::constructible_from<Label, A&&>)
        constexpr LabelStorage(A&& label) : value_(std::forward<A>(label)) {}
    };

    template <>
    struct LabelStorage<NoLabel> {
        constexpr LabelStorage() = default;
        constexpr LabelStorage(NoLabel) {}
    };
 

    template <class TargetLabel, class SourceLabel>
    inline constexpr bool can_copy_label_v =
        !has_label_v<TargetLabel> ||
        (has_label_v<SourceLabel> && std::constructible_from<TargetLabel, const SourceLabel&>) ||
        (!has_label_v<SourceLabel> && std::default_initializable<TargetLabel>);

    template <class TargetLabel, class OtherPoint>
    constexpr auto copyLabel(const OtherPoint& other) {
        if constexpr (!has_label_v<TargetLabel>) {
            return NoLabel{};
        } else if constexpr (!has_label_v<typename OtherPoint::LabelType>) {
            return TargetLabel{};
        } else {
            return TargetLabel(other.label());
        }
    }
 
} //detail
 

template <class TNumber, class TLabel>
struct Point {
    using NumberType = TNumber;
    using LabelType = TLabel;

    constexpr Point() = default;

    constexpr Point(NumberType x, NumberType y)
        : coords_{x, y} {}

    template <class X, class Y, class A>
        requires(std::constructible_from<NumberType, const X&> &&
                 std::constructible_from<NumberType, const Y&> &&
                 std::constructible_from<LabelType, A&&>)
    constexpr Point(const X& x, const Y& y, A&& label)
        : coords_{static_cast<NumberType>(x), static_cast<NumberType>(y)},
          label_(std::forward<A>(label)) {}

    template <PointConcept OtherPoint>
        // requires(std::convertible_to<typename OtherPoint::Number, NumberType> && detail::can_copy_label_v<LabelType, typename OtherPoint::LabelType>)
    constexpr Point(const OtherPoint& other)
        : coords_{
              detail::convertCoordinate<NumberType>(other.x()),
              detail::convertCoordinate<NumberType>(other.y()),
          },
          label_(detail::copyLabel<LabelType>(other)) {}

    constexpr const NumberType& x() const {
        return coords_[0];
    }
    NumberType& x() {
        return coords_[0];
    }

    constexpr const NumberType& y() const {
        return coords_[1];
    }
    NumberType& y() {
        return coords_[1];
    }

    template <class A = LabelType>
        requires(detail::has_label_v<A>)
    constexpr A& label() const {
        return label_.value_;
    }

    constexpr const NumberType& operator[](std::size_t index) const {
        assert(index < size());
        return coords_[index];
    }

    NumberType& operator[](std::size_t index) {
        assert(index < size());
        return coords_[index];
    }

    static constexpr std::size_t size() {
        return 2;
    }

    constexpr const NumberType& get(std::ptrdiff_t index) const {
        const std::ptrdiff_t n = static_cast<std::ptrdiff_t>(size());
        return (*this)[static_cast<std::size_t>(((index % n) + n) % n)];
    }
    constexpr NumberType& get(std::ptrdiff_t index) {
        const std::ptrdiff_t n = static_cast<std::ptrdiff_t>(size());
        return (*this)[static_cast<std::size_t>(((index % n) + n) % n)];
    }

    constexpr std::ptrdiff_t index(const NumberType& value) const {
        for (std::ptrdiff_t i = 0; i < static_cast<std::ptrdiff_t>(size()); ++i) {
            if ((*this)[static_cast<std::size_t>(i)] == value) {
                return i;
            }
        }
        return -1;
    }

    constexpr auto begin() {
        return coords_.begin();
    }
    constexpr auto begin() const {
        return coords_.cbegin();
    }

    constexpr auto cbegin() const {
        return coords_.cbegin();
    }

    constexpr auto end() {
        return coords_.end();
    }
    constexpr auto end() const {
        return coords_.cend();
    }

    constexpr auto cend() const {
        return coords_.cend();
    }

    [[nodiscard]] constexpr Point operator-() const;

    template<PointConcept OtherPoint>
    [[nodiscard]] constexpr bool operator==(const OtherPoint& other) const;

    template<AnyShapeConcept OtherShape>
    [[nodiscard]] constexpr bool samePointSet(const OtherShape& other) const;

    template<PointConcept OtherPoint>
    [[nodiscard]] constexpr std::strong_ordering operator<=>(const OtherPoint& other) const;

    [[nodiscard]] constexpr Rectangle<Point> bbox() const;

    template <std::floating_point ResultNumber = double>
    [[nodiscard]] constexpr Rectangle<Point<ResultNumber>> fbox() const;

    [[nodiscard]] constexpr std::array<Point, 1> vertices() const;

    [[nodiscard]] constexpr Convex<Point> convexHull() const {
        return Convex<Point>(vertices());
    }

    [[nodiscard]] constexpr std::array<Segment<Point>, 0> edges() const;

    [[nodiscard]] constexpr std::array<OrientedSegment<Point>, 0> orientedEdges() const;

    template<PointConcept OtherPoint>
    [[nodiscard]] constexpr bool contains(const OtherPoint& other) const;

    template<SegmentConcept OtherSegment>
    [[nodiscard]] constexpr bool contains(const OtherSegment& other) const;

    template<OrientedSegmentConcept OtherOrientedSegment>
    [[nodiscard]] constexpr bool contains(const OtherOrientedSegment& other) const;

    template<LineConcept OtherLine>
    [[nodiscard]] constexpr bool contains(const OtherLine& other) const;

    template<OrientedLineConcept OtherOrientedLine>
    [[nodiscard]] constexpr bool contains(const OtherOrientedLine& other) const;

    template<RayConcept OtherRay>
    [[nodiscard]] constexpr bool contains(const OtherRay& other) const;

    template<HalfplaneConcept OtherHalfplane>
    [[nodiscard]] constexpr bool contains(const OtherHalfplane& other) const;

    template<RectangleConcept OtherRectangle>
    [[nodiscard]] constexpr bool contains(const OtherRectangle& other) const;

    template<TriangleConcept OtherTriangle>
    [[nodiscard]] constexpr bool contains(const OtherTriangle& other) const;

    template<ConvexConcept OtherConvex>
    [[nodiscard]] constexpr bool contains(const OtherConvex& other) const;

    template<PolygonConcept OtherPolygon>
    [[nodiscard]] constexpr bool contains(const OtherPolygon& other) const;

    template<DiskConcept OtherDisk>
    [[nodiscard]] constexpr bool contains(const OtherDisk& other) const;

    [[nodiscard]] constexpr bool contains(const Shape<Point<TNumber, TLabel>>& other) const;

    [[nodiscard]] constexpr bool boundaryContains(const Shape<Point<TNumber, TLabel>>& other) const;
 
    // The empty set is a subset of every shape, so it is contained in all of
    // them. This lets an EmptyShape flow through Shape's variant dispatch
    // without special-casing.
    template <class EmptyPoint>
    [[nodiscard]] constexpr bool contains(const EmptyShape<EmptyPoint>&) const {
        return true;
    }

    template <class EmptyPoint>
    [[nodiscard]] constexpr bool boundaryContains(const EmptyShape<EmptyPoint>&) const {
        return true;
    }

    template <class EmptyPoint>
    [[nodiscard]] constexpr bool interiorContains(const EmptyShape<EmptyPoint>&) const {
        return true;
    }

    template<PointConcept OtherPoint>
    [[nodiscard]] constexpr bool boundaryContains(const OtherPoint& other) const;

    template<SegmentConcept OtherSegment>
    [[nodiscard]] constexpr bool boundaryContains(const OtherSegment& other) const;

    template<OrientedSegmentConcept OtherOrientedSegment>
    [[nodiscard]] constexpr bool boundaryContains(const OtherOrientedSegment& other) const;

    template<LineConcept OtherLine>
    [[nodiscard]] constexpr bool boundaryContains(const OtherLine& other) const;

    template<OrientedLineConcept OtherOrientedLine>
    [[nodiscard]] constexpr bool boundaryContains(const OtherOrientedLine& other) const;

    template<RayConcept OtherRay>
    [[nodiscard]] constexpr bool boundaryContains(const OtherRay& other) const;

    template<HalfplaneConcept OtherHalfplane>
    [[nodiscard]] constexpr bool boundaryContains(const OtherHalfplane& other) const;

    template<RectangleConcept OtherRectangle>
    [[nodiscard]] constexpr bool boundaryContains(const OtherRectangle& other) const;

    template<TriangleConcept OtherTriangle>
    [[nodiscard]] constexpr bool boundaryContains(const OtherTriangle& other) const;

    template<PointConcept OtherPoint>
    [[nodiscard]] constexpr bool interiorContains(const OtherPoint& other) const;

    template<SegmentConcept OtherSegment>
    [[nodiscard]] constexpr bool interiorContains(const OtherSegment& other) const;

    template<OrientedSegmentConcept OtherOrientedSegment>
    [[nodiscard]] constexpr bool interiorContains(const OtherOrientedSegment& other) const;

    template<LineConcept OtherLine>
    [[nodiscard]] constexpr bool interiorContains(const OtherLine& other) const;

    template<OrientedLineConcept OtherOrientedLine>
    [[nodiscard]] constexpr bool interiorContains(const OtherOrientedLine& other) const;

    template<RayConcept OtherRay>
    [[nodiscard]] constexpr bool interiorContains(const OtherRay& other) const;

    template<HalfplaneConcept OtherHalfplane>
    [[nodiscard]] constexpr bool interiorContains(const OtherHalfplane& other) const;

    template<RectangleConcept OtherRectangle>
    [[nodiscard]] constexpr bool interiorContains(const OtherRectangle& other) const;

    template<TriangleConcept OtherTriangle>
    [[nodiscard]] constexpr bool interiorContains(const OtherTriangle& other) const;

    template<ConvexConcept OtherConvex>
    [[nodiscard]] constexpr bool interiorContains(const OtherConvex& other) const;

    template<PolygonConcept OtherPolygon>
    [[nodiscard]] constexpr bool interiorContains(const OtherPolygon& other) const;

    template<DiskConcept OtherDisk>
    [[nodiscard]] constexpr bool interiorContains(const OtherDisk& other) const;
 
    // --- not-yet-implemented predicate pairs (throw); see implementation ---
    template<DiskConcept OtherDisk>
    [[nodiscard]] constexpr bool boundaryContains(const OtherDisk& other) const;

    template<ConvexConcept OtherConvex>
    [[nodiscard]] constexpr bool boundaryContains(const OtherConvex& other) const;

    template<PolygonConcept OtherPolygon>
    [[nodiscard]] constexpr bool boundaryContains(const OtherPolygon& other) const;

    template<PointConcept OtherPoint>
    [[nodiscard]] constexpr bool separates(const OtherPoint& other) const;

    template<HalfplaneConcept OtherHalfplane>
    [[nodiscard]] constexpr bool separates(const OtherHalfplane& other) const;

    template<RectangleConcept OtherRectangle>
    [[nodiscard]] constexpr bool separates(const OtherRectangle& other) const;

    template<TriangleConcept OtherTriangle>
    [[nodiscard]] constexpr bool separates(const OtherTriangle& other) const;

    template<DiskConcept OtherDisk>
    [[nodiscard]] constexpr bool separates(const OtherDisk& other) const;

    template<ConvexConcept OtherConvex>
    [[nodiscard]] constexpr bool separates(const OtherConvex& other) const;

    template<PolygonConcept OtherPolygon>
    [[nodiscard]] constexpr bool separates(const OtherPolygon& other) const;

    template<MonotoneChainConcept OtherChain>
    [[nodiscard]] constexpr bool contains(const OtherChain& other) const;

    template<MonotoneChainConcept OtherChain>
    [[nodiscard]] constexpr bool boundaryContains(const OtherChain& other) const;

    template<MonotoneChainConcept OtherChain>
    [[nodiscard]] constexpr bool interiorContains(const OtherChain& other) const;

    template<MonotoneChainConcept OtherChain>
    [[nodiscard]] constexpr bool separates(const OtherChain& other) const;

    template<PolylineConcept OtherPolyline>
    [[nodiscard]] constexpr bool contains(const OtherPolyline& other) const;

    template<PolylineConcept OtherPolyline>
    [[nodiscard]] constexpr bool boundaryContains(const OtherPolyline& other) const;

    template<PolylineConcept OtherPolyline>
    [[nodiscard]] constexpr bool interiorContains(const OtherPolyline& other) const;

    template<PolylineConcept OtherPolyline>
    [[nodiscard]] constexpr bool separates(const OtherPolyline& other) const;

    template<HalfplaneIntersectionConcept OtherRegion>
    [[nodiscard]] constexpr bool contains(const OtherRegion& other) const;

    template<HalfplaneIntersectionConcept OtherRegion>
    [[nodiscard]] constexpr bool boundaryContains(const OtherRegion& other) const;

    template<HalfplaneIntersectionConcept OtherRegion>
    [[nodiscard]] constexpr bool interiorContains(const OtherRegion& other) const;

    template<HalfplaneIntersectionConcept OtherRegion>
    [[nodiscard]] constexpr bool separates(const OtherRegion& other) const;

    template<PolygonWithHolesConcept OtherRegion>
    [[nodiscard]] constexpr bool contains(const OtherRegion& other) const;

    template<PolygonWithHolesConcept OtherRegion>
    [[nodiscard]] constexpr bool boundaryContains(const OtherRegion& other) const;

    template<PolygonWithHolesConcept OtherRegion>
    [[nodiscard]] constexpr bool interiorContains(const OtherRegion& other) const;

    template<PolygonWithHolesConcept OtherRegion>
    [[nodiscard]] bool separates(const OtherRegion& other) const;
 
    // -------------------------------------------------------------------------
    // A set of regions
    //
    // It outranks every other shape, so the symmetric relations reach it through
    // the rank-based forwarders and only the asymmetric ones are answered here.
    // A set is the union of its components, so it is contained exactly when
    // every component is — no matter what this shape is.

    template<PolygonSetConcept OtherSet>
    [[nodiscard]] constexpr bool contains(const OtherSet& other) const {
        for (const auto& component : other) {
            if (!contains(component)) {
                return false;
            }
        }
        return true;
    }

    template<PolygonSetConcept OtherSet>
    [[nodiscard]] constexpr bool boundaryContains(const OtherSet& other) const {
        for (const auto& component : other) {
            if (!boundaryContains(component)) {
                return false;
            }
        }
        return true;
    }

    template<PolygonSetConcept OtherSet>
    [[nodiscard]] constexpr bool interiorContains(const OtherSet& other) const {
        for (const auto& component : other) {
            if (!interiorContains(component)) {
                return false;
            }
        }
        return true;
    }

    template<PolygonSetConcept OtherSet>
    [[nodiscard]] bool separates(const OtherSet& other) const;
 

    template<PointConcept OtherPoint>
    [[nodiscard]] constexpr bool intersects(const OtherPoint& other) const;

    [[nodiscard]] constexpr bool intersects(const Shape<Point<TNumber, TLabel>>& other) const;

    template<typename OtherShape>
        requires (!PointConcept<OtherShape> && detail::shapeRank<OtherShape> > detail::shapeRank<Point>)
    [[nodiscard]] constexpr bool intersects(const OtherShape& other) const {
        return other.intersects(*this);
    }

    template <class EmptyPoint>
    [[nodiscard]] constexpr bool intersects(const EmptyShape<EmptyPoint>&) const {
        return false;
    }

    template<PointConcept OtherPoint>
    [[nodiscard]] constexpr bool interiorsIntersect(const OtherPoint& other) const;

    [[nodiscard]] constexpr bool interiorsIntersect(const Shape<Point<TNumber, TLabel>>& other) const;

    template<typename OtherShape>
        requires (!PointConcept<OtherShape> && detail::shapeRank<OtherShape> > detail::shapeRank<Point>)
    [[nodiscard]] constexpr bool interiorsIntersect(const OtherShape& other) const {
        return other.interiorsIntersect(*this);
    }

    template <class EmptyPoint>
    [[nodiscard]] constexpr bool interiorsIntersect(const EmptyShape<EmptyPoint>&) const {
        return false;
    }

    template<SegmentConcept OtherSegment>
    [[nodiscard]] constexpr bool separates(const OtherSegment& other) const;

    template<OrientedSegmentConcept OtherOrientedSegment>
    [[nodiscard]] constexpr bool separates(const OtherOrientedSegment& other) const;

    template<LineConcept OtherLine>
    [[nodiscard]] constexpr bool separates(const OtherLine& other) const;

    template<OrientedLineConcept OtherOrientedLine>
    [[nodiscard]] constexpr bool separates(const OtherOrientedLine& other) const;

    template<RayConcept OtherRay>
    [[nodiscard]] constexpr bool separates(const OtherRay& other) const;

    template<PointConcept OtherPoint>
    [[nodiscard]] constexpr bool crosses(const OtherPoint& other) const;

    [[nodiscard]] constexpr bool crosses(const Shape<Point<TNumber, TLabel>>& other) const;

    template<typename OtherShape>
        requires (!PointConcept<OtherShape> && detail::shapeRank<OtherShape> > detail::shapeRank<Point>)
    [[nodiscard]] constexpr bool crosses(const OtherShape& other) const {
        return other.crosses(*this);
    }

    template <class EmptyPoint>
    [[nodiscard]] constexpr bool crosses(const EmptyShape<EmptyPoint>&) const {
        return false;
    }

    template <class ResultNumber = NumberType, PointConcept OtherPoint>
    [[nodiscard]] constexpr std::optional<Point<ResultNumber, LabelType>>
    intersection(const OtherPoint& other) const;

    template <class ResultNumber = NumberType, typename OtherShape>
        requires (!PointConcept<OtherShape>
                  && (detail::shapeRank<OtherShape> > detail::shapeRank<Point>)
                  && requires(const OtherShape& o, const Point& self) {
                         o.template intersection<ResultNumber>(self);
                     })
    [[nodiscard]] constexpr auto intersection(const OtherShape& other) const {
        return other.template intersection<ResultNumber>(*this);
    }

    template <class ResultNumber = NumberType, class EmptyPoint>
    [[nodiscard]] constexpr EmptyShape<EmptyPoint> intersection(const EmptyShape<EmptyPoint>&) const {
        return {};
    }

    template <class ResultNumber = NumberType, PointConcept OtherPoint>
    [[nodiscard]] constexpr auto squaredDistance(const OtherPoint& other) const;

    template <class ResultNumber = NumberType, RectangleConcept OtherRectangle>
    [[nodiscard]] constexpr auto squaredDistance(const OtherRectangle& other) const {
        return other.template squaredDistance<ResultNumber>(*this);
    }

    template <class ResultNumber = division_result_t<NumberType>, typename OtherShape>
        requires (!RectangleConcept<OtherShape>
                  && (detail::shapeRank<OtherShape> > detail::shapeRank<Point>)
                  && requires(const OtherShape& o, const Point& self) {
                         o.template squaredDistance<ResultNumber>(self);
                     })
    [[nodiscard]] constexpr auto squaredDistance(const OtherShape& other) const {
        return other.template squaredDistance<ResultNumber>(*this);
    }

    template <class ResultNumber = double, class DiskPointType, class DiskLabel>
    [[nodiscard]] detail::floating_result_t<ResultNumber> squaredDistance(const Disk<DiskPointType, DiskLabel>& disk) const {
        return disk.template squaredDistance<ResultNumber>(*this);
    }

    template <class ResultNumber = NumberType, BoundedPolygonalConcept OtherShape>
        requires detail::ClosestPairConcept<Point<TNumber, TLabel>, OtherShape>
    [[nodiscard]] constexpr auto closestSegments(const OtherShape& other) const;

    template <class ResultNumber = division_result_t<NumberType>, class OtherShape>
        requires detail::ClosestPointsPairConcept<Point<TNumber, TLabel>, OtherShape>
    [[nodiscard]] constexpr auto closestPoints(const OtherShape& other) const;

    template <class ResultNumber = NumberType, PointConcept OtherPoint>
    [[nodiscard]] constexpr auto squaredHausdorffDistance(const OtherPoint& other) const;

    template <class ResultNumber = NumberType, typename OtherShape>
        requires ((detail::shapeRank<OtherShape> > detail::shapeRank<Point>)
                  && requires(const OtherShape& o, const Point& self) {
                         o.template squaredHausdorffDistance<ResultNumber>(self);
                     })
    [[nodiscard]] constexpr auto squaredHausdorffDistance(const OtherShape& other) const {
        return other.template squaredHausdorffDistance<ResultNumber>(*this);
    }

    template <class ApproximateNumber = double, PointConcept OtherPoint>
    [[nodiscard]] ApproximateNumber distance(const OtherPoint& other) const;

    template <class ResultNumber = NumberType, PointConcept OtherPoint>
    [[nodiscard]] constexpr auto distanceL1(const OtherPoint& other) const;

    template <class ResultNumber = NumberType, RectangleConcept OtherRectangle>
    [[nodiscard]] constexpr auto distanceL1(const OtherRectangle& other) const {
        return other.template distanceL1<ResultNumber>(*this);
    }

    template <class ResultNumber = division_result_t<NumberType>, typename OtherShape>
        requires (!PointConcept<OtherShape>
                  && !RectangleConcept<OtherShape>
                  && (detail::shapeRank<OtherShape> > detail::shapeRank<Point>)
                  && requires(const OtherShape& o, const Point& self) {
                         o.template distanceL1<ResultNumber>(self);
                     })
    [[nodiscard]] constexpr auto distanceL1(const OtherShape& other) const {
        return other.template distanceL1<ResultNumber>(*this);
    }

    template <class ResultNumber = division_result_t<NumberType>, PointConcept OtherPoint>
    [[nodiscard]] constexpr auto intersection(const Shape<OtherPoint>& other) const {
        return other.template intersection<ResultNumber>(*this);
    }

    template <class ResultNumber = double, PointConcept OtherPoint>
    [[nodiscard]] constexpr auto distanceL1(const Shape<OtherPoint>& other) const {
        return other.template distanceL1<ResultNumber>(*this);
    }

    template <class ResultNumber = NumberType, PointConcept OtherPoint>
    [[nodiscard]] constexpr auto distanceLInf(const OtherPoint& other) const;

    template <class ResultNumber = NumberType, RectangleConcept OtherRectangle>
    [[nodiscard]] constexpr auto distanceLInf(const OtherRectangle& other) const {
        return other.template distanceLInf<ResultNumber>(*this);
    }

    template <class ResultNumber = division_result_t<NumberType>, typename OtherShape>
        requires (!PointConcept<OtherShape>
                  && !RectangleConcept<OtherShape>
                  && (detail::shapeRank<OtherShape> > detail::shapeRank<Point>)
                  && requires(const OtherShape& o, const Point& self) {
                         o.template distanceLInf<ResultNumber>(self);
                     })
    [[nodiscard]] constexpr auto distanceLInf(const OtherShape& other) const {
        return other.template distanceLInf<ResultNumber>(*this);
    }

    template <class ResultNumber = double, PointConcept OtherPoint>
    [[nodiscard]] constexpr auto distanceLInf(const Shape<OtherPoint>& other) const {
        return other.template distanceLInf<ResultNumber>(*this);
    }

    template <class ResultNumber = NumberType, PointConcept OtherPoint>
    [[nodiscard]] constexpr auto hausdorffDistanceL1(const OtherPoint& other) const;

    template <class ResultNumber = NumberType, typename OtherShape>
        requires (!PointConcept<OtherShape>
                  && (detail::shapeRank<OtherShape> > detail::shapeRank<Point>)
                  && requires(const OtherShape& o, const Point& self) {
                         o.template hausdorffDistanceL1<ResultNumber>(self);
                     })
    [[nodiscard]] constexpr auto hausdorffDistanceL1(const OtherShape& other) const {
        return other.template hausdorffDistanceL1<ResultNumber>(*this);
    }

    template <class ResultNumber = NumberType, PointConcept OtherPoint>
    [[nodiscard]] constexpr auto hausdorffDistanceL1(const Shape<OtherPoint>& other) const {
        return other.template hausdorffDistanceL1<ResultNumber>(*this);
    }

    template <class ResultNumber = NumberType, PointConcept OtherPoint>
    [[nodiscard]] constexpr auto hausdorffDistanceLInf(const OtherPoint& other) const;

    template <class ResultNumber = NumberType, typename OtherShape>
        requires (!PointConcept<OtherShape>
                  && (detail::shapeRank<OtherShape> > detail::shapeRank<Point>)
                  && requires(const OtherShape& o, const Point& self) {
                         o.template hausdorffDistanceLInf<ResultNumber>(self);
                     })
    [[nodiscard]] constexpr auto hausdorffDistanceLInf(const OtherShape& other) const {
        return other.template hausdorffDistanceLInf<ResultNumber>(*this);
    }

    template <class ResultNumber = NumberType, PointConcept OtherPoint>
    [[nodiscard]] constexpr auto hausdorffDistanceLInf(const Shape<OtherPoint>& other) const {
        return other.template hausdorffDistanceLInf<ResultNumber>(*this);
    }

    template <class ResultNumber = double, class DiskPointType, class DiskLabel>
    [[nodiscard]] detail::floating_result_t<ResultNumber> distanceL1(const Disk<DiskPointType, DiskLabel>& disk) const {
        return disk.template distanceL1<ResultNumber>(*this);
    }

    template <class ResultNumber = double, class DiskPointType, class DiskLabel>
    [[nodiscard]] detail::floating_result_t<ResultNumber> distanceLInf(const Disk<DiskPointType, DiskLabel>& disk) const {
        return disk.template distanceLInf<ResultNumber>(*this);
    }

    template <class OtherShape>
        requires MinkowskiSummableConcept<Point<TNumber, TLabel>, OtherShape>
    [[nodiscard]] constexpr auto minkowskiSum(const OtherShape& other) const;

    template <class OtherShape>
        requires MinkowskiSummableConcept<Point<TNumber, TLabel>, OtherShape>
    [[nodiscard]] constexpr auto minkowskiErosion(const OtherShape& other) const;

    template<PointConcept OtherPoint>
    constexpr Point& operator+=(const OtherPoint& other);

    template<PointConcept OtherPoint>
    constexpr Point& operator-=(const OtherPoint& other);

    template <class OtherNumber>
    constexpr Point& operator*=(const OtherNumber scalar);

    template <class OtherNumber>
    constexpr Point& operator/=(const OtherNumber scalar);

    constexpr Point swapped() const;

    [[nodiscard]] constexpr Point rotated90(int k = 1) const;

    constexpr void rotate90(int k = 1);

    template <class OtherNumber>
    [[nodiscard]] constexpr Point scaledUpX(const OtherNumber scalar) const;

    template <class OtherNumber>
    constexpr void scaleUpX(const OtherNumber scalar);

    template <class OtherNumber>
    [[nodiscard]] constexpr Point scaledUpY(const OtherNumber scalar) const;

    template <class OtherNumber>
    constexpr void scaleUpY(const OtherNumber scalar);

    template <class OtherNumber>
    [[nodiscard]] constexpr Point scaledDownX(const OtherNumber scalar) const;

    template <class OtherNumber>
    constexpr void scaleDownX(const OtherNumber scalar);

    template <class OtherNumber>
    [[nodiscard]] constexpr Point scaledDownY(const OtherNumber scalar) const;

    template <class OtherNumber>
    constexpr void scaleDownY(const OtherNumber scalar);

    [[nodiscard]] constexpr HalfplaneIntersection<Point<NumberType, LabelType>> asHalfplaneIntersection() const {
        return HalfplaneIntersection<Point<NumberType, LabelType>>(*this);
    }

    template<class ResultNumber = NumberType>
    constexpr Line<Point<ResultNumber, LabelType>> dual() const;

    template<class ResultNumber = division_result_t<NumberType>>
    constexpr Line<Point<ResultNumber, LabelType>> polar() const;
 
  private:
    std::array<NumberType,2> coords_{};
    [[no_unique_address]] detail::LabelStorage<LabelType> label_{};
}; // struct Point

template <class LeftNumber, class LeftLabel, class RightNumber, class RightLabel>
[[nodiscard]] constexpr auto operator-(const Point<LeftNumber, LeftLabel>& left, const Point<RightNumber, RightLabel>& right);

template <class Number, class Label, class Scalar>
    requires(!detail::is_point_v<Scalar> && !TransformationConcept<Scalar>)
[[nodiscard]] constexpr auto operator*(const Point<Number, Label>& point, const Scalar& scalar);

template <class Scalar, class Number, class Label>
    requires(!detail::is_point_v<Scalar> && !TransformationConcept<Scalar>)
[[nodiscard]] constexpr auto operator*(const Scalar& scalar, const Point<Number, Label>& point);

template <class LeftNumber, class LeftLabel, class RightNumber, class RightLabel>
[[nodiscard]] constexpr auto operator*(const Point<LeftNumber, LeftLabel>& left, const Point<RightNumber, RightLabel>& right);

template <class Number, class Label, class Scalar>
    requires(!detail::is_point_v<Scalar> && !TransformationConcept<Scalar>)
[[nodiscard]] constexpr auto operator/(const Point<Number, Label>& point, const Scalar& scalar);

template <class Number, class Label>
std::ostream& operator<<(std::ostream& stream, const Point<Number, Label>& point);
 
}//pgl