rectangle.hpp

Go to the documentation of this file.

#pragma once
 
#include "shape/ray.hpp"

 
#include <array>
#include <cassert>
#include <concepts>
#include <cstddef>
#include <iterator>
#include <ostream>
#include <ranges>
#include <stdexcept>
#include <type_traits>
#include <optional>
#include <vector>
#include <utility>
#include <variant>
 
 
namespace pgl {
 
namespace detail {
 
template <std::floating_point ResultNumber, class Value>
constexpr ResultNumber lowerFloatingBound(const Value& value) {
    if constexpr (requires { value.template lowerBound<ResultNumber>(); }) {
        return value.template lowerBound<ResultNumber>();
    } else {
        return static_cast<ResultNumber>(value);
    }
}
 
template <std::floating_point ResultNumber, class Value>
constexpr ResultNumber upperFloatingBound(const Value& value) {
    if constexpr (requires { value.template upperBound<ResultNumber>(); }) {
        return value.template upperBound<ResultNumber>();
    } else {
        return static_cast<ResultNumber>(value);
    }
}
 
}  // namespace detail
 
template <class PointType = Point<>, class Label>
struct Rectangle;
 
Rectangle() -> Rectangle<Point<>, NoLabel>;
 
template <class PointType>
Rectangle(PointType, PointType) -> Rectangle<PointType, NoLabel>;
 
template <class Number>
Rectangle(Number, Number, Number, Number) -> Rectangle<Point<Number>, NoLabel>;
 
template <std::ranges::input_range Range>
    requires detail::is_point_v<std::ranges::range_value_t<Range>>
Rectangle(Range&&) -> Rectangle<std::remove_cvref_t<std::ranges::range_value_t<Range>>, NoLabel>;

template <class PointType_, class TLabel>
struct Rectangle {
    using PointType = PointType_;
    using NumberType = PointType::NumberType;
    using LabelType = TLabel;
 
    static_assert(detail::is_point_v<PointType>, "Rectangle requires pgl::Point corners");

    template <bool Oriented>
    using BoundaryType = std::conditional_t<Oriented, OrientedSegment<PointType>, Segment<PointType>>;

    template <bool Oriented>
    class BoundaryIterator;

    class CornerIterator;

    using value_type = PointType;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using reference = PointType;
    using const_reference = PointType;
    using iterator = CornerIterator;
    using const_iterator = CornerIterator;
 
    using EdgeIterator = BoundaryIterator<false>;
    using OrientedEdgeIterator = BoundaryIterator<true>;

    constexpr Rectangle() : points_(emptyCorners()) {}

    constexpr Rectangle(PointType first, PointType second, bool minmax = false) {
        if (minmax) {
            if (second.x() < first.x() || second.y() < first.y()) {
                points_ = emptyCorners();
                return;
            }
            points_[0] = std::move(first);
            points_[1] = std::move(second);
            return;
        }
 
        const NumberType min_x = second.x() < first.x() ? second.x() : first.x();
        const NumberType min_y = second.y() < first.y() ? second.y() : first.y();
        const NumberType max_x = first.x() < second.x() ? second.x() : first.x();
        const NumberType max_y = first.y() < second.y() ? second.y() : first.y();
 
        const PointType normalized_min = makeCorner(min_x, min_y);
        const PointType normalized_max = makeCorner(max_x, max_y);
 
        if (first == normalized_min && second == normalized_max) {
            points_[0] = std::move(first);
            points_[1] = std::move(second);
            return;
        }
 
        if (second == normalized_min && first == normalized_max) {
            points_[0] = std::move(second);
            points_[1] = std::move(first);
            return;
        }
 
        points_[0] = normalized_min;
        points_[1] = normalized_max;
    }

    constexpr Rectangle(NumberType x1, NumberType y1, NumberType x2, NumberType y2, bool minmax = false)
        : Rectangle(PointType(x1, y1), PointType(x2, y2), minmax) {}
 
