SelectionArea.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: SelectionArea
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/LineSegment.h>
#include <NDEVR/Polygon.h>
#include <NDEVR/RadialObject.h>
#include <NDEVR/Bounds.h>
#include <NDEVR/Matrix.h>
#include <NDEVR/Intersection.h>
#include <NDEVR/Plane.h>
namespace NDEVR
{
    /**--------------------------------------------------------------------------------------------------
    The type of selection used.
    **/
    enum SelectionMode
    {
          e_selection_point
        , e_selection_line
        , e_selection_polygon
        , e_selection_bounds
        , e_selection_plane
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief An area of N-dimensional space that is considered selected
    **/
    template<uint01 t_dims, class t_type>
    class SelectionArea
    {
    public:
        SelectionArea()
            : m_point(Constant<Vertex<t_dims, t_type>>::Invalid)
            , m_mode(SelectionMode::e_selection_line)   
            , m_is_pre_transformed(true)
            , m_is_inverse(false)
            , m_is_enabled(true)
        {}
 
        SelectionArea(const SelectionArea& area)
            : m_matrix(area.m_matrix)
            , m_inverse_matrix(area.m_inverse_matrix)
            , m_projection_matrix(area.m_projection_matrix)
            , m_projection_inverse_matrix(area.m_projection_inverse_matrix)
            , m_mode(area.m_mode)
            , m_is_pre_transformed(area.m_is_pre_transformed)
            , m_is_inverse(area.m_is_inverse)
            , m_is_enabled(area.m_is_enabled)
        {
            switch(m_mode)
            {
            case e_selection_point: m_point = area.m_point; break;
            case e_selection_line: m_line = area.m_line; break;
            case e_selection_bounds: m_bounds = area.m_bounds; break;
            case e_selection_polygon: new (&m_polygon) Polygon<t_type>(area.m_polygon); break;
            case e_selection_plane: m_plane = area.m_plane; break;
            default: lib_assert(false, "unknown selection copy");
            }
        }
        SelectionArea(const Vertex<t_dims, t_type>& point)
            : m_point(point)
            , m_mode(e_selection_point)
            , m_is_pre_transformed(true)
            , m_is_inverse(false)
            , m_is_enabled(true)
        {}
        SelectionArea(const LineSegment<t_dims, t_type>& segment)
            : m_line(segment)
            , m_mode(e_selection_line)
            , m_is_pre_transformed(true)
            , m_is_inverse(false)
            , m_is_enabled(true)
        {}
 
        SelectionArea(const Polygon<t_type>& poly)
            : m_polygon(poly)
            , m_mode(e_selection_polygon)
            , m_is_pre_transformed(true)
            , m_is_inverse(false)
            , m_is_enabled(true)
        {}
 
        SelectionArea(Polygon<t_type>&& poly)
            : m_polygon(std::move(poly))
            , m_mode(e_selection_polygon)
            , m_is_pre_transformed(true)
            , m_is_inverse(false)
            , m_is_enabled(true)
        {}
 
        SelectionArea(const Bounds<t_dims, t_type>& bounds)
            : m_bounds(bounds)
            , m_mode(e_selection_bounds)
            , m_is_pre_transformed(true)
            , m_is_inverse(false)
            , m_is_enabled(true)
        {}
 
        SelectionArea(const Plane<t_dims, t_type>& plane)
            : m_plane(plane)
            , m_mode(e_selection_plane)
            , m_is_pre_transformed(true)
            , m_is_inverse(false)
            , m_is_enabled(true)
        {}
 
