line_segment.hpp

 
#ifndef UFO_GEOMETRY_LINE_SEGMENT_HPP
#define UFO_GEOMETRY_LINE_SEGMENT_HPP
 
// UFO
#include <ufo/geometry/aabb.hpp>
#include <ufo/numeric/vec.hpp>
 
// STL
#include <concepts>
#include <cstddef>
#include <format>
#include <ostream>
 
namespace ufo
{
template <std::size_t Dim = 3, std::floating_point T = float>
struct LineSegment {
    using value_type = T;
 
    Vec<Dim, T> start;
 
    Vec<Dim, T> end;
 
    constexpr LineSegment() noexcept = default;
 
    constexpr LineSegment(Vec<Dim, T> const& start, Vec<Dim, T> const& end) noexcept
        : start(start), end(end)
    {
    }
 
    constexpr LineSegment(LineSegment const&) noexcept = default;
 
    template <std::convertible_to<T> U>
    constexpr explicit LineSegment(LineSegment<Dim, U> const& other) noexcept
        : start(Vec<Dim, T>(other.start)), end(Vec<Dim, T>(other.end))
    {
    }
 
    [[nodiscard]] static constexpr std::size_t dimension() noexcept { return Dim; }
 
    [[nodiscard]] constexpr T length() const noexcept { return norm(end - start); }
 
    [[nodiscard]] constexpr Vec<Dim, T> at(T t) const noexcept
    {
        return start + t * (end - start);
    }
 
    [[nodiscard]] constexpr Vec<Dim, T> center() const noexcept
    {
        return (start + end) * T(0.5);
    }
 
    [[nodiscard]] constexpr T diameter() const noexcept { return length(); }
 
    [[nodiscard]] constexpr bool isDegenerate(
        T eps = std::numeric_limits<T>::epsilon()) const noexcept
    {
        return length() <= eps;
    }
 
    [[nodiscard]] constexpr AABB<Dim, T> aabb() const noexcept
    {
        return AABB<Dim, T>(ufo::min(start, end), ufo::max(start, end));
    }
 
    [[nodiscard]] constexpr T volume() const noexcept { return T(0); }
 
    [[nodiscard]] bool operator==(LineSegment const&) const = default;
};
 
//
// Deduction guides
//
 
template <std::size_t Dim, std::floating_point T>
LineSegment(Vec<Dim, T>, Vec<Dim, T>) -> LineSegment<Dim, T>;
 
template <std::size_t Dim, std::floating_point T>
std::ostream& operator<<(std::ostream& out, LineSegment<Dim, T> const& ls)
{
    return out << "Start: [" << ls.start << "], End: [" << ls.end << "]";
}
 
template <std::floating_point T>
using LineSegment1 = LineSegment<1, T>;
template <std::floating_point T>
using LineSegment2 = LineSegment<2, T>;
template <std::floating_point T>
using LineSegment3 = LineSegment<3, T>;
template <std::floating_point T>
using LineSegment4 = LineSegment<4, T>;
 
using LineSegment1f = LineSegment<1, float>;
using LineSegment2f = LineSegment<2, float>;
using LineSegment3f = LineSegment<3, float>;
using LineSegment4f = LineSegment<4, float>;
 
using LineSegment1d = LineSegment<1, double>;
using LineSegment2d = LineSegment<2, double>;
using LineSegment3d = LineSegment<3, double>;
using LineSegment4d = LineSegment<4, double>;
 
}  // namespace ufo
 
template <std::size_t Dim, std::floating_point T>
  requires std::formattable<T, char>
struct std::formatter<ufo::LineSegment<Dim, T>> {
    constexpr auto parse(std::format_parse_context& ctx) { return ctx.begin(); }
 
    auto format(ufo::LineSegment<Dim, T> const& ls, std::format_context& ctx) const
    {
        return std::format_to(ctx.out(), "Start: [{}], End: [{}]", ls.start, ls.end);
    }
};
 
#endif  // UFO_GEOMETRY_LINE_SEGMENT_HPP