Bounds.hpp

/*--------------------------------------------------------------------------------------------
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
{

    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(const t_vertex& vertex)
            : Vector<2, t_vertex>(vertex, vertex)
        {}

        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())
        {}

        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 t_type span(uint01 dim) const
        {
            return Vector<2, t_vertex>::m_values[MAX][dim] - Vector<2, t_vertex>::m_values[MIN][dim];
        }

        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_type center(uint01 dim) const
        {
            return (Vector<2, t_vertex>::m_values[MIN][dim] + Vector<2, t_vertex>::m_values[MAX][dim]) / cast<t_type>(2);
        }

 
        constexpr t_type volume() const
        {
            return span().product();
        }

        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 void expand(const t_type& expansion_scaler)
        {
            (*this)[MIN] -= expansion_scaler;
            (*this)[MAX] += expansion_scaler;
        }

 
        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 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);
        }

        template<uint01 t_new_dims, class t_new_type, class t_new_vertex = Vertex<t_new_dims, t_new_type>>
        constexpr decltype(auto) as(t_new_type extra_fill_value = t_new_type(0)) const
        {
            if constexpr (t_new_dims == t_dims
                && std::is_same_v<t_new_type, t_type>
                && std::is_same_v<t_new_vertex, t_vertex>)
            {
                return static_cast<const Bounds&>(*this);
            }
            else
            {
                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)));
            }
        }

        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]));
            }
        }

        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;
        }

        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;
        }

        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;
        }
 

        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 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;
            }
        }

 
        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 LineSegment<t_dims, t_type, t_vertex>& line_segment)
        {
            addToBounds(line_segment.vertex(A));
            addToBounds(line_segment.vertex(B));
        }

 
        constexpr void addToBounds(const Triangle<t_dims, t_type, t_vertex>& triangle)
        {
            addToBounds(triangle.vertex(A));
            addToBounds(triangle.vertex(B));
            addToBounds(triangle.vertex(C));
        }

        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 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 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 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 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))) 
                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;
        }

        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;
        }

        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;
        }

        [[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;
        }

        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;
    }
    template<uint01 t_dims, class t_type, class t_vertex>
    static constexpr bool IsValid(const Bounds<t_dims, t_type, t_vertex>& value)
    {
        for (uint01 dim = 0; dim < 2; ++dim)
        {
            if (IsInvalid(value[dim]))
                return false;
        }
        return true;
    }
 
};