Bounds.hpp

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Base
File: Bounds
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/BaseValues.h>
#include <NDEVR/Vertex.h>
#include <NDEVR/LineSegment.h>
#include <NDEVR/Triangle.h>
#include <NDEVR/RadialObject.h>
namespace NDEVR
{
 
    /**--------------------------------------------------------------------------------------------------
    Class: Bounds
    
    \brief A specification of upper and lower bounds in N-dimensions.
    
    Author: Tyler Parke
    
    Date: 2017-11-17
    --------------------------------------------------------------------------------------------------**/
    template<uint01 t_dims, class t_type, class t_vertex = Vertex<t_dims, t_type>>
    class Bounds : public Vector<2, t_vertex>
    {
    public:
        constexpr Bounds()
        {}
        constexpr Bounds() {…}
 
        /**
        \brief Given the vector, creates bounds of size 0 where max and min are both equal to the vertex
        \param[in] vertex The vertex around which a bounds of size 0 will be made.
         **/
        constexpr Bounds(const t_vertex& vertex)
            : Vector<2, t_vertex>(vertex, vertex)
        {}
        constexpr Bounds(const t_vertex& vertex) {…}
 
        /**
                
        \brief Given the center, creates bounds of size where max and min are both equal to the vertex + size and
            - size respectively.
        \param[in] center -    The center of the bounds.
        \param[in] size -       The size of the bounds.
         **/
        constexpr Bounds(const t_vertex& center, t_type size)
            : Vector<2, t_vertex>(center - size, center + size)
        {}
        constexpr Bounds(const t_vertex& center, t_type size) {…}
        constexpr Bounds(const t_vertex& min, const t_vertex& max)
            : Vector<2, t_vertex>(min, max)
        {}
        constexpr Bounds(const t_vertex& min, const t_vertex& max) {…}
        constexpr Bounds(const t_type& min_scaler, const t_type& max_scaler)
            : Vector<2, t_vertex>(t_vertex(min_scaler), t_vertex(max_scaler))
        {}
        constexpr Bounds(const t_type& min_scaler, const t_type& max_scaler) {…}
 
        constexpr Bounds(const  Vector<2, t_vertex>& bounds)
            : Vector<2, t_vertex>(bounds)
        {}
        constexpr Bounds(const  Vector<2, t_vertex>& bounds) {…}
 
        constexpr Bounds(const Bounds& bounds_a, const Bounds& bounds_b)
            : Vector<2, t_vertex>(getMin(bounds_a[MIN], bounds_b[MIN]), getMax(bounds_a[MAX], bounds_b[MAX]))
        {}
        constexpr Bounds(const Bounds& bounds_a, const Bounds& bounds_b) {…}
 
        constexpr Bounds(const Bounds& bounds, const t_vertex& vector)
            : Vector<2, t_vertex>(getMin(bounds[MIN], vector), getMax(bounds[MAX], vector))
        {}
        constexpr Bounds(const Bounds& bounds, const t_vertex& vector) {…}
        constexpr Bounds(const LineSegment<t_dims, t_type, t_vertex>& line)
            : Vector<2, t_vertex>(getMin(line.vertex(A), line.vertex(B)), getMax(line.vertex(A), line.vertex(B)))
        {}
        constexpr Bounds(const LineSegment<t_dims, t_type, t_vertex>& line) {…}
 
        constexpr Bounds(const Triangle<t_dims, t_type, t_vertex>& tri)
            : Vector<2, t_vertex>(
                  getMin(tri.vertex(A), tri.vertex(B), tri.vertex(C))
                , getMax(tri.vertex(A), tri.vertex(B), tri.vertex(C)))
        {}
        constexpr Bounds(const Triangle<t_dims, t_type, t_vertex>& tri) {…}
 
        constexpr Bounds(const RadialObject<t_dims, t_type, t_vertex>& radial)
            : Vector<2, t_vertex>(radial.center() - radial.radius(), radial.center() + radial.radius())
        {}
        constexpr Bounds(const RadialObject<t_dims, t_type, t_vertex>& radial) {…}
 