    template<PointConcept OtherPointType, class OtherLabelType>
        requires(std::constructible_from<PointType, const OtherPointType&>)
    constexpr Rectangle(const Rectangle<OtherPointType, OtherLabelType>& other)
        : Rectangle(PointType(other.min()), PointType(other.max()), true) {
        label_ = detail::copyLabel<LabelType>(other);
    }

    template<PointConcept OtherPointType, class OtherLabelType>
        requires(std::constructible_from<PointType, const OtherPointType&>)
    constexpr Rectangle& operator=(const Rectangle<OtherPointType, OtherLabelType>& other) {
        points_[0] = PointType(other.min());
        points_[1] = PointType(other.max());
        label_ = detail::copyLabel<LabelType>(other);
        return *this;
    }

    template<std::ranges::input_range Range = std::initializer_list<PointType>>
    requires std::ranges::common_range<Range> &&
             std::convertible_to<std::ranges::range_value_t<Range>, PointType>
    constexpr explicit Rectangle(Range&& points) : Rectangle() {
        for(const auto &p : points) {
            insert(p);
        }
    }
 

    template <std::ranges::input_range Range>
        requires(!detail::is_point_v<typename std::ranges::range_value_t<Range>> && requires(const typename std::ranges::range_value_t<Range>& shape) { shape.bbox(); })
    constexpr explicit Rectangle(Range&& shapes) : Rectangle() {
        for(const auto &s : shapes) {
            insert(s);
        }
    }

    constexpr PointType operator[](std::size_t index) const {
        assert(index < size());
        switch (index) {
            case 0: return min();
            case 1: return bottomRight();
            case 2: return max();
            default: return topLeft();
        }
    }

    [[nodiscard]] constexpr bool empty() const {
        if constexpr (is_Rational_v<NumberType>) {
            // Ordering two rationals cross-multiplies, and on an unreduced pair
            // it reduces first, so the one comparison costs a gcd and two
            // heap-capable products. Against an integer none of that happens:
            // `== 0` is the sign of the numerator and `== -1` is the numerator
            // against `-den`. The zero test leads because it is the cheaper of
            // the two and it is the one every non-empty rectangle pays for.
            return points_[0].x() == 0 && points_[1].x() == -1;
        } else {
            return points_[1].x() < points_[0].x();
        }
    }

    [[nodiscard]] constexpr std::size_t size() const {
        return empty() ? 0 : 4;
    }

    constexpr PointType get(std::ptrdiff_t index) const {
        assert(!empty());
        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 PointType& point) const {
        for (std::ptrdiff_t i = 0; i < static_cast<std::ptrdiff_t>(size()); ++i) {
            if ((*this)[static_cast<std::size_t>(i)] == point) {
                return i;
            }
        }
        return -1;
    }

    constexpr const PointType& min() const {
        return points_[0];
    }

    constexpr const PointType& max() const {
        return points_[1];
    }

    [[nodiscard]] constexpr auto width() const {
        using Result = decltype(max().x() - min().x());
        return empty() ? Result(0) : Result(max().x() - min().x());
    }

    [[nodiscard]] constexpr auto height() const {
        using Result = decltype(max().y() - min().y());
        return empty() ? Result(0) : Result(max().y() - min().y());
    }

    class CornerIterator {
      public:
        using iterator_category = std::forward_iterator_tag;
        using value_type = PointType;
        using difference_type = std::ptrdiff_t;
        using pointer = void;
        using reference = PointType;
 
        constexpr CornerIterator() = default;
        constexpr CornerIterator(const Rectangle* rect, std::size_t index)
            : rect_(rect), index_(index) {}
 
        constexpr PointType operator*() const {
            return (*rect_)[index_];
        }
        constexpr CornerIterator& operator++() {
            ++index_;
            return *this;
        }
        constexpr CornerIterator operator++(int) {
            CornerIterator tmp = *this;
            ++index_;
            return tmp;
        }
        constexpr bool operator==(const CornerIterator&) const = default;
 
