emptyshape.hpp

Go to the documentation of this file.

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

 
#include <compare>
#include <cstddef>
#include <ostream>
#include <stdexcept>
#include <type_traits>
#include <utility>
 
 
namespace pgl {

template <class PointType_ = Point<>>
struct EmptyShape {
    using PointType = PointType_;
    using NumberType = typename PointType::NumberType;
    using LabelType = typename PointType::LabelType;

    constexpr EmptyShape() = default;

    [[nodiscard]] constexpr bool operator==(const EmptyShape&) const = default;
    [[nodiscard]] constexpr auto operator<=>(const EmptyShape&) const = default;

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

    [[nodiscard]] static constexpr std::size_t size() {
        return 0;
    }

    [[nodiscard]] constexpr bool isDegenerate() const {
        return false;
    }

    [[nodiscard]] constexpr bool isUndefined() const {
        return false;
    }

    [[nodiscard]] PointType get(std::ptrdiff_t) const {
        throw std::logic_error("EmptyShape::get: the empty shape has no vertices");
    }

    [[nodiscard]] PointType operator[](std::size_t) const {
        throw std::logic_error("EmptyShape::operator[]: the empty shape has no vertices");
    }

    template <class T>
    [[nodiscard]] std::ptrdiff_t index(const T&) const {
        throw std::logic_error("EmptyShape::index: the empty shape has no vertices");
    }
 
    // The empty set is a subset of every shape, so it contains only the empty
    // set itself: containment of any non-empty shape is false, while containment
    // of another empty shape is true.
    //
    // "Another empty shape" is not only an EmptyShape. A default-constructed
    // Rectangle, Convex, Polygon, PolygonWithHoles, PolygonSet,
    // HalfplaneIntersection, MonotoneChain or Polyline is the empty set too, and
    // each answers so through `empty()` -- so the generic overloads ask, rather
    // than assuming that anything of another type covers a point. The shapes
    // that can never be empty (a Point, Segment, Line, Ray, Halfplane, Triangle
    // or Disk always cover at least one point) have no `empty()` and take the
    // constant-false branch.

    template <class T>
    [[nodiscard]] constexpr bool contains(const T& other) const {
        if constexpr (requires { other.empty(); }) {
            return other.empty();
        } else {
            return false;
        }
    }

    template <PointConcept OtherPoint>
    [[nodiscard]] constexpr bool contains(const EmptyShape<OtherPoint>&) const {
        return true;
    }

    template <class T>
    [[nodiscard]] constexpr bool boundaryContains(const T& other) const {
        // The boundary of the empty set is the empty set.
        if constexpr (requires { other.empty(); }) {
            return other.empty();
        } else {
            return false;
        }
    }

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

    template <class T>
    [[nodiscard]] constexpr bool interiorContains(const T& other) const {
        // The interior of the empty set is the empty set.
        if constexpr (requires { other.empty(); }) {
            return other.empty();
        } else {
            return false;
        }
    }

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

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

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

    template <class T>
    [[nodiscard]] constexpr bool separates(const T&) const {
        return false;
    }

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

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

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

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

    template <PointConcept OtherPoint>
    constexpr EmptyShape& operator+=(const OtherPoint&) {
        return *this;
    }

    template <PointConcept OtherPoint>
    constexpr EmptyShape& operator-=(const OtherPoint&) {
        return *this;
    }

    template <class Scalar>
        requires(!detail::is_point_v<Scalar> && !TransformationConcept<Scalar>)
    constexpr EmptyShape& operator*=(const Scalar&) {
        return *this;
    }

    template <class Scalar>
        requires(!detail::is_point_v<Scalar> && !TransformationConcept<Scalar>)
    constexpr EmptyShape& operator/=(const Scalar&) {
        return *this;
    }

    [[nodiscard]] constexpr EmptyShape rotated90(int = 1) const {
        return *this;
    }

    constexpr void rotate90(int = 1) {}

    template <class OtherNumber>
    [[nodiscard]] constexpr EmptyShape scaledUpX(const OtherNumber) const {
        return *this;
    }

    template <class OtherNumber>
    constexpr void scaleUpX(const OtherNumber) {}

    template <class OtherNumber>
    [[nodiscard]] constexpr EmptyShape scaledUpY(const OtherNumber) const {
        return *this;
    }

    template <class OtherNumber>
    constexpr void scaleUpY(const OtherNumber) {}

    template <class OtherNumber>
    [[nodiscard]] constexpr EmptyShape scaledDownX(const OtherNumber) const {
        return *this;
    }

    template <class OtherNumber>
    constexpr void scaleDownX(const OtherNumber) {}

    template <class OtherNumber>
    [[nodiscard]] constexpr EmptyShape scaledDownY(const OtherNumber) const {
        return *this;
    }

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

template <class PointType, class TranslationNumber, class TranslationLabel>
constexpr auto operator-(const EmptyShape<PointType>&,
                         const Point<TranslationNumber, TranslationLabel>&) {
    using ResultPoint = std::decay_t<decltype(std::declval<const PointType&>() -
                                              std::declval<const Point<TranslationNumber, TranslationLabel>&>())>;
    return EmptyShape<ResultPoint>{};
}

template <class PointType, class Scalar>
    requires(!detail::is_point_v<Scalar> && !TransformationConcept<Scalar>)
constexpr auto operator*(const EmptyShape<PointType>&, const Scalar&) {
    using ResultPoint = std::decay_t<decltype(std::declval<const PointType&>() *
                                              std::declval<const Scalar&>())>;
    return EmptyShape<ResultPoint>{};
}

template <class Scalar, class PointType>
    requires(!detail::is_point_v<Scalar> && !TransformationConcept<Scalar>)
constexpr auto operator*(const Scalar& scalar, const EmptyShape<PointType>& empty) {
    return empty * scalar;
}

template <class PointType, class Scalar>
    requires(!detail::is_point_v<Scalar> && !TransformationConcept<Scalar>)
constexpr auto operator/(const EmptyShape<PointType>&, const Scalar&) {
    using ResultPoint = std::decay_t<decltype(std::declval<const PointType&>() /
                                              std::declval<const Scalar&>())>;
    return EmptyShape<ResultPoint>{};
}

template <class PointType>
std::ostream& operator<<(std::ostream& stream, const EmptyShape<PointType>&) {
    return stream << "EmptyShape()";
}
 
}  // namespace pgl