        /**
        \brief The side lengths of these bounds. For each dimension, the span is max - min.
        \returns A t_vertex defining the span of the range in each dimension.
        **/
        constexpr Ray<t_dims, t_type> span() const
        {
            return Ray<t_dims, t_type>(Vector<2, t_vertex>::m_values[1] - Vector<2, t_vertex>::m_values[0]);
        }
        constexpr Ray<t_dims, t_type> span() const {…}
 
        /**
        \brief Returns the center of the bounds.
        \returns A t_vertex representing the center.
        **/
        constexpr t_vertex center() const
        {
            return (Vector<2, t_vertex>::m_values[MIN] + Vector<2, t_vertex>::m_values[MAX]) / cast<t_type>(2);
        }
        constexpr t_vertex center() const {…}
 
        /**
        \brief Returns the volume of the bounds. This is defined as length in 1 dimension, area in 2 dimensions.
        \returns A t_type giving the volume of the bounds.
        **/
 
        constexpr t_type volume() const
        {
            return span().product();
        }
        constexpr t_type volume() const {…}
        /**
        \brief The surface area of the shape. This is defined as the area between internal space and non-internal space.
        \returns A t_type representing the area of the surface created by the bounds.
        **/
        constexpr t_type surfaceArea() const
        {
            t_type area = 0;
            t_vertex side_lengths = span();
            for (uint01 dim_a = 0; dim_a < t_dims; dim_a++)
            {
                for (uint01 dim_b = 0; dim_b < t_dims; dim_b++)
                {
                    if (dim_b != dim_a)
                    {
                        area += side_lengths[dim_a] * side_lengths[dim_b];
                    }
                }
            }
            return area;
        }
        constexpr t_type surfaceArea() const {…}
 
        /**
        \brief Expands the given expansion scaler. such that max and min are both expanded outward from the center by
            the given expansion scaler
        \param[in] expansion_scaler -  The expansion scaler.
         **/
 
        constexpr void expand(const t_type& expansion_scaler)
        {
            (*this)[MIN] -= expansion_scaler;
            (*this)[MAX] += expansion_scaler;
        }
        constexpr void expand(const t_type& expansion_scaler) {…}
 
        /**
        \brief Expands the given expansion scaler. such that max and min are both expanded outward from the center by
            the given expansion vector. That is that each dimension may be scaled out differently.
        \param[in] expansion_vector -  The expansion vector.
         **/
 
        constexpr void expand(const t_vertex& expansion_vector)
        {
            Vector<2, t_vertex>::m_values[MIN] -= expansion_vector;
            Vector<2, t_vertex>::m_values[MAX] += expansion_vector;
        }
        constexpr void expand(const t_vertex& expansion_vector) {…}
 
        /**     
        \brief Scales this geometry about a center point
        \param[in] scale -     The scale.
        \param[in] center -    The center.
        \returns A Bounds&lt;t_dims,t_type&gt;
         **/
        constexpr Bounds<t_dims, t_type> scale(const Vector<t_dims, t_type>& scale, const Vector<t_dims, t_type>& center) const
        {
            t_vertex scale_a = Vector<2, t_vertex>::m_values[MIN].scale(scale, center);
            t_vertex scale_b = Vector<2, t_vertex>::m_values[MAX].scale(scale, center);
            return Bounds<t_dims, t_type>(getMin(scale_a, scale_b), getMax(scale_a, scale_b));
        }
        constexpr Bounds<t_dims, t_type> scale(const Vector<t_dims, t_type>& scale, const Vector<t_dims, t_type>& center) const {…}
        constexpr Bounds<t_dims, t_type> scale(const Vector<t_dims, t_type>& center_scale) const
        {
            return scale(center_scale, center());
        }
        constexpr Bounds<t_dims, t_type> scale(const Vector<t_dims, t_type>& center_scale) const {…}
 