        SelectionArea& operator=(const SelectionArea& area)
        {
            cleanup();
            m_mode = area.m_mode;
            switch(m_mode)
            {
            case e_selection_point: m_point = area.m_point; break;
            case e_selection_line: m_line = area.m_line; break;
            case e_selection_bounds: m_bounds = area.m_bounds; break;
            case e_selection_polygon: new (&m_polygon) Polygon<t_type>(area.m_polygon); break;
            case e_selection_plane: m_plane = area.m_plane; break;
            default: lib_assert(false, "unknown selection copy");
            }
            m_is_inverse = area.m_is_inverse;
            m_is_pre_transformed = area.m_is_pre_transformed;
            m_matrix = area.m_matrix;
            m_inverse_matrix = area.m_inverse_matrix;
            m_projection_matrix = area.m_projection_matrix;
            m_projection_inverse_matrix = area.m_projection_inverse_matrix;
            m_is_enabled = area.m_is_enabled;
            return *this;
        }
        ~SelectionArea()
        {
            cleanup();
        }
        
        void setSelection(const Vertex<t_dims, t_type>& point)
        {
            cleanup();
            m_mode = e_selection_point;
            m_point = point;
        }
 
        void setSelection(const LineSegment<t_dims, t_type>& segment)
        {
            cleanup();
            m_mode = e_selection_line;
            m_line = segment;
        }
 
        void setSelection(const Polygon<t_type>& poly)
        {
            cleanup();
            m_mode = e_selection_polygon;
            new (&m_polygon) Polygon<t_type>(poly); 
        }
 
        void setSelection(Polygon<t_type>&& poly)
        {
            cleanup();
            m_mode = e_selection_polygon;
            new (&m_polygon) Polygon<t_type>(); 
            std::swap(poly, m_polygon);
        }
 
        void setSelection(const Bounds<t_dims, t_type>& bounds)
        {
            cleanup();
            m_mode = e_selection_bounds;
            m_bounds = bounds;
        }
 
        void setSelection(const Plane<t_dims, t_type>& plane)
        {
            cleanup();
            m_mode = e_selection_plane;
            m_plane = plane;
        }
        SelectionMode mode() const { return m_mode; }
 
        const Vertex<t_dims, t_type>& point() const { return m_point; }
        Vertex<t_dims, t_type>& point() { return m_point; }
 
        const LineSegment<t_dims, t_type>& line() const { return m_line; }
        LineSegment<t_dims, t_type>& line() { return m_line; }
 
        const Bounds<t_dims, t_type>& bounds() const { return m_bounds; }
        Bounds<t_dims, t_type>& bounds() { return m_bounds; }
 
        const Polygon<t_type>& polygon() const { return m_polygon; }
        Polygon<t_type>& polygon() { return m_polygon; }
 
        const Plane<t_dims, t_type>& plane() const { return m_plane; }
        Plane<t_dims, t_type>& plane() { return m_plane; }
 
        
 
        void setTransform(const Matrix<t_type>& matrix) 
        { 
            m_matrix = matrix;
            m_inverse_matrix = matrix.invert();
            m_is_pre_transformed = (matrix == Matrix<t_type>(1.0));
        }
 
        void setProjectionMatrix(const Matrix<t_type>& matrix)
        {
            if (!IsInvalid(matrix))
            {
                m_projection_matrix = matrix;
                m_projection_inverse_matrix = matrix.invert();
            }
        }
        const Matrix<t_type>& transform() const 
        { 
            return m_matrix; 
        }
 
        const Matrix<t_type>& projectionTransform() const
        {
            return m_projection_matrix;
        }
        const Matrix<t_type>& inverseTransform() const
        {
            return m_inverse_matrix;
        }
        const Matrix<t_type>& inversePerspectiveTransform() const
        {
            return m_projection_inverse_matrix;
        }
        Bounds<t_dims, t_type> selectionBounds() const
        {
            switch (m_mode)
            {
            case e_selection_point: return Bounds<t_dims, t_type>(m_point);
            case e_selection_line: return Bounds<t_dims, t_type>(m_line);
            case e_selection_bounds: return m_bounds;
            case e_selection_polygon: return m_polygon.bounds().template as<t_dims, t_type>();
            case e_selection_plane:
            {
                Bounds<t_dims, t_type> bounds = Constant<Bounds<t_dims, t_type>>::Max;
                for (uint01 dim = 0; dim < t_dims; dim++)
                {
                    if (m_plane.normal[dim] == 1)
                        bounds[dim][MAX] = bounds[dim][MIN] = m_plane.d;
                    else if (m_plane.normal[dim] == -1)
                        bounds[dim][MAX] = bounds[dim][MIN] = -m_plane.d;
                }
                return bounds;
            }
            default: lib_assert(false, "Unknown selection area mode in as()"); break;
            }
            return Constant<Bounds<t_dims, t_type>>::Invalid;
        }
 
