cylinder.hpp

 
#ifndef UFO_GEOMETRY_CYLINDER_HPP
#define UFO_GEOMETRY_CYLINDER_HPP
 
// UFO
#include <ufo/geometry/aabb.hpp>
#include <ufo/numeric/vec.hpp>
 
// STL
#include <concepts>
#include <cstddef>
#include <format>
#include <numbers>
#include <ostream>
 
namespace ufo
{
template <std::size_t Dim = 3, std::floating_point T = float>
struct Cylinder {
    using value_type = T;
 
    Vec<Dim, T> start;
 
    Vec<Dim, T> end;
 
    T radius{};
 
    constexpr Cylinder() noexcept = default;
 
    constexpr Cylinder(Vec<Dim, T> start, Vec<Dim, T> end, T radius) noexcept
        : start(start), end(end), radius(radius)
    {
    }
 
    constexpr Cylinder(Cylinder const&) noexcept = default;
 
    template <std::convertible_to<T> U>
    constexpr explicit Cylinder(Cylinder<Dim, U> const& other) noexcept
        : start(Vec<Dim, T>(other.start))
        , end(Vec<Dim, T>(other.end))
        , radius(static_cast<T>(other.radius))
    {
    }
 
    [[nodiscard]] static constexpr std::size_t dimension() noexcept { return Dim; }
 
    [[nodiscard]] constexpr Vec<Dim, T> center() const noexcept
    {
        return (start + end) * T(0.5);
    }
 
    [[nodiscard]] constexpr T diameter() const noexcept
    {
        return std::max(radius * T(2), length());
    }
 
    [[nodiscard]] constexpr Vec<Dim, T> at(T t) const noexcept
    {
        return start + t * (end - start);
    }
 
    [[nodiscard]] constexpr T length() const noexcept { return ufo::length(end - start); }
 
    [[nodiscard]] constexpr AABB<Dim, T> aabb() const noexcept
    {
        Vec<Dim, T> axis   = end - start;
        T           length = ufo::length(axis);
        if (length < std::numeric_limits<T>::epsilon()) {
            return AABB<Dim, T>(start, radius);
        }
        axis /= length;
        Vec<Dim, T> min_ext;
        Vec<Dim, T> max_ext;
        for (std::size_t i = 0; i < Dim; ++i) {
            T s        = std::sqrt(std::max(T(0), T(1) - axis[i] * axis[i]));
            min_ext[i] = std::min(start[i], end[i]) - radius * s;
            max_ext[i] = std::max(start[i], end[i]) + radius * s;
        }
        return AABB<Dim, T>(min_ext, max_ext);
    }
 
    [[nodiscard]] constexpr bool isDegenerate() const noexcept { return radius < T(0); }
 
    [[nodiscard]] constexpr T volume() const noexcept
    {
        if constexpr (1 == Dim) {
            return length();
        } else if constexpr (2 == Dim) {
            return radius * T(2) * length();
        } else if constexpr (3 == Dim) {
            return std::numbers::pi_v<T> * radius * radius * length();
        } else {
            // Higher dimensions would need the general n-cylinder volume formula
            return T(0);
        }
    }
 
    [[nodiscard]] bool operator==(Cylinder const&) const = default;
};
 
//
// Deduction guides
//
 
template <std::size_t Dim, std::floating_point T>
Cylinder(Vec<Dim, T>, Vec<Dim, T>, T) -> Cylinder<Dim, T>;
 
template <std::size_t Dim, std::floating_point T>
std::ostream& operator<<(std::ostream& out, Cylinder<Dim, T> const& cylinder)
{
    return out << "Start: [" << cylinder.start << "], End: [" << cylinder.end
               << "], Radius: " << cylinder.radius;
}
 
template <std::floating_point T>
using Cylinder1 = Cylinder<1, T>;
template <std::floating_point T>
using Cylinder2 = Cylinder<2, T>;
template <std::floating_point T>
using Cylinder3 = Cylinder<3, T>;
template <std::floating_point T>
using Cylinder4 = Cylinder<4, T>;
 
using Cylinder1f = Cylinder<1, float>;
using Cylinder2f = Cylinder<2, float>;
using Cylinder3f = Cylinder<3, float>;
using Cylinder4f = Cylinder<4, float>;
 
using Cylinder1d = Cylinder<1, double>;
using Cylinder2d = Cylinder<2, double>;
using Cylinder3d = Cylinder<3, double>;
using Cylinder4d = Cylinder<4, double>;
 
}  // namespace ufo
 
template <std::size_t Dim, std::floating_point T>
  requires std::formattable<T, char>
struct std::formatter<ufo::Cylinder<Dim, T>> {
    constexpr auto parse(std::format_parse_context& ctx) { return ctx.begin(); }
 
    auto format(ufo::Cylinder<Dim, T> const& cylinder, std::format_context& ctx) const
    {
        return std::format_to(ctx.out(), "Start: [{}], End: [{}], Radius: {}", cylinder.start,
                              cylinder.end, cylinder.radius);
    }
};
 
#endif  // UFO_GEOMETRY_CYLINDER_HPP