        constexpr Bounds<t_dims, t_type> scale(const t_type& scale, const Vector<t_dims, t_type>& center) const
        {
            t_vertex scale_a = Vector<2, t_vertex>::m_values[MIN].scale(scale, center);
            t_vertex scale_b = Vector<2, t_vertex>::m_values[MAX].scale(scale, center);
            return Bounds<t_dims, t_type>(getMin(scale_a, scale_b), getMax(scale_a, scale_b));
        }
        constexpr Bounds<t_dims, t_type> scale(const t_type& scale, const Vector<t_dims, t_type>& center) const {…}
 
        constexpr Bounds<t_dims, t_type> scale(const t_type& center_scale) const
        {
            auto point = center();
            t_vertex scale_a = Vector<2, t_vertex>::m_values[MIN].scale(center_scale, point);
            t_vertex scale_b = Vector<2, t_vertex>::m_values[MAX].scale(center_scale, point);
            if(center_scale > 0)
                return Bounds<t_dims, t_type>(scale_a, scale_b);
            else
                return Bounds<t_dims, t_type>(scale_b, scale_a);
        }
        constexpr Bounds<t_dims, t_type> scale(const t_type& center_scale) const {…}
 
        /**
        \brief Casts this object into an object of different dimension or precision.
        \param[in] extra_fill_value (Optional) The extra fill value, or value to set dimensions extra that may be
            created when t_new_dim > t_dim.
         **/
        template<uint01 t_new_dims, class t_new_type, class t_new_vertex = Vertex<t_new_dims, t_new_type>>
        constexpr Bounds<t_new_dims, t_new_type, t_new_vertex> as(t_new_type extra_fill_value = t_new_type(0)) const
        {
            return Bounds<t_new_dims, t_new_type, t_new_vertex>(
                  t_new_vertex((*this)[MIN].template as<t_new_dims, t_new_type>(extra_fill_value))
                , t_new_vertex((*this)[MAX].template as<t_new_dims, t_new_type>(extra_fill_value)));
        }
        constexpr Bounds<t_new_dims, t_new_type, t_new_vertex> as(t_new_type extra_fill_value = t_new_type(0)) const {…}
 
        /**
        \brief Query if this object contains the given value.
        t_allow_bounds - whether or not to allow boundary cases to be considered valid.
 
        \param[in] value The const t_vertex&amp; to test for containment.
 
        \returns True if the object is in the bounds, false if not.
         **/
        template<bool t_allow_bounds = true, uint01 tdims = t_dims
            , typename = typename std::enable_if<tdims == 1>::type>
            constexpr bool contains(const t_type & value) const
        {
            if (t_allow_bounds)
            {
                return !(!(value >= (*this)[MIN][0]) || !(value <= (*this)[MAX][0]));
            }
            else
            {
                return !(!(value > (*this)[MIN][0]) || !(value < (*this)[MAX][0]));
            }
        }
            constexpr bool contains(const t_type & value) const {…}
 
        /**
        \brief Query if this object contains the given vector.
        t_allow_bounds - whether or not to allow boundary cases to be considered valid.
 
        \param[in] vector -  The const t_vertex&amp; to test for containment.
        
        \returns True if the object is in the bounds, false if not.
         **/
        template<bool t_allow_bounds = true>
        constexpr bool contains(const t_vertex& vector) const
        {
            if (t_allow_bounds)
            {
                for (uint01 dim = 0; dim < t_dims; ++dim)
                {
                    if (!(vector[dim] >= (*this)[MIN][dim]) || !(vector[dim] <= (*this)[MAX][dim]))
                        return false;
                }
            }
            else
            {
                for (uint01 dim = 0; dim < t_dims; ++dim)
                {
                    if (!(vector[dim] > (*this)[MIN][dim]) || !(vector[dim] < (*this)[MAX][dim]))
                        return false;
                }
            }
            return true;
        }
        constexpr bool contains(const t_vertex& vector) const {…}
 