      private:
        const Rectangle* rect_ = nullptr;
        std::size_t index_ = 0;
    };

    constexpr CornerIterator begin() const {
        return CornerIterator(this, 0);
    }

    constexpr CornerIterator cbegin() const {
        return CornerIterator(this, 0);
    }

    constexpr CornerIterator end() const {
        return CornerIterator(this, size());
    }

    constexpr CornerIterator cend() const {
        return CornerIterator(this, size());
    }

    constexpr EdgeIterator edgesBegin() const {
        return EdgeIterator(this, 0);
    }

    constexpr EdgeIterator edgesEnd() const {
        return EdgeIterator(this, size());
    }

    constexpr OrientedEdgeIterator orientedEdgesBegin() const {
        return OrientedEdgeIterator(this, 0);
    }

    constexpr OrientedEdgeIterator orientedEdgesEnd() const {
        return OrientedEdgeIterator(this, size());
    }

    constexpr bool operator==(const Rectangle& other) const {
        return points_ == other.points_;
    }

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

    constexpr auto operator<=>(const Rectangle& other) const {
        return points_ <=> other.points_;
    }

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

    template <class ResultNumber = NumberType>
    [[nodiscard]] constexpr ResultNumber area() const;

    [[nodiscard]] constexpr auto twiceArea() const;

    [[nodiscard]] constexpr bool isDegenerate() const;

    [[nodiscard]] constexpr bool isPoint() const;

    [[nodiscard]] constexpr std::optional<PointType> getIfPoint() const;

    [[nodiscard]] constexpr bool isSegment() const;

    [[nodiscard]] constexpr std::optional<BoundaryType<false>> getIfSegment() const;

    [[nodiscard]] constexpr bool isUndefined() const;

    [[nodiscard]] constexpr Rectangle bbox() const;

    template <class ResultNumber = grid_number_t<typename PointType_::NumberType>>
        requires(detail::extended_integral<ResultNumber> || std::same_as<ResultNumber, BigInt>)
    [[nodiscard]] std::vector<Point<ResultNumber, typename PointType::LabelType>>
    latticePoints() const;

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

    [[nodiscard]] constexpr std::array<PointType, 4> vertices() const;

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

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

    [[nodiscard]] constexpr explicit operator Convex<PointType>() const {
        if (empty()) {
            return Convex<PointType>();
        }
        return Convex<PointType>(*this, !isDegenerate());
    }

    [[nodiscard]] constexpr Convex<PointType> asConvex() const {
        return static_cast<Convex<PointType>>(*this);
    }

    [[nodiscard]] constexpr Convex<PointType> convexHull() const {
        return asConvex();
    }

    [[nodiscard]] constexpr HalfplaneIntersection<PointType> asHalfplaneIntersection() const {
        return HalfplaneIntersection<PointType>(*this);
    }

    [[nodiscard]] constexpr explicit operator Polygon<PointType>() const {
        if (empty()) {
            return Polygon<PointType>();
        }
        return Polygon<PointType>(*this, !isDegenerate());
    }

    [[nodiscard]] constexpr Polygon<PointType> asPolygon() const {
        return static_cast<Polygon<PointType>>(*this);
    }

    [[nodiscard]] constexpr PolygonWithHoles<PointType> asPolygonWithHoles() const {
        return PolygonWithHoles<PointType>(asPolygon());
    }

    [[nodiscard]] constexpr PolygonSet<PointType> asPolygonSet() const {
        return PolygonSet<PointType>(asPolygonWithHoles());
    }

    template<PointConcept OtherPoint>
    [[nodiscard]] constexpr bool verticesContain(const OtherPoint& point) const;

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

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

    template<OrientedLineConcept OtherOrientedLine>
    [[nodiscard]] constexpr bool contains(const OtherOrientedLine& 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<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<PointType>& other) const;