        template<uint01 t_new_dims, class t_new_type>
        SelectionArea<t_new_dims, t_new_type> as() const
        {
            SelectionArea<t_new_dims, t_new_type> new_selection;
            switch (m_mode)
            {
            case e_selection_point: new_selection.setSelection(m_point.template as<t_new_dims, t_new_type>()); break;
            case e_selection_line: new_selection.setSelection(m_line.template as<t_new_dims, t_new_type>()); break;
            case e_selection_bounds: new_selection.setSelection(m_bounds.template as<t_new_dims, t_new_type>()); break;
            case e_selection_polygon: new_selection.setSelection(m_polygon.template as<t_new_type>()); break;
            case e_selection_plane: new_selection.setSelection(m_plane.template as<t_new_dims, t_new_type>()); break;
            default: lib_assert(false, "Unknown selection area mode in as()"); break;
            }
            new_selection.setProjectionMatrix(m_projection_matrix.template as<t_new_type>());
            new_selection.setTransform(m_matrix.template as<t_new_type>());
            new_selection.setIsInverse(m_is_inverse);
            new_selection.setIsEnabled(m_is_enabled);
            return new_selection;
        }
        bool isPreTransformed() const
        {
            return m_is_pre_transformed;
        }
        template<uint01 t_new_dims, class t_new_type>
        SelectionArea<t_new_dims, t_new_type> preTransformed() const
        {
            SelectionArea<t_new_dims, t_new_type> area;
            if (sizeof(t_new_type) > sizeof(t_type))
            {
                Matrix<t_new_type> matrix = m_matrix.template as<t_new_type>().invert();
                
                switch (m_mode)
                {
                case e_selection_point: area.setSelection(matrix * m_point.template as<t_new_dims, t_new_type>()); break;
                case e_selection_line: area.setSelection(matrix * m_line.template as<t_new_dims, t_new_type>()); break;
                case e_selection_bounds: area.setSelection(matrix * m_bounds.template as<t_new_dims, t_new_type>()); break;
                case e_selection_polygon: area.setSelection(matrix * m_polygon.template as<t_new_type>()); break;
                default: lib_assert(false, "Unknown object to pre-transform");
                }
            }
            else//we want higher precision so multiply first
            {
                Matrix<t_type> matrix = m_matrix.invert();
                switch (m_mode)
                {
                case e_selection_point: area.setSelection((matrix * m_point).template as<t_new_dims, t_new_type>()); break;
                case e_selection_line: area.setSelection((matrix * m_line).template as<t_new_dims, t_new_type>()); break;
                case e_selection_bounds: area.setSelection((matrix * m_bounds).template as<t_new_dims, t_new_type>()); break;
                case e_selection_polygon: area.setSelection((matrix * m_polygon).template as<t_new_type>()); break;
                default: lib_assert(false, "Unknown object to pre-transform");
                }
            }
            area.setIsEnabled(m_is_enabled);
            area.setIsInverse(m_is_inverse);
            area.setProjectionMatrix(m_projection_matrix.template as<t_new_type>());
            return area;
        }
 