        /**
                \brief Query if this object contains the given bounds.
 
        Author: Tyler Parke
 
        Date: 2017-11-17
 
        Parameters:
        t_allow_bounds - whether or not to allow boundary cases to be considered valid.
 
        \param[in] bounds -  The bounds to check if it is inside object.
 
        \returns True if it succeeds, false if it fails.
        **/
        template<bool t_allow_bounds = true>
        constexpr bool contains(const Bounds& bounds) const
        {
            if (t_allow_bounds)
            {
                for (uint01 dim = 0; dim < t_dims; ++dim)
                {
                    if (!(bounds[MIN][dim] >= (*this)[MIN][dim]))
                        return false;
                    if (!(bounds[MAX][dim] <= (*this)[MAX][dim]))
                        return false;
                }
            }
            else
            {
                for (uint01 dim = 0; dim < t_dims; ++dim)
                {
                    if (!(bounds[MIN][dim] >(*this)[MIN][dim]))
                        return false;
                    if (!(bounds[MAX][dim] < (*this)[MAX][dim]))
                        return false;
                }
            }
            return true;
        }
        constexpr bool contains(const Bounds& bounds) const {…}
 
        /**
                Fully contains.
 
        \brief Author: Tyler Parke
 
        Date: 2017-11-17
 
        Parameters:
        \param[in] line -  The vector.
 
        \returns True if it succeeds, false if it fails.
        **/
        template<bool t_allow_bounds = true>
        constexpr bool contains(const LineSegment<t_dims, t_type, t_vertex>& line) const
        {
            if (t_allow_bounds)
            {
                for (uint01 dim = 0; dim < t_dims; ++dim)
                {
                    if (!(line.vertex(A)[dim] >= (*this)[MIN][dim] && line.vertex(B)[dim] >= (*this)[MIN][dim]))
                        return false;
                    if (!(line.vertex(A)[dim] <= (*this)[MAX][dim] && line.vertex(B)[dim] <= (*this)[MAX][dim]))
                        return false;
                }
            }
            else
            {
                for (uint01 dim = 0; dim < t_dims; ++dim)
                {
                    if (!(line.vertex(A)[dim] > (*this)[MIN][dim] && line.vertex(B)[dim] > (*this)[MIN][dim]))
                        return false;
                    if (!(line.vertex(A)[dim] < (*this)[MAX][dim] && line.vertex(B)[dim] < (*this)[MAX][dim]))
                        return false;
                }
            }
            return true;
        }
        constexpr bool contains(const LineSegment<t_dims, t_type, t_vertex>& line) const {…}
 
 
        /**
                \brief Fully contains.
 
        Author: Tyler Parke
 
        Date: 2017-11-17
 
        Parameters:
        \param[in] tri -  The triangle.
 
        \returns True if it succeeds, false if it fails.
        **/
        template<bool t_allow_bounds = true>
        constexpr bool contains(const Triangle<t_dims, t_type, t_vertex>& tri) const
        {
            for (uint01 tri_index = A; tri_index <= C; tri_index++)
                if (!contains<t_allow_bounds>(tri.vertex(tri_index)))
                    return false;
            return true;
        }
        constexpr bool contains(const Triangle<t_dims, t_type, t_vertex>& tri) const {…}
        /**
                \brief Adds to the bounds such that the new bounds fully encompasses the argument.
        
        Author: Tyler Parke.
        
        Date:
        2017 -  11-17.
        
        Parameters:
        \param[in] vector -  The vector.
         **/
 
        constexpr void addToBounds(const t_vertex& vector)
        {
            for (uint01 dim = 0; dim < t_dims; ++dim)
            {
                if ((*this)[MAX][dim] < vector[dim])
                    (*this)[MAX][dim] = vector[dim];
                if ((*this)[MIN][dim] > vector[dim])
                    (*this)[MIN][dim] = vector[dim];
            }
        }
        constexpr void addToBounds(const t_vertex& vector) {…}
        template<uint01 tdims = t_dims>
        constexpr void addToBounds(typename std::enable_if<tdims == 1, const t_type&>::type scaler)
        {
            for (uint01 dim = 0; dim < tdims; ++dim)
            {
                if ((*this)[MAX][dim] < scaler)
                    (*this)[MAX][dim] = scaler;
                if ((*this)[MIN][dim] > scaler)
                    (*this)[MIN][dim] = scaler;
            }
        }
        constexpr void addToBounds(typename std::enable_if<tdims == 1, const t_type&>::type scaler) {…}
 
