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()
        {}
 
        /**--------------------------------------------------------------------------------------------------
                \brief Given the vector, creates bounds of size 0 where max and min are both equal to the vertex
        
        Author: Tyler Parke
        
        Date: 2017-11-17
        
        Parameters:
        vector -  The vertex around which a bounds of size 0 will be made.
         *-----------------------------------------------------------------------------------------------**/
        constexpr Bounds(const t_vertex& vertex)
            : Vector<2, t_vertex>(vertex, vertex)
        {}
 
        /**--------------------------------------------------------------------------------------------------
                
        \brief Given the center, creates bounds of size where max and min are both equal to the vertex + size and
        - size respectively.
        
        Author: Tyler Parke
        
        Date: 2017-11-17
        
        Parameters:
        center -    The center of the bounds.
        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& min, const t_vertex& max)
            : Vector<2, t_vertex>(min, 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  Vector<2, t_vertex>& bounds)
            : 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, const t_vertex& vector)
            : Vector<2, t_vertex>(getMin(bounds[MIN], vector), getMax(bounds[MAX], 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 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 RadialObject<t_dims, t_type, t_vertex>& radial)
            : Vector<2, t_vertex>(radial.center() - radial.radius(), radial.center() + radial.radius())
        {}
 
        /**--------------------------------------------------------------------------------------------------
                \brief The side lengths of these bounds. For each dimension, the span is max - min.
 
        Author: Tyler Parke
 
        Date: 2017-11-17
 
        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]);
        }
 
        /**--------------------------------------------------------------------------------------------------
                \brief Returns the center of the bounds.
 
        Author: Tyler Parke
 
        Date: 2017-11-17
 
        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);
        }
 
        /**--------------------------------------------------------------------------------------------------
                \brief Returns the volume of the bounds. This is defined as length in 1 dimension, area in 2 dimensions.
 
        Author: Tyler Parke
 
        Date: 2017-11-17
 
        Returns: A t_type giving the volume of the bounds.
        *-----------------------------------------------------------------------------------------------**/
 
        constexpr t_type volume() const
        {
            return span().product();
        }
        /**--------------------------------------------------------------------------------------------------
                \brief The surface area of the shape. This is defined as the area between internal space and non-internal space.
 
        Author: Tyler Parke
 
        Date: 2017-11-17
 
        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;
        }
 
        /**--------------------------------------------------------------------------------------------------
                \brief Expands the given expansion scaler. such that max and min are both expanded outward from the center by
        the given expansion scaler
        
        Author: Tyler Parke
        
        Date: 2017-11-17
        
        Parameters:
        expansion_scaler -  The expansion scaler.
         *-----------------------------------------------------------------------------------------------**/
 
        constexpr void expand(const t_type& expansion_scaler)
        {
            (*this)[MIN] -= expansion_scaler;
            (*this)[MAX] += 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.
        
        Author: Tyler Parke
        
        Date: 2017-11-17
        
        Parameters:
        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;
        }
 
        /**--------------------------------------------------------------------------------------------------
                
        \brief Scales this geometry about a center point
        
        Author: Tyler Parke
        
        Date: 2017-11-17
        
        Parameters:
        scale -     The scale.
        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>& center_scale) const
        {
            return scale(center_scale, center());
        }
 
        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& 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);
        }
 
        /**--------------------------------------------------------------------------------------------------
                \brief Casts this object into an object of different dimension or precision.
        
        Author: Tyler Parke
        
        Date: 2017-11-13
        
        Parameters:
        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)));
        }
 
        /**--------------------------------------------------------------------------------------------------
                \brief Query if this object contains the given value.
 
        Author: Tyler Parke
 
        Date: 2017-11-17
 
        Parameters:
        t_allow_bounds - whether or not to allow boundary cases to be considered valid.
 
        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, 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]));
            }
        }
 
        /**--------------------------------------------------------------------------------------------------
                \brief Query if this object contains the given vector.
        
        Author: Tyler Parke
        
        Date: 2017-11-17
        
        Parameters:
        t_allow_bounds - whether or not to allow boundary cases to be considered valid.
 
        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;
        }
 
        /**--------------------------------------------------------------------------------------------------
                \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.
 
        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;
        }
 
        /**--------------------------------------------------------------------------------------------------
                Fully contains.
 
        \brief Author: Tyler Parke
 
        Date: 2017-11-17
 
        Parameters:
        vector -  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;
        }
 
 
        /**--------------------------------------------------------------------------------------------------
                \brief Fully contains.
 
        Author: Tyler Parke
 
        Date: 2017-11-17
 
        Parameters:
        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;
        }
        /**--------------------------------------------------------------------------------------------------
                \brief Adds to the bounds such that the new bounds fully encompasses the argument.
        
        Author: Tyler Parke.
        
        Date:
        2017 -  11-17.
        
        Parameters:
        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];
            }
        }
        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;
            }
        }
 
        /**--------------------------------------------------------------------------------------------------
                \brief Adds to the bounds such that the new bounds fully encompasses the argument.
        
        Author: Tyler Parke.
        
        Date:
        2017-11-17.
        
        Parameters:
        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];
            }
        }
 
        /**--------------------------------------------------------------------------------------------------
                \brief Adds to the bounds such that the new bounds fully encompasses the argument.
        
        Author: Tyler Parke.
        
        Date:
        2017-11-17.
        
        Parameters:
        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));
        }
 
        /**--------------------------------------------------------------------------------------------------
                \brief Adds to the bounds such that the new bounds fully encompesses the argument.
        
        Author: Tyler Parke.
        
        Date:
        2017-11-17.
        
        Parameters:
        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));
        }
 
        /**--------------------------------------------------------------------------------------------------
                \brief Query if this object contains the given radial_object.
 
        Author: Tyler Parke
 
        Date: 2017-11-18
 
        Parameters:
        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();
        }
 
        /**--------------------------------------------------------------------------------------------------
                \brief Closest edge.
        
        Author: Tyler Parke.
        
        Date:
        2017 -  11-17.
        
        Parameters:
        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;
        }
 
        /**--------------------------------------------------------------------------------------------------
                \brief Closest value.
        
        Author: Tyler Parke.
        
        Date:
        2017 -  11-17.
        
        Parameters:
        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;
        }
 
        /**--------------------------------------------------------------------------------------------------
                \brief Furthest value.
        
        Author: Tyler Parke.
        
        Date:
        2017 -  11-17.
        
        Parameters:
        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;
        }
 
        /**--------------------------------------------------------------------------------------------------
                
        \brief Checks for intersection of the ray from a given distance, excluding one axis.
        
        Author: Tyler Parke
        
        Date: 2017-11-18
        
        Parameters:
        distance_a -      The distance a.
        distance_b -      The distance b.
        origin -          The origin.
        ray -             The ray.
        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;
        }
 
        /**--------------------------------------------------------------------------------------------------
                \brief Query if this object intersects the given pair.
 
        Author: Tyler Parke
 
        Date: 2017-11-17
 
        Parameters:
        pair -  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;
        }
 
 
        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;
        }
 
        /**--------------------------------------------------------------------------------------------------
                \brief Query if this object contains the given circle.
 
        Author: Tyler Parke
 
        Date: 2017-11-17
 
        Parameters:
        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;
        }
 
        /**--------------------------------------------------------------------------------------------------
                Validates this object. Returns true if the value at MIN is less than or equal the value at MAX in all
        dimensions.
 
        Author: Tyler Parke
 
        Date: 2017-11-17
 
        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;
        }
 
        /**--------------------------------------------------------------------------------------------------
                \brief Ensures that this is a valid bounds object. Values are swapped within the structure to ensure that
        MAX >= MIN
 
        Author: Tyler Parke
 
        Date: 2022-01-20
        *-----------------------------------------------------------------------------------------------**/
        void ensureValid()
        {
            t_vertex min = (*this)[MIN];
            t_vertex max = (*this)[MAX];
            (*this)[MIN] = getMin(min, max);
            (*this)[MAX] = getMax(min, max);
        }
        Bounds<t_dims, t_type>& operator-=(const t_type& center_scale)
        {
            (*this)[MAX] -= center_scale;
            (*this)[MIN] -= center_scale;
            return *this;
        }
    };
 
    
 
    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;
    }
 
};