        void preTransform(const Matrix<t_type>& mat)
        {
            switch (m_mode)
            {
            case e_selection_point: setSelection(mat * m_point); break;
            case e_selection_line: setSelection(mat * m_line); break;
            case e_selection_bounds: setSelection(mat * m_bounds); break;
            case e_selection_polygon: setSelection(mat * m_polygon); break;
            default: lib_assert(false, "Unknown object to pre-transform");
            }
        }
        bool isInverse() const
        {
            return m_is_inverse;
        }
        void setIsInverse(bool is_inverse)
        {
            m_is_inverse = is_inverse;
        }
        bool isEnabled() const
        {
            return m_is_enabled;
        }
        void setIsEnabled(bool is_enabled)
        {
            m_is_enabled = is_enabled;
        }
        bool operator==(const SelectionArea& area) const
        {
            if(m_mode != area.m_mode)
                return false;
            switch(m_mode) 
            {
            case SelectionMode::e_selection_bounds:
                if(m_bounds != area.m_bounds)
                    return false;
                break;
            case SelectionMode::e_selection_line:
                if(m_line != area.m_line)
                    return false;
                break;
            case SelectionMode::e_selection_polygon:
                if(m_polygon != area.m_polygon)
                    return false;
                break;
            case SelectionMode::e_selection_point:
                if(m_point != area.m_point)
                    return false;
                break;
            case SelectionMode::e_selection_plane:
                if (m_plane != area.m_plane)
                    return false;
                break;
            default:
                lib_assert(false, "unknown selection mode");
            }
            return m_matrix == area.m_matrix && m_projection_matrix == area.m_projection_matrix;
        }
        bool operator!=(const SelectionArea& area) const
        {
            if(m_mode != area.m_mode)
                return true;
            switch(m_mode) 
            {
            case SelectionMode::e_selection_bounds:
                if(m_bounds != area.m_bounds)
                    return true;
                break;
            case SelectionMode::e_selection_line:
                if(m_line != area.m_line)
                    return true;
                break;
            case SelectionMode::e_selection_polygon:
                if(m_polygon != area.m_polygon)
                    return false;
                break;
            case SelectionMode::e_selection_point:
                if(m_point != area.m_point)
                    return true;
                break;
            case SelectionMode::e_selection_plane:
                if (m_plane != area.m_plane)
                    return true;
                break;
            default:
                lib_assert(false, "unknown selection mode");
            }
            return m_matrix != area.m_matrix || m_projection_matrix != area.m_projection_matrix;
        }
    protected:
        void cleanup()
        {
            if(m_mode == e_selection_polygon)
            {
                m_polygon.~Polygon<t_type>();
                m_mode = e_selection_point;
            }
        }
    protected:
        Matrix<t_type> m_matrix = Matrix<t_type>(1);
        Matrix<t_type> m_inverse_matrix = Matrix<t_type>(1);
        Matrix<t_type> m_projection_matrix = Matrix<t_type>(1);
        Matrix<t_type> m_projection_inverse_matrix = Matrix<t_type>(1);
        union
        {
            Vertex<t_dims, t_type> m_point;
            LineSegment<t_dims, t_type> m_line;
            Bounds<t_dims, t_type> m_bounds;
            Polygon<t_type> m_polygon;
            Plane<t_dims, t_type> m_plane;
        };
        SelectionMode m_mode;
        bool m_is_pre_transformed;
        bool m_is_inverse;
        bool m_is_enabled;
    };
 