        /**
                \brief Adds to the bounds such that the new bounds fully encompasses the argument.
        
        Author: Tyler Parke.
        
        Date:
        2017-11-17.
        
        Parameters:
        \param[in] bounds -  The bounds to add to this bounds.
         **/
 
        constexpr void addToBounds(const Bounds& bounds)
        {
            for (uint01 dim = 0; dim < t_dims; ++dim)
            {
                if ((*this)[MAX][dim] < bounds[MAX][dim])
                    (*this)[MAX][dim] = bounds[MAX][dim];
                if ((*this)[MIN][dim] > bounds[MIN][dim])
                    (*this)[MIN][dim] = bounds[MIN][dim];
            }
        }
        constexpr void addToBounds(const Bounds& bounds) {…}
 
        /**
                \brief Adds to the bounds such that the new bounds fully encompasses the argument.
        
        Author: Tyler Parke.
        
        Date:
        2017-11-17.
        
        Parameters:
        \param[in] line_segment -  The line segment.
         **/
 
        constexpr void addToBounds(const LineSegment<t_dims, t_type, t_vertex>& line_segment)
        {
            addToBounds(line_segment.vertex(A));
            addToBounds(line_segment.vertex(B));
        }
        constexpr void addToBounds(const LineSegment<t_dims, t_type, t_vertex>& line_segment) {…}
 
        /**
                \brief Adds to the bounds such that the new bounds fully encompesses the argument.
        
        Author: Tyler Parke.
        
        Date:
        2017-11-17.
        
        Parameters:
        \param[in] triangle -  The triangle.
         **/
 
        constexpr void addToBounds(const Triangle<t_dims, t_type, t_vertex>& triangle)
        {
            addToBounds(triangle.vertex(A));
            addToBounds(triangle.vertex(B));
            addToBounds(triangle.vertex(C));
        }
        constexpr void addToBounds(const Triangle<t_dims, t_type, t_vertex>& triangle) {…}
 
        /**
                \brief Query if this object contains the given radial_object.
 
        Author: Tyler Parke
 
        Date: 2017-11-18
 
        Parameters:
        \param[in] radial_object -  The const RadialObject&lt;t_dims,t_type&gt;&amp; to test for containment.
 
        \returns True if the object is in this collection, false if not.
        **/
        template<bool t_allow_bounds = true>
        constexpr bool contains(const RadialObject<t_dims, t_type>& radial_object) const
        {
            if (t_allow_bounds)
                return distanceSquared(closestEdge(radial_object.center()), radial_object.center()) <= radial_object.radius() * radial_object.radius();
            else
                return distanceSquared(closestEdge(radial_object.center()), radial_object.center()) <  radial_object.radius() * radial_object.radius();
        }
        constexpr bool contains(const RadialObject<t_dims, t_type>& radial_object) const {…}
 
        /**
                \brief Closest edge.
        
        Author: Tyler Parke.
        
        Date:
        2017 -  11-17.
        
        Parameters:
        \param[in] vertex -  The first t_vertex.
        
        \returns The closest edge.
         **/
 
        constexpr t_vertex closestEdge(const t_vertex& vertex) const
        {
            t_vertex closest_edge;
            for(uint01 dim = 0; dim < t_dims; ++dim)
                closest_edge[dim] = abs(vertex[dim] - (*this)[MIN][dim]) > abs(vertex[dim] - (*this)[MAX][dim]) ? (*this)[MAX][dim] : (*this)[MIN][dim];
            return closest_edge;
        }
        constexpr t_vertex closestEdge(const t_vertex& vertex) const {…}
 
        /**
                \brief Closest value.
        
        Author: Tyler Parke.
        
        Date:
        2017 -  11-17.
        
        Parameters:
        \param[in] vertex -  The first t_vertex.
        
        \returns The closest element.
         **/
 
        constexpr t_vertex closestValue(const t_vertex& vertex) const
        {
            t_vertex closest_vertex;
            for(uint01 dim = 0; dim < t_dims; ++dim)
                closest_vertex[dim] = (vertex[dim] < (*this)[MIN][dim]) ? (*this)[MIN][dim] : (vertex[dim] > (*this)[MAX][dim]) ? (*this)[MAX][dim] : vertex[dim];
            return closest_vertex;
        }
        constexpr t_vertex closestValue(const t_vertex& vertex) const {…}
 
        /**
                \brief Furthest value.
        
        Author: Tyler Parke.
        
        Date:
        2017 -  11-17.
        
        Parameters:
        \param[in] vertex -  The first t_vertex.
        
        \returns The furthest point.
         **/
 
        constexpr t_vertex furthestValue(const t_vertex& vertex) const
        {
            t_vertex furthest_vertex;
            for(uint01 dim = 0; dim < t_dims; ++dim)
                furthest_vertex[dim] = abs(vertex[dim] - (*this)[MIN][dim]) > abs(vertex[dim] - (*this)[MAX][dim]) ? (*this)[MIN][dim] : (*this)[MAX][dim];
            return furthest_vertex;
        }
        constexpr t_vertex furthestValue(const t_vertex& vertex) const {…}
 
        /**
                
        \brief Checks for intersection of the ray from a given distance, excluding one axis.
        
        Author: Tyler Parke
        
        Date: 2017-11-18
        
        Parameters:
        \param[in] distance_a -       The distance a.
        \param[in] distance_b -       The distance b.
        \param[in] origin -           The origin.
        \param[in] ray -              The ray.
        \param[in] exclusion_axis -  The exclusion axis.
        
        \returns True if it succeeds, false if it fails.
         **/
 
        constexpr bool doesIntersect(t_type distance_a, t_type distance_b, const t_vertex& origin, const Vector<t_dims, t_type>& ray, uint01 exclusion_axis) const
        {
            if(!((distance_a * distance_b) < cast<t_type>(0))) //!< for Invalid
                return false;
 
            t_type unit_value = (-distance_a / (distance_b - distance_a));
            for (uint01 dim = 0; dim < exclusion_axis; ++dim)
            {
                t_type hit_location = origin[dim] + ray[dim] * unit_value;
                if (hit_location < (*this)[MIN][dim] || hit_location > (*this)[MAX][dim])
                    return false;
            }
            for (uint01 dim = exclusion_axis + 1; dim < t_dims; ++dim)
            {
                t_type hit_location = origin[dim] + ray[dim] * unit_value;
                if (hit_location < (*this)[MIN][dim] || hit_location > (*this)[MAX][dim])
                    return false;
            }
            return true;
        }
        constexpr bool doesIntersect(t_type distance_a, t_type distance_b, const t_vertex& origin, const Vector<t_dims, t_type>& ray, uint01 exclusion_axis) const {…}
 
        /**
                \brief Query if this object intersects the given pair.
 
        Author: Tyler Parke
 
        Date: 2017-11-17
 
        Parameters:
        \param[in] bounds -  The pair.
 
        \returns True if it succeeds, false if it fails.
        **/
        template<class t_other_vertex_type>
        constexpr bool intersects(const Bounds<t_dims, t_type, t_other_vertex_type>& bounds) const
        {
            for (uint01 dim = 0; dim < t_dims; ++dim)
            {
                if (!((*this)[MAX][dim] > bounds[MIN][dim] && (*this)[MIN][dim] < bounds[MAX][dim]))
                    return false;
            }
            return true;
        }
        constexpr bool intersects(const Bounds<t_dims, t_type, t_other_vertex_type>& bounds) const {…}
 
 
        template<class t_other_vertex_type>
        constexpr bool intersects(const LineSegment<t_dims, t_type, t_other_vertex_type>& seg) const
        {
            if (contains(seg))
            {
                return true;
            }
            const Vector<t_dims, t_type> ray = seg.ray();
            for (uint01 i = 0; i < t_dims; ++i)
            {
                if (   doesIntersect(seg.vertex(A)[i] - (*this)[MIN][i], seg.vertex(B)[i] - (*this)[MIN][i], seg.vertex(A), ray, i)
                    || doesIntersect(seg.vertex(A)[i] - (*this)[MAX][i], seg.vertex(B)[i] - (*this)[MAX][i], seg.vertex(A), ray, i))
                    return true;
            }
            return false;
        }
        constexpr bool intersects(const LineSegment<t_dims, t_type, t_other_vertex_type>& seg) const {…}
 
        /**
        \brief Query if this object contains the given circle.
        \param[in] circle -  The const RadialObject&lt;t_rad_dims,t_rad_type&gt;&amp; to test for containment.
        \returns True if the object is in this collection, false if not.
        **/
        template<bool t_allow_bounds = true>
        constexpr bool intersects(const RadialObject<t_dims, t_type>& circle) const
        {
            t_type dist_squared = circle.radius() * circle.radius();
            for (uint01 dim = 0; dim < t_dims; ++dim)
            {
                if (circle.getCenter()[dim] < (*this)[MIN][dim])
                {
                    t_type value = circle.center()[dim] - (*this)[MIN][dim];
                    dist_squared -= (value * value);
                }
                else if (circle.getCenter()[dim] > (*this)[MAX][dim])
                {
                    t_type value = circle.center()[dim] - (*this)[MAX][dim];
                    dist_squared -= (value * value);
                }
                if (t_allow_bounds)
                {
                    if (dist_squared < 0)
                        return false;
                }
                else
                {
                    if (dist_squared <= 0)
                        return false;
                }
            }
            return true;
        }
        constexpr bool intersects(const RadialObject<t_dims, t_type>& circle) const {…}
 
        /**
        \brief Validates this object. Returns true if the value at MIN is less than or equal the value at MAX in all
            dimensions.
        \returns True if it succeeds, false if it fails.
        **/
        [[nodiscard]] constexpr bool validate() const
        {
            if (getMin((*this)[MIN], (*this)[MAX]) != (*this)[MIN])
                return false;
            if (getMax((*this)[MIN], (*this)[MAX]) != (*this)[MAX])
                return false;
            return true;
        }
        [[nodiscard]] constexpr bool validate() const {…}
 
        /**
        \brief Ensures that this is a valid bounds object. Values are swapped within the structure to ensure that
            MAX >= MIN
        **/
        void ensureValid()
        {
            t_vertex min = (*this)[MIN];
            t_vertex max = (*this)[MAX];
            (*this)[MIN] = getMin(min, max);
            (*this)[MAX] = getMax(min, max);
        }
        void ensureValid() {…}
        Bounds<t_dims, t_type>& operator-=(const t_type& center_scale)
        {
            (*this)[MAX] -= center_scale;
            (*this)[MIN] -= center_scale;
            return *this;
        }
        Bounds<t_dims, t_type>& operator-=(const t_type& center_scale) {…}
    };
    class Bounds : public Vector<2, t_vertex> {…};
 
    
 
    template<uint01 t_dims, class t_type, class t_vertex>
    struct Constant<Bounds<t_dims, t_type, t_vertex>>
    {
        constexpr static Bounds<t_dims, t_type, t_vertex> Invalid{ Constant<t_type>::Invalid, Constant<t_type>::Invalid };
        constexpr static Bounds<t_dims, t_type, t_vertex> Min{ Constant<t_type>::Max, Constant<t_type>::Min };
        constexpr static Bounds<t_dims, t_type, t_vertex> Max{ Constant<t_type>::Min, Constant<t_type>::Max };
    };
 
    template<uint01 t_dims, class t_type, class t_vertex>
    static constexpr bool IsInvalid(const Bounds<t_dims, t_type, t_vertex>& value)
    {
        for (uint01 dim = 0; dim < 2; ++dim)
        {
            if (IsInvalid(value[dim]))
                return true;
        }
        return false;
    }
 
};