RadialObject.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: RadialObject
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/BaseValues.h>
#include <NDEVR/Vertex.h>
#include <NDEVR/VectorFunctions.h>
#include "Matrix.hpp"
 
namespace NDEVR
{

    template<uint01 t_dims, class t_type, class t_vertex = Vertex<t_dims, t_type>>
    class RadialObject
    {
    public:
        constexpr RadialObject(t_type r = 0)
            : m_center(0)
            , m_radius(r)
        {}
        constexpr RadialObject(const t_vertex& center, t_type radius)
            : m_center(center)
            , m_radius(radius)
        {}
 
        constexpr RadialObject(const t_vertex& vertex_a, const t_vertex& vertex_b, const t_vertex& vertex_c)
            : m_center(Constant<t_type>::Invalid)
            , m_radius(Constant<t_type>::Invalid)
        {
            static_assert(t_dims == 2, "Radial Object given 3 points must be defined in 2 dimensions");
            const t_vertex A = vertex_a;
            const t_vertex B = vertex_b;
            const t_vertex C = vertex_c;
 
            const t_type D = 2 * (A[X] * (B[Y] - C[Y]) + B[X] * (C[Y] - A[Y]) + C[X] * (A[Y] - B[Y]));
            if (D == t_type(0))
                return; // Degenerate / colinear
 
            const t_type A_sq = A[X] * A[X] + A[Y] * A[Y];
            const t_type B_sq = B[X] * B[X] + B[Y] * B[Y];
            const t_type C_sq = C[X] * C[X] + C[Y] * C[Y];
 
            const t_type Ux = (A_sq * (B[Y] - C[Y]) + B_sq * (C[Y] - A[Y]) + C_sq * (A[Y] - B[Y])) / D;
            const t_type Uy = (A_sq * (C[X] - B[X]) + B_sq * (A[X] - C[X]) + C_sq * (B[X] - A[X])) / D;
 
            m_center = t_vertex(Ux, Uy);
            m_radius = distance<t_type>(m_center, vertex_a);
        }
        

        template<bool t_allow_bounds = true>
        constexpr bool contains(const t_vertex& vector) const
        {
            if(t_allow_bounds)
                return distanceSquared(m_center, vector) <= m_radius * m_radius;
            else
                return distanceSquared(m_center, vector) <  m_radius * m_radius;
        }

 
        constexpr t_type radius() const {return m_radius;}
 
 

        template<uint01 t_new_dims, class t_new_type, class t_new_vertex = Vertex<t_new_dims, t_new_type>>
        constexpr RadialObject<t_new_dims, t_new_type> as() const
        {
            return RadialObject<t_new_dims, t_new_type>(t_new_vertex(m_center.template as<t_new_dims, t_new_type>()), cast<t_new_type>(m_radius));
        }

 
        [[nodiscard]] constexpr const t_vertex& center() const {return m_center;}
 
        bool operator==(const RadialObject& rad) const
        {
            return m_radius == rad.m_radius && (m_center == rad.m_center);
        }
        bool operator!=(const RadialObject& rad) const
        {
            return m_radius != rad.m_radius || m_center != rad.m_center;
        }
    private: 
        t_vertex m_center;
        t_type m_radius;
    };
 
    template<uint01 t_dims, class t_type, class t_vector>
    struct Constant<RadialObject<t_dims, t_type, t_vector>>
    {
        constexpr const static RadialObject<t_dims, t_type, t_vector> Invalid{ Constant<t_vector>::Invalid, Constant<t_type>::Invalid };
        constexpr const static RadialObject<t_dims, t_type, t_vector> Min{ t_vector(0), 0 };
        constexpr const static RadialObject<t_dims, t_type, t_vector> Max{ t_vector(0), Constant<t_type>::Max};
    };

    template<uint01 t_dims, class t_type, class t_vertex = Vertex<t_dims, t_type>>
    class BiRadialObject
    {
    public:
        constexpr BiRadialObject(t_type r = 0)
            : m_axis_major(Vector<t_dims, t_type>(0.0))
            , m_radius(r)
        {}
        constexpr BiRadialObject(const t_vertex& p1, const t_vertex& p2, t_type radius)
            : m_axis_major(p1, p2)
            , m_radius(radius)
        {}
 
 
        template<class t_matrix_type = fltp08>
        static BiRadialObject<t_dims, t_type, t_vertex> fromCircleTransform(const Matrix<t_matrix_type>& mat)
        {
            BiRadialObject<t_dims, t_type, t_vertex> object;
            Vertex<3, fltp08> center = mat.decomposeOffset();
            Ray<3, fltp08> direction = mat * Ray<3, fltp08>(0.5, 0, 0);
 
            object.m_axis_major[A] = center + direction;
            object.m_axis_major[B] = center - direction;
 
            Vector<t_dims, t_type> scale = mat.decomposeScale();
 
            object.m_radius = getMin(scale[X], scale[Y]);
 
            return object;
        }
 
        constexpr bool contains(const t_vertex& vector) const
        {
            fltp08 total_distance = distance<fltp08>(m_axis_major[A], vector) + distance<fltp08>(m_axis_major[B], vector);
            return m_radius > total_distance - distance<fltp08>(m_axis_major[A], m_axis_major[B]);
        }

 
        constexpr t_type radius() const { return m_radius; }
 
        

        template<uint01 t_new_dims, class t_new_type>
        constexpr BiRadialObject<t_new_dims, t_new_type> as() const
        {
            return BiRadialObject<t_new_dims, t_new_type>(m_axis_major[A].template as<t_new_dims, t_new_type>(), m_axis_major[B].template as<t_new_dims, t_new_type>(), cast<t_new_type>(m_radius));
        }

 
        constexpr t_vertex center() const { return t_vertex((m_axis_major[A] + m_axis_major[B]) / cast<t_type>(2)); }
        constexpr const t_vertex& axisPoint(uint01 vertex) const
        { 
            return m_axis_major[vertex];
        }
 
        template<class t_ratio_type = fltp08>
        t_ratio_type minorToMajorRatio() const
        {
            const t_ratio_type axis_distance = distance<t_ratio_type>(m_axis_major[A], m_axis_major[B]);
            return cast<t_ratio_type>(m_radius) / (cast<t_ratio_type>(m_radius) + axis_distance / cast<t_ratio_type>(2));
        }
        template<class t_matrix_type = fltp08>
        Matrix<t_matrix_type> fromCircleTransform() const
        {
            Matrix<t_matrix_type> mat = Matrix<t_matrix_type>::ScalerMatrix(m_radius);
            if (m_axis_major[B] - m_axis_major[A] == t_vertex(0))
                return mat;
            Vector<t_dims, t_type> axis = (m_axis_major[B] - m_axis_major[A]).template normalized<t_matrix_type>();
            t_matrix_type scale = cast<t_matrix_type>(1) / minorToMajorRatio<t_matrix_type>();
            mat = mat.scale(axis, scale);
            return mat;
        }
    private:
        Vector<2, t_vertex> m_axis_major;
        t_type m_radius;
    };
};