    [[nodiscard]] constexpr bool boundaryContains(const Shape<PointType>& other) const;
 
    // The empty set is a subset of every shape (contained in all of them) and
    // disjoint from all of them, so containment is true while separation is
    // false. These overloads let 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 <class EmptyPoint>
    [[nodiscard]] constexpr bool separates(const EmptyShape<EmptyPoint>&) const {
        return false;
    }

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

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

    template<OrientedLineConcept OtherOrientedLine>
    [[nodiscard]] constexpr bool interiorContains(const OtherOrientedLine& 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<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<PointConcept OtherPoint>
    [[nodiscard]] constexpr bool boundaryContains(const OtherPoint& point) 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<ConvexConcept OtherConvex>
    [[nodiscard]] constexpr bool boundaryContains(const OtherConvex& other) const;

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

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

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

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

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

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

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

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

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

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

    [[nodiscard]] constexpr bool intersects(const Shape<PointType>& other) const;

    template<typename OtherShape>
        requires (!PointConcept<OtherShape> && detail::shapeRank<OtherShape> > detail::shapeRank<Rectangle>)
    [[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;

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

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

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

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

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

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

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

    template<typename OtherShape>
        requires (!PointConcept<OtherShape> && detail::shapeRank<OtherShape> > detail::shapeRank<Rectangle>)
    [[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;
    }

    [[nodiscard]] constexpr bool interiorsIntersect(const Shape<PointType>& other) const;

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

    template<PointConcept OtherPoint>
    [[nodiscard]] constexpr bool separates(const OtherPoint& 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<SegmentConcept OtherSegment>
    [[nodiscard]] constexpr bool separates(const OtherSegment& other) const;

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

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

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

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

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

    template<DiskConcept OtherDisk>
    [[nodiscard]] constexpr bool separates(const OtherDisk& 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;

    [[nodiscard]] constexpr bool separates(const Shape<PointType>& other) const;
 
    // --- not-yet-implemented predicate pairs (throw); see implementation ---
    template<DiskConcept OtherDisk>
    [[nodiscard]] constexpr bool interiorContains(const OtherDisk& 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<RectangleConcept OtherRectangle>
    [[nodiscard]] constexpr bool crosses(const OtherRectangle& other) const;

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

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

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

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

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

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

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

    template<typename OtherShape>
        requires (!PointConcept<OtherShape> && detail::shapeRank<OtherShape> > detail::shapeRank<Rectangle>)
    [[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;
    }

    [[nodiscard]] constexpr bool crosses(const Shape<PointType>& other) const;

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

    template <class ResultNumber = NumberType, RectangleConcept OtherRectangle>
    [[nodiscard]] constexpr std::optional<Rectangle<Point<ResultNumber, typename PointType::LabelType>>>
    intersection(const OtherRectangle& other) const;

    template <class ResultNumber = division_result_t<NumberType>, LineConcept OtherLine>
    [[nodiscard]] constexpr std::optional<std::variant<Point<ResultNumber, typename PointType::LabelType>, Segment<Point<ResultNumber, typename PointType::LabelType>>>>
    intersection(const OtherLine& other) const;

    template <class ResultNumber = division_result_t<NumberType>, OrientedLineConcept OtherOrientedLine>
    [[nodiscard]] constexpr std::optional<std::variant<Point<ResultNumber, typename PointType::LabelType>, Segment<Point<ResultNumber, typename PointType::LabelType>>>>
    intersection(const OtherOrientedLine& other) const;

    template <class ResultNumber = division_result_t<NumberType>, SegmentConcept OtherSegment>
    [[nodiscard]] constexpr std::optional<std::variant<Point<ResultNumber, typename PointType::LabelType>, Segment<Point<ResultNumber, typename PointType::LabelType>>>>
    intersection(const OtherSegment& other) const;

    template <class ResultNumber = division_result_t<NumberType>, OrientedSegmentConcept OtherOrientedSegment>
    [[nodiscard]] constexpr std::optional<std::variant<Point<ResultNumber, typename PointType::LabelType>, Segment<Point<ResultNumber, typename PointType::LabelType>>>>
    intersection(const OtherOrientedSegment& other) const;

    template <class ResultNumber = division_result_t<NumberType>, RayConcept OtherRay>
    [[nodiscard]] constexpr std::optional<std::variant<Point<ResultNumber, typename PointType::LabelType>, Segment<Point<ResultNumber, typename PointType::LabelType>>>>
    intersection(const OtherRay& other) const;

    template <class ResultNumber = division_result_t<NumberType>, HalfplaneConcept OtherHalfplane>
    [[nodiscard]] constexpr auto intersection(const OtherHalfplane& other) const;

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

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

    template <class ResultNumber = division_result_t<NumberType>, typename OtherShape>
        requires (!PointConcept<OtherShape>
                  && (detail::shapeRank<OtherShape> > detail::shapeRank<Rectangle>)
                  && requires(const OtherShape& o, const Rectangle& self) {
                         o.template regularizedIntersection<ResultNumber>(self);
                     })
    [[nodiscard]] constexpr auto regularizedIntersection(const OtherShape& other) const {
        return other.template regularizedIntersection<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& point) const;

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

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

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

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

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

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

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

    template <class ResultNumber = division_result_t<NumberType>, typename OtherShape>
        requires ((detail::shapeRank<OtherShape> > detail::shapeRank<Rectangle>)
                  && requires(const OtherShape& o, const Rectangle& 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<Rectangle<PointType_, TLabel>, OtherShape>
    [[nodiscard]] constexpr auto closestSegments(const OtherShape& other) const;

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

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

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

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

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

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

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

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

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

    template <class ResultNumber = division_result_t<NumberType>, typename OtherShape>
        requires ((detail::shapeRank<OtherShape> > detail::shapeRank<Rectangle>)
                  && requires(const OtherShape& o, const Rectangle& 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 = division_result_t<NumberType>, PointConcept OtherPoint>
    [[nodiscard]] auto regularizedIntersection(const Shape<OtherPoint>& other) const {
        return other.template regularizedIntersection<ResultNumber>(*this);
    }

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

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

    template <class ResultNumber = division_result_t<NumberType>, PointConcept OtherPoint>
    [[nodiscard]] auto symmetricDifference(const Shape<OtherPoint>& other) const {
        return other.template symmetricDifference<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& point) const;

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

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

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

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

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

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

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

    template <class ResultNumber = division_result_t<NumberType>, typename OtherShape>
        requires ((detail::shapeRank<OtherShape> > detail::shapeRank<Rectangle>)
                  && requires(const OtherShape& o, const Rectangle& 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, RectangleConcept OtherRectangle>
    [[nodiscard]] constexpr auto hausdorffDistanceL1(const OtherRectangle& other) const;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    template <PointConcept OtherPoint>
    constexpr void insert(const OtherPoint& point);

    template <RectangleConcept OtherRectangle>
    constexpr void insert(const OtherRectangle& other);

    template <class TShape>
        requires(!detail::is_point_v<TShape> && !RectangleConcept<TShape> && requires(const TShape& shape) { shape.bbox(); })
    constexpr void insert(const TShape& shape);

    template<std::ranges::input_range Range = std::initializer_list<PointType>>
    requires std::ranges::common_range<Range> &&
             std::convertible_to<std::ranges::range_value_t<Range>, PointType> &&
             (!requires(const std::remove_cvref_t<Range>& shape) { shape.bbox(); })
    constexpr void insert(Range&& range) {
        // Defined inline so MSVC can match the constrained overload; the
        // overloaded out-of-line form trips MSVC's C2244.
        for (const auto& point : range) {
            insert(point);
        }
    }

    template <std::ranges::input_range Range>
        requires(!detail::is_point_v<typename std::ranges::range_value_t<Range>> && requires(const typename std::ranges::range_value_t<Range>& shape) { shape.bbox(); })
    constexpr void insert(Range&& range) {
        // Defined inline so MSVC can match the constrained overload; the
        // overloaded out-of-line form trips MSVC's C2244.
        for (const auto& shape : range) {
            insert(shape);
        }
    }

    [[nodiscard]] constexpr Segment<PointType> diameter() const;

    template <class ResultNumber = division_result_t<NumberType>>
    [[nodiscard]] constexpr Point<ResultNumber> midpoint() const;

    template <class ResultNumber = division_result_t<NumberType>>
    [[nodiscard]] constexpr Point<ResultNumber> centroid() const;

    [[nodiscard]] constexpr Disk<PointType, NoLabel> circumcircle() const;

    template <class ResultNumber = division_result_t<NumberType>>
    [[nodiscard]] constexpr Point<ResultNumber> center() const;

    template <class ResultNumber = division_result_t<NumberType>>
    [[nodiscard]] constexpr Point<ResultNumber> pointInside() const;

    template <class OtherShape>
    [[nodiscard]] constexpr bool pointInsideInteriorContainedIn(const OtherShape& shape) const;

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

    constexpr void rotate90(int k = 1);

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

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

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

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

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

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

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

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

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

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

    template <class OtherShape>
        requires (!MinkowskiSummableConcept<Rectangle<PointType_, TLabel>, OtherShape> &&
                  BoundedPolygonalConcept<OtherShape>)
    [[nodiscard]] constexpr auto minkowskiErosion(const OtherShape& other) const;

    template <class ResultNumber = division_result_t<NumberType>, typename OtherShape>
        requires (!MinkowskiSummableConcept<Rectangle<PointType_, TLabel>, OtherShape>
                  && (detail::shapeRank<OtherShape> > detail::shapeRank<Rectangle>)
                  && requires(const OtherShape& o, const Rectangle& self) {
                         o.template minkowskiSum<ResultNumber>(self);
                     })
    [[nodiscard]] auto minkowskiSum(const OtherShape& other) const {
        return other.template minkowskiSum<ResultNumber>(*this);
    }

    template <class ResultNumber = division_result_t<NumberType>, RectangleConcept OtherRectangle>
    [[nodiscard]] PolygonSet<Point<ResultNumber, typename PointType::LabelType>>
    regularizedUnion(const OtherRectangle& other) const;

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

    template <class ResultNumber = division_result_t<NumberType>, PolygonalRegionConcept OtherRegion>
    [[nodiscard]] PolygonSet<Point<ResultNumber, typename PointType::LabelType>>
    difference(const OtherRegion& other) const;

    template <class ResultNumber = division_result_t<NumberType>, HalfplaneIntersectionConcept OtherIntersection>
    [[nodiscard]] PolygonSet<Point<ResultNumber, typename PointType::LabelType>>
    difference(const OtherIntersection& other) const;

    template <class ResultNumber = division_result_t<NumberType>, HalfplaneConcept OtherHalfplane>
    [[nodiscard]] PolygonSet<Point<ResultNumber, typename PointType::LabelType>>
    difference(const OtherHalfplane& other) const;

    template <class ResultNumber = division_result_t<NumberType>, RectangleConcept OtherRectangle>
    [[nodiscard]] PolygonSet<Point<ResultNumber, typename PointType::LabelType>>
    symmetricDifference(const OtherRectangle& other) const;

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

    template<PointConcept OtherPoint>
    constexpr Rectangle& operator+=(const OtherPoint& translation);

    template<PointConcept OtherPoint>
    constexpr Rectangle& operator-=(const OtherPoint& translation);

    template <class Scalar>
        requires(!detail::is_point_v<Scalar> && !TransformationConcept<Scalar>)
    constexpr Rectangle& operator*=(const Scalar& scalar);

    template <class Scalar>
        requires(!detail::is_point_v<Scalar> && !TransformationConcept<Scalar>)
    constexpr Rectangle& operator/=(const Scalar& scalar);
 
    template <bool Oriented>
    class BoundaryIterator {
      public:
        using iterator_category = std::forward_iterator_tag;
        using iterator_concept = std::forward_iterator_tag;
        using value_type = BoundaryType<Oriented>;
        using difference_type = std::ptrdiff_t;
        using reference = value_type;
 
        constexpr BoundaryIterator() = default;
 
        constexpr value_type operator*() const {
            assert(rectangle != nullptr);
            return rectangle->template boundaryAt<Oriented>(index);
        }
 
        constexpr BoundaryIterator& operator++() {
            ++index;
            return *this;
        }
 
        constexpr BoundaryIterator operator++(int) {
            BoundaryIterator copy(*this);
            ++(*this);
            return copy;
        }
 
        constexpr bool operator==(const BoundaryIterator& other) const = default;
 
      private:
        friend struct Rectangle;
 
        constexpr BoundaryIterator(const Rectangle* rectangle_arg, std::size_t index_arg)
            : rectangle(rectangle_arg), index(index_arg) {}
 
        const Rectangle* rectangle = nullptr;
        std::size_t index = 0;
    };
 
  private:
    static constexpr std::size_t edgeCount = 4;
 
    static constexpr PointType makeCorner(const NumberType& x, const NumberType& y) {
        return Point<NumberType, typename PointType::LabelType>(x, y, typename PointType::LabelType{});
    }

    static constexpr std::array<PointType, 2> emptyCorners() {
        return {makeCorner(NumberType(0), NumberType(0)),
                makeCorner(NumberType(-1), NumberType(-1))};
    }

    constexpr PointType bottomRight() const;

    constexpr PointType topLeft() const;

    template <bool Oriented>
    constexpr BoundaryType<Oriented> boundaryAt(std::size_t index) const;
 
    template <class Left, class Right>
    static constexpr bool intervalsOverlap(const Left& first_min, const Left& first_max, const Right& second_min, const Right& second_max);
 
    template <class Left, class Right>
    static constexpr bool intervalsOverlapStrict(const Left& first_min, const Left& first_max, const Right& second_min, const Right& second_max);
 
    template <class Left, class Right>
    static constexpr auto axisDistance(const Left& first_min, const Left& first_max, const Right& second_min, const Right& second_max)
        -> std::common_type_t<Left, Right>;
 
    // template <std::ranges::input_range Range>
    //     requires std::constructible_from<PointType, std::ranges::range_reference_t<Range>>
    // constexpr void assignBoundingBox(Range&& points);
 
    std::array<PointType, 2> points_{};
    [[no_unique_address]] mutable LabelType label_{};
};

template <class PointType, class LabelType, class TranslationNumber, class TranslationLabel>
constexpr auto operator-(const Rectangle<PointType, LabelType>& rectangle, const Point<TranslationNumber, TranslationLabel>& translation);

template <class PointType, class LabelType, class Scalar>
    requires(!detail::is_point_v<Scalar> && !TransformationConcept<Scalar>)
constexpr auto operator*(const Rectangle<PointType, LabelType>& rectangle, const Scalar& scalar);

template <class Scalar, class PointType, class LabelType>
    requires(!detail::is_point_v<Scalar> && !TransformationConcept<Scalar>)
constexpr auto operator*(const Scalar& scalar, const Rectangle<PointType, LabelType>& rectangle);

template <class PointType, class LabelType, class Scalar>
    requires(!detail::is_point_v<Scalar> && !TransformationConcept<Scalar>)
constexpr auto operator/(const Rectangle<PointType, LabelType>& rectangle, const Scalar& scalar);

template <class PointType, class LabelType>
std::ostream& operator<<(std::ostream& stream, const Rectangle<PointType, LabelType>& rectangle);
 
}  // namespace pgl