    /**--------------------------------------------------------------------------------------------------
        Classifies.
 
    Author: Tyler Parke
 
    Date: 2018-03-26
 
    Parameters:
    other -    The vector.
    area -     The radians.
 
    \returns The IntersectionTypes.
    **/
    template<class t_other_type, uint01 t_dims, class t_type>
    IntersectionTypes classify(const t_other_type& other, const SelectionArea<t_dims, t_type>& area)
    {
        if(!area.isEnabled())
        {
            if(area.isInverse())
                return inside;
            else
                return outside;
        }
        //t_other_type trans_other = area.isPreTransformed() ? other : area.transform() * other;
        IntersectionTypes intersection;
        if (area.isPreTransformed())
        {
            switch (area.mode())
            {
            case e_selection_line:
                intersection = classify(other, area.line());
                break;
            case e_selection_bounds:
                intersection = classify(other, area.bounds());
                break;
            case e_selection_polygon:
                intersection = classify(other, area.polygon());
                break;
            case e_selection_plane:
                intersection = classify(other, area.plane());
                break;
            default:
                lib_assert(false, "unknown intersection");
                intersection = IntersectionTypes::outside;
                break;
            }
        }
        else
        {
            switch (area.mode())
            {
            case e_selection_line:
                intersection = classify(other, area.inverseTransform() * area.line());
                break;
            case e_selection_bounds:
                intersection = classify(other, area.inverseTransform() * area.bounds());
                break;
            case e_selection_polygon:
                intersection = classify(area.transform() * other, area.polygon());
                break;
            case e_selection_plane:
                intersection = classify(other, area.inverseTransform() * area.plane());
                break;
            default:
                lib_assert(false, "unknown intersection");
                intersection = IntersectionTypes::outside;
                break;
            }
        }
        if(area.isInverse())
        {
            switch(intersection)
            {
            case outside: intersection = inside; break;
            case inside: intersection = outside; break;
            default: break;
            }
        }
        return intersection;
    }
    template<class t_other_type, uint01 t_dims, class t_type>
    IntersectionTypes classify(const SelectionArea<t_dims, t_type>& area, const t_other_type& other)
    {
        if(!area.isEnabled())
        {
            if(area.isInverse())
                return inside;
            else
                return outside;
        }
        IntersectionTypes intersection = outside;
        if (area.isPreTransformed())
        {
            switch (area.mode())
            {
            case e_selection_line:
                intersection = classify(area.line(), other);
                break;
            case e_selection_bounds:
                intersection = classify(area.bounds(), other);
                break;
            case e_selection_polygon:
                intersection = classify(area.polygon(), other.template as<2, t_type>());
                break;
            case e_selection_plane:
                intersection = classify(area.plane(), other);
                break;
            default:
                break;
            }
        }
        else
        {
            switch (area.mode())
            {
            case e_selection_line:
                intersection = classify(area.line(), area.transform() * other);
                break;
            case e_selection_bounds:
                intersection = classify(area.bounds(), area.transform() * other);
                break;
            case e_selection_polygon:
                intersection = classify(area.polygon(), (area.transform() * other).template as<2, t_type>());
                break;
            case e_selection_plane:
                intersection = classify(area.plane(), area.transform() * other);
                break;
            default:
                break;
            }
        }
        if (area.isInverse())
        {
            switch (intersection)
            {
            case outside: intersection = inside; break;
            case inside: intersection = outside; break;
            default: break;
            }
        }
        return intersection;
    }
 
    template<class t_other_type, uint01 t_dims, class t_type>
    constexpr t_type distanceSquared(const t_other_type& other, const SelectionArea<t_dims, t_type>& area)
    {
        return distanceSquared(area, other);
    }
    template<class t_other_type, uint01 t_dims, class t_type>
    constexpr t_type distanceSquared(const SelectionArea<t_dims, t_type>& area, const t_other_type& other)
    {
        if (area.isPreTransformed())
        {
            switch (area.mode())
            {
            case e_selection_point:
                return distanceSquared(area.point(), other);
            case e_selection_line:
                return distanceSquared(area.line(), other);
            case e_selection_polygon:
                return distanceSquared(area.polygon(), other);
            case e_selection_bounds:
                return distanceSquared(area.bounds(), other);
            case e_selection_plane:
                //distanceSquared(area.radius(), n_vertex);
                break;
            }
        }
        else
        {
            switch (area.mode())
            {
            case e_selection_point:
                return distanceSquared(area.point(), area.transform() * other);
            case e_selection_line:
                return distanceSquared(area.line(), area.transform() * other);
            case e_selection_polygon:
                return distanceSquared(area.polygon(), area.transform() * other);
            case e_selection_bounds:
                return distanceSquared(area.bounds(), area.transform() * other);
            case e_selection_plane:
                //distanceSquared(area.radius(), n_vertex);
                break;
            }
        }
        return Constant<t_type>::Max;
    }
    
}