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 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(t_type r = 0) {…}
        constexpr RadialObject(const t_vertex& center, t_type radius)
            : m_center(center)
            , m_radius(radius)
        {}
        constexpr RadialObject(const t_vertex& center, t_type radius) {…}
        /**--------------------------------------------------------------------------------------------------
                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>::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 + 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);
            }
        }
        constexpr RadialObject(const t_vertex& vertex_a, const t_vertex& vertex_b, const t_vertex& vertex_c) {…}
        
 
        /**--------------------------------------------------------------------------------------------------
                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;
        }
        constexpr bool contains(const t_vertex& vector) const {…}
 
        /**--------------------------------------------------------------------------------------------------
                Gets the radius.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        \returns A t_type.
        **/
 
        constexpr t_type radius() const {return m_radius;}
 
 
 
        /**--------------------------------------------------------------------------------------------------
                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));
        }
        constexpr RadialObject<t_new_dims, t_new_type> as() 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 {…}
        bool operator!=(const RadialObject& rad) const
        {
            return m_radius != rad.m_radius || m_center != rad.m_center;
        }
        bool operator!=(const RadialObject& rad) const {…}
    private: 
        /** The center. */
        t_vertex m_center;
        /** The radius. */
        t_type m_radius;
    };
    class RadialObject {…};
 
    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};
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief An ellipse like shape (such as an oval or egg) with two points, where all points on the shape are
        equal distance between the two points (distanceTo(A) + distanceTo(B) = radius).
    **/
    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(t_type r = 0) {…}
        constexpr BiRadialObject(const t_vertex& p1, const t_vertex& p2, t_type radius)
            : m_axis_major(p1, p2)
            , m_radius(radius)
        {}
        constexpr BiRadialObject(const t_vertex& p1, const t_vertex& p2, t_type 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;
        }
        static BiRadialObject<t_dims, t_type, t_vertex> fromCircleTransform(const Matrix<t_matrix_type>& mat) {…}
        /**--------------------------------------------------------------------------------------------------
                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]);
        }
        constexpr bool contains(const t_vertex& vector) const {…}
 
        /**--------------------------------------------------------------------------------------------------
                Gets the radius.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        \returns A t_type.
        **/
 
        constexpr t_type radius() const { return m_radius; }
 
        
 
        /**--------------------------------------------------------------------------------------------------
                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));
        }
        constexpr BiRadialObject<t_new_dims, t_new_type> as() 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];
        }
        constexpr const t_vertex& axisPoint(uint01 vertex) const {…}
 
        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));
        }
        t_ratio_type minorToMajorRatio() const {…}
        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;
        }
        Matrix<t_matrix_type> fromCircleTransform() const {…}
    private:
        /** The 1. */
        Vector<2, t_vertex> m_axis_major;
        /** The radius. */
        t_type m_radius;
    };
    class BiRadialObject {…};
};