RadialObject.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: 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: Parke
Namespace that wraps all Logic created by Tyler Parke
 *-----------------------------------------------------------------------------------------------**/
 
namespace NDEVR
{
 
    /**--------------------------------------------------------------------------------------------------
    Class: RadialObject
    
    \brief A radial object.
    
    Author: Tyler Parke
    
    Date: 2017-11-19
     *-----------------------------------------------------------------------------------------------**/
    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)
        {}
        /**--------------------------------------------------------------------------------------------------
        Fn: , RadialObject::m_center(Constant<t_type>::NaN)
 
        Constructor.
 
        Author: Tyler Parke
 
        Date: 2017-11-19
 
        Parameters:
        parameter1 -  The first parameter.
        *-----------------------------------------------------------------------------------------------**/
 
        constexpr RadialObject(const t_vertex& vertex_a, const t_vertex& vertex_b, const t_vertex& vertex_c)
            : m_center(Constant<t_type>::NaN)
            , m_radius(Constant<t_type>::NaN)
        {
            static_assert(t_dims == 2, "Radial Object given 3 points must be defined in 2 dimensions");
            const t_vertex a = (vertex_a + vertex_b) / cast<t_type>(2);
            const t_vertex b = (vertex_c + vertex_b) / cast<t_type>(2);
 
            const t_vertex e(vertex_b[Y] - vertex_a[Y], vertex_a[X] - vertex_b[X]);
            const t_vertex q(vertex_b[Y] - vertex_c[Y], vertex_c[X] - vertex_b[X]);
            
            if (e[Y] * q[X] - e[X] * q[Y] != cast<t_type>(0))
            {
                m_center = b + q * (e[X] * (b[Y] - a[Y]) - e[Y] * (b[X] - a[X])) / (e[Y] * q[X] - e[X] * q[Y]);
                m_radius = distance<t_type>(vertex_a, m_center);
            }
        }
        
 
        /**--------------------------------------------------------------------------------------------------
        Fn: constexpr bool RadialObject::contains(const t_vertex& vector) const
        
        Query if this object contains the given vector.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Parameters:
        vector -  The const t_vertex&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 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;
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: constexpr t_type RadialObject::radius() const
        
        Gets the radius.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Returns: A t_type.
         *-----------------------------------------------------------------------------------------------**/
 
        constexpr t_type radius() const {return m_radius;}
 
 
 
        /**--------------------------------------------------------------------------------------------------
        Fn: constexpr RadialObject<t_new_dims, t_new_type> RadialObject::as() const
        
        Gets as.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Returns: A RadialObject&lt;t_new_dims,t_new_type&gt;
         *-----------------------------------------------------------------------------------------------**/
        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));
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: constexpr const t_vertex& RadialObject::center() const
        
        Gets the center.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Returns: A reference to a const t_vertex.
         *-----------------------------------------------------------------------------------------------**/
 
        [[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: 
        /** The center. */
        t_vertex m_center;
        /** The radius. */
        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> NaN{ Constant<t_vector>::NaN, Constant<t_type>::NaN };
        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};
    };
 
    /**--------------------------------------------------------------------------------------------------
    Class: BiRadialObject
    
    A bi radial object.
    
    Author: Tyler Parke
    
    Date: 2017-11-19
     *-----------------------------------------------------------------------------------------------**/
    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;
        }
        /**--------------------------------------------------------------------------------------------------
        Fn: constexpr bool BiRadialObject::contains(const Vector<t_dims, t_type>& vector) const
        
        Query if this object contains the given vector.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Parameters:
        vector -  The const Vector&lt;t_dims,t_type&gt;&amp; to test for containment.
        
        Returns: True if the object is in this collection, false if not.
         *-----------------------------------------------------------------------------------------------**/
 
        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]);
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: constexpr t_type BiRadialObject::radius() const
        
        Gets the radius.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Returns: A t_type.
         *-----------------------------------------------------------------------------------------------**/
 
        constexpr t_type radius() const { return m_radius; }
 
        
 
        /**--------------------------------------------------------------------------------------------------
        Fn: constexpr BiRadialObject<t_new_dims, t_new_type> BiRadialObject::as() const
        
        Gets as.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Returns: A RadialObject&lt;t_new_dims,t_new_type&gt;
         *-----------------------------------------------------------------------------------------------**/
        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));
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: constexpr const t_vertex& BiRadialObject::center() const
        
        Gets the center.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Returns: The centerpoint of the Biradial object (Or the intersection of the major and minor axis);
         *-----------------------------------------------------------------------------------------------**/
 
        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:
        /** The 1. */
        Vector<2, t_vertex> m_axis_major;
        /** The radius. */
        t_type m_radius;
    };
};