UnitTypes.h

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: Units
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/String.h>
#include "DLLInfo.h"
#include <NDEVR/Unit.h>
namespace NDEVR
{
 
    /**--------------------------------------------------------------------------------------------------
    \brief A unit that simply references another but with a custom name and ID
    **/
    class INIFactory;
    struct NDEVR_BASE_API ReferenceUnit : public Unit
    {
        const Unit& reference;
        ReferenceUnit(String name, TranslatedString translated_id, const Unit& reference)
            : Unit(name, translated_id)
            , reference(reference)
        {
            axis_abbreviations[0] = reference.axis_abbreviations[0];
            axis_abbreviations[1] = reference.axis_abbreviations[1];
            axis_abbreviations[2] = reference.axis_abbreviations[2];
            axis_abbreviations[3] = reference.axis_abbreviations[3];
        }
        
        [[nodiscard]] virtual fltp08 convertToUnit(const fltp08& program_space, const uint01 direction = X) const override
        {
            return reference.convertToUnit(program_space, direction);
        }
        [[nodiscard]] virtual fltp08 convertFromUnit(const fltp08& program_space, const uint01 direction = X) const override
        {
            return reference.convertToUnit(program_space, direction);
        }
        [[nodiscard]] virtual Vertex<3, fltp08> convertToUnit(const Vertex<3, fltp08>& program_space) const override
        {
            return reference.convertToUnit(program_space);
        }
        [[nodiscard]] virtual Vertex<3, fltp08> convertFromUnit(const Vertex<3, fltp08>& program_space) const override
        {
            return reference.convertFromUnit(program_space);
        }
        [[nodiscard]] virtual Ray<3, fltp08> convertToUnit(const Ray<3, fltp08>& program_space) const override
        {
            return reference.convertToUnit(program_space);
        }
        [[nodiscard]] virtual Ray<3, fltp08> convertFromUnit(const Ray<3, fltp08>& program_space) const override
        {
            return reference.convertFromUnit(program_space);
        }
        [[nodiscard]] virtual String convertToString(const fltp08& program_space, bool add_comma, uint04 min_decimals, uint04 max_decimals, uint04 min_digits, bool include_abv = true, uint01 direction = X) const override
        {
            return reference.convertToString(program_space, add_comma, min_decimals, max_decimals, min_digits, include_abv, direction);
        }
        virtual void toString(String& s, const fltp08& program_space, bool add_comma, uint04 min_decimals, uint04 max_decimals, uint04 min_digits, bool include_abv = true, uint01 direction = X) const override
        {
            reference.toString(s, program_space, add_comma, min_decimals, max_decimals, min_digits, include_abv, direction);
        }
        [[nodiscard]] virtual fltp08 convertFromString(const String& unit_string, uint01 direction = X) const override
        {
            return reference.convertFromString(unit_string, direction);
        }
        [[nodiscard]] virtual fltp08 fromString(const String& unit_string, uint01 direction = X) const override
        {
            return reference.fromString(unit_string, direction);
        }
        [[nodiscard]] virtual const TranslatedString& abbreviation(uint01 direction = X) const override
        {
            return reference.abbreviation(direction);
        }
        
        [[nodiscard]] virtual String getNextPreferredSeparator(const String& current_string, uint01 direction = X) const override
        {
            return reference.getNextPreferredSeparator(current_string, direction);
        }
 
        [[nodiscard]] virtual String toFormula(const String& unit_string, uint01 direction = X) const override
        {
            return reference.toFormula(unit_string, direction);
        }
        [[nodiscard]] virtual fltp08 epsilon(fltp08 value, uint01 direction = X) const override
        {
            return reference.epsilon(value, direction);
        }
        [[nodiscard]] virtual const Unit* subUnit(uint01 direction) const override
        {
            return reference.subUnit(direction);
        }
        [[nodiscard]] virtual Matrix<fltp08> matrix() const override
        {
            return reference.matrix();
        }
    };
    /**--------------------------------------------------------------------------------------------------
    \brief A unit that describes a simple scale (think meters vs feet)
    **/
    struct NDEVR_BASE_API ScaledUnit : public Unit
    {
        const fltp08 scale;
        const TranslatedString core_abbreviation;
        ScaledUnit(String name, TranslatedString translated_id, TranslatedString abbreviation, fltp08 scale)
            : Unit(std::move(name), std::move(translated_id))
            , scale(scale)
            , core_abbreviation(abbreviation)
        {}
 
        [[nodiscard]] virtual fltp08 convertToUnit(const fltp08& program_space, const uint01 direction = X) const override
        {
            lib_assert(direction < 3, "Out of bounds direction");
            UNUSED(direction);
            return program_space * scale;
        }
        [[nodiscard]] virtual fltp08 convertFromUnit(const fltp08& program_space, const uint01 direction = X) const override
        {
            lib_assert(direction < 3, "Out of bounds direction");
            UNUSED(direction);//Not used for simple conversions
            return program_space / scale;
        }
        [[nodiscard]] virtual Vertex<3, fltp08> convertToUnit(const Vertex<3, fltp08>& program_space) const override
        {
            return Vertex<3, fltp08>(scale * program_space);
        }
        [[nodiscard]] virtual Vertex<3, fltp08> convertFromUnit(const Vertex<3, fltp08>& program_space) const override
        {
            return Vertex<3, fltp08>(program_space / scale);
        }
        [[nodiscard]] virtual Ray<3, fltp08> convertToUnit(const Ray<3, fltp08>& program_space) const override
        {
            return scale * program_space;
        }
        [[nodiscard]] virtual Ray<3, fltp08> convertFromUnit(const Ray<3, fltp08>& program_space) const override
        {
            return program_space / scale;
        }
        [[nodiscard]] virtual String convertToString(const fltp08& program_space, bool add_comma, uint04 min_decimals, uint04 max_decimals, uint04 min_digits, bool include_abv = true, uint01 direction = X) const override
        {
            return toString(convertToUnit(program_space, direction), add_comma, min_decimals, max_decimals, min_digits, include_abv, direction);
        }
        [[nodiscard]] virtual fltp08 convertFromString(const String& unit_string, uint01 direction = X) const override
        {
            return convertFromUnit(fromString(unit_string, direction), direction);
        }
        [[nodiscard]] virtual fltp08 fromString(const String& unit_string, uint01 direction = X) const override
        {
            UNUSED(direction);
            return unit_string.getAs<fltp08>();
        }
        [[nodiscard]] virtual const TranslatedString& abbreviation(uint01 direction = X) const override
        {
            UNUSED(direction);
            return core_abbreviation;
        }
        [[nodiscard]] virtual const Unit* subUnit(uint01) const override
        {
            return this;
        }
        [[nodiscard]] virtual Matrix<fltp08> matrix() const override
        {
            return Matrix<fltp08>::ScalerMatrix(scale);
        }
        [[nodiscard]] virtual Unit* clone(const String& name, const TranslatedString& translated_id) const override;;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief A unit that has both a scale and an offset (think degrees celcius vs fahrenheit)
    **/
    struct NDEVR_BASE_API ScaledOffsetUnit : public Unit
    {
        const fltp08 scale;
        const fltp08 offset;
        const TranslatedString core_abbreviation;
        ScaledOffsetUnit(String name, TranslatedString translated_id, TranslatedString abbreviation, fltp08 scale, fltp08 offset)
            : Unit(std::move(name), std::move(translated_id))
            , scale(scale)
            , offset(offset)
            , core_abbreviation(abbreviation)
        {}
 
        [[nodiscard]] virtual fltp08 convertToUnit(const fltp08& program_space, const uint01 direction = X) const override
        {
            lib_assert(direction < 3, "Out of bounds direction");
            UNUSED(direction);
            return program_space * scale + offset;
        }
        [[nodiscard]] virtual fltp08 convertFromUnit(const fltp08& program_space, const uint01 direction = X) const override
        {
            lib_assert(direction < 3, "Out of bounds direction");
            UNUSED(direction);//Not used for simple conversions
            return (program_space - offset) / scale;
        }
        [[nodiscard]] virtual Vertex<3, fltp08> convertToUnit(const Vertex<3, fltp08>& program_space) const override
        {
            return scale * program_space + offset;
        }
        [[nodiscard]] virtual Vertex<3, fltp08> convertFromUnit(const Vertex<3, fltp08>& program_space) const override
        {
            return (program_space - offset) / scale;
        }
        [[nodiscard]] virtual Ray<3, fltp08> convertToUnit(const Ray<3, fltp08>& program_space) const override
        {
            return scale * program_space + offset;
        }
        [[nodiscard]] virtual Ray<3, fltp08> convertFromUnit(const Ray<3, fltp08>& program_space) const override
        {
            return (program_space - offset) / scale;
        }
        
        [[nodiscard]] virtual const TranslatedString& abbreviation(uint01 direction = X) const override
        {
            UNUSED(direction);
            return core_abbreviation;
        }
        [[nodiscard]] virtual const Unit* subUnit(uint01) const override
        {
            return this;
        }
        [[nodiscard]] virtual Matrix<fltp08> matrix() const override
        {
            return Matrix<fltp08>::ScalerMatrix(scale);
        }
 
        [[nodiscard]] virtual Unit* clone(const String& new_name, const TranslatedString& new_display_name) const override
        {
            ScaledOffsetUnit* unit = new ScaledOffsetUnit(new_name, new_display_name, abbreviation(), scale, offset);
            unit->axis_abbreviations[0] = axis_name_ids[0];
            unit->axis_abbreviations[1] = axis_name_ids[1];
            unit->axis_abbreviations[2] = axis_name_ids[2];
            unit->axis_abbreviations[3] = axis_name_ids[3];
            return unit;
        }
    };
    /**--------------------------------------------------------------------------------------------------
    \brief A unit that has a complex rotational offset. Think northing-easting vs easting-southing
    **/
    struct NDEVR_BASE_API MatrixUnit : public ReferenceUnit
    {
        const Matrix<fltp08> local_matrix;
        MatrixUnit(String name, const TranslatedString& translated_id, const Matrix<fltp08>& mat, const Unit& base)
            : ReferenceUnit(std::move(name), std::move(translated_id), base)
            , local_matrix(mat * base.matrix())
        {}
 
        [[nodiscard]] virtual fltp08 convertToUnit(const fltp08& program_space, const uint01 direction = X) const override;
        [[nodiscard]] virtual fltp08 convertFromUnit(const fltp08& program_space, const uint01 direction = X) const override;
        [[nodiscard]] virtual Vertex<3, fltp08> convertToUnit(const Vertex<3, fltp08>& program_space) const override;
        [[nodiscard]] virtual Vertex<3, fltp08> convertFromUnit(const Vertex<3, fltp08>& program_space) const override;
        [[nodiscard]] virtual Ray<3, fltp08> convertToUnit(const Ray<3, fltp08>& program_space) const override;
        [[nodiscard]] virtual Ray<3, fltp08> convertFromUnit(const Ray<3, fltp08>& program_space) const override;
 
        [[nodiscard]] virtual fltp08 epsilon(fltp08 value, uint01 direction = X) const override;
        [[nodiscard]] virtual Matrix<fltp08> matrix() const override
        {
            return local_matrix;
        }
        [[nodiscard]] virtual const Unit* subUnit(uint01) const override
        {
            return &reference;
        }
        [[nodiscard]] virtual Unit* clone(const String& name, const TranslatedString& translated_id) const override;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief A unit that has two parts (Think feet, inches)
    **/
    struct NDEVR_BASE_API TwoPartUnit : public ScaledUnit
    {
        TwoPartUnit(const String& name, const TranslatedString& translated_id, const TranslatedString& abr_major, const TranslatedString& abr_minor, fltp08 scale, fltp08 sub_unit);
 
        void toString(String& string, const fltp08& local_space, bool add_comma, uint04 min_decimals, uint04 max_decimals, uint04 min_digits, bool include_abv = true, uint01 direction = X) const override;
        [[nodiscard]] virtual fltp08 fromString(const String& unit_string, uint01 direction = X) const override;
        [[nodiscard]] virtual fltp08 epsilon(fltp08 value, uint01 direction) const override;
 
        [[nodiscard]] virtual String getNextPreferredSeparator(const String& string, uint01 direction) const override;
 
        [[nodiscard]] virtual Unit* clone(const String& name, const TranslatedString& translated_id) const override;
        const TranslatedString abr_major;
        const TranslatedString abr_minor;
        const fltp08 sub_unit;
        uint04 max_decimal_digits;
    };
    /**--------------------------------------------------------------------------------------------------
    Class: AngleUnit
 
    \brief Contains logic for converting angles into user defined units including up-direction and clockwise-logic.
    **/
    struct NDEVR_BASE_API AngleUnit : public ScaledUnit
    {
        AngleUnit(const String& name, const TranslatedString& translated_name, const TranslatedString& abbreviation, fltp08 scale);
    protected:
        AngleUnit(const String& name, const TranslatedString& translated_name, const TranslatedString& abbreviation, fltp08 scale, const Vector<3, bool>& normalized,
            const Vector<3, fltp08>& upper_limits,
            const Vector<3, fltp08>& reflexes, const Vector<3, bool>& reflexes_up);
    public:
        virtual ~AngleUnit() = default;
        [[nodiscard]] virtual fltp08 convertToUnit(const fltp08& program_space, uint01 direction = X) const override;
        [[nodiscard]] virtual fltp08 normalize(fltp08 value, uint01 direction) const;
        [[nodiscard]] virtual fltp08 denormalize(fltp08 value, uint01 direction) const;
        [[nodiscard]] virtual fltp08 convertFromUnit(const fltp08& program_space, uint01 direction = X) const override;
 
        [[nodiscard]] virtual Vertex<3, fltp08> convertToUnit(const Vertex<3, fltp08>& program_space) const override;
 
        [[nodiscard]] virtual Ray<3, fltp08> convertToUnit(const Ray<3, fltp08>& program_space) const override;
 
        [[nodiscard]] virtual Vertex<3, fltp08> convertFromUnit(const Vertex<3, fltp08>& program_space) const override;
        [[nodiscard]] virtual Ray<3, fltp08> convertFromUnit(const Ray<3, fltp08>& program_space) const override;
        [[nodiscard]] virtual Unit* clone(const String& name, const TranslatedString& translated_id) const override;
        [[nodiscard]] virtual fltp08 epsilon(fltp08 value, uint01 direction = X) const override;
 
        fltp08 period = 2.0 * Angle<fltp08>::INDEX_PI;
        Vector<3, fltp08> upper_limits = Vector<3, fltp08>(2.0 * Angle<fltp08>::INDEX_PI);
        Vector<3, fltp08> reflex_point = Constant<Vector<3, fltp08>>::Invalid;
        Vector<3, bool> normalized = Vector<3, bool>(false);
        Vector<3, bool> reflexes_up = Vector<3, bool>(false);
    };
    /**--------------------------------------------------------------------------------------------------
    \brief An angle unit that contains two-parts (Degrees, Minutes)
    **/
    struct NDEVR_BASE_API TwoPartAngleUnit : public AngleUnit
    {
        TwoPartAngleUnit(const String& name, const TranslatedString& translated_name, const TranslatedString& abr_major, const TranslatedString& abr_minor, fltp08 sub_unit, const AngleUnit& angle_unit);
        TwoPartAngleUnit(const String& name, const TranslatedString& translated_name, const TranslatedString& abr_major, const TranslatedString& abr_minor, fltp08 sub_unit, fltp08 scale, const Vector<3, bool>& normalized, Vector<3, fltp08> upper_limits, Vector<3, fltp08> reflex_point, Vector<3, bool> reflexes_up);
        void toString(String& string, const fltp08& local_space, bool add_comma, uint04 min_decimals, uint04 max_decimals,
            uint04 min_digits, bool use_abv = true, uint01 direction = X) const override;
 
        fltp08 fromString(const String& unit_string, uint01 direction = X) const override;
 
 
        String getNextPreferredSeparator(const String& string, uint01 direction = X) const override;
        fltp08 epsilon(fltp08 value, uint01 direction = X) const override;
        [[nodiscard]] virtual Unit* clone(const String& name, const TranslatedString& translated_id) const override;
        const TranslatedString abr_major;
        const TranslatedString abr_minor;
        const fltp08 sub_unit;
        uint04 max_decimal_digits;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief An angle unit that contains two-parts (Degrees, Minutes, Seconds)
    **/
    struct NDEVR_BASE_API ThreePartAngleUnit : public AngleUnit
    {
        ThreePartAngleUnit(const String& name, const TranslatedString& translated_name, const TranslatedString& abr_major, const TranslatedString& abr_minor_a, const TranslatedString& abr_minor_b, fltp08 sub_unit_a, fltp08 sub_unit_b, const AngleUnit& angle_unit);
 
        ThreePartAngleUnit(const String& name, const TranslatedString& translated_name, const TranslatedString& abr_major, const TranslatedString& abr_minor_a, const TranslatedString& abr_minor_b, fltp08 sub_unit_a, fltp08 sub_unit_b, fltp08 scale, const Vector<3, bool>& normalized, Vector<3, fltp08> upper_limits, Vector<3, fltp08> reflex_point, Vector<3, bool> reflexes_up);
        void toString(String& string, const fltp08& local_space, bool add_comma, uint04 min_decimals, uint04 max_decimals,
            uint04 min_digits, bool use_abv = true, uint01 direction = X) const override;
 
        fltp08 fromString(const String& unit_string, uint01 direction = X) const override;
 
        String getNextPreferredSeparator(const String& current_string, uint01 direction = X) const override;
 
        fltp08 epsilon(fltp08 value, uint01 direction = X) const override;
        [[nodiscard]] virtual Unit* clone(const String& name, const TranslatedString& translated_id) const override;
        const TranslatedString abr_major;
        const TranslatedString abr_minor_a;
        const TranslatedString abr_minor_b;
        const fltp08 sub_unit_a;
        const fltp08 sub_unit_b;
        uint04 max_decimal_digits;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Degrees, Minutes, Seconds stored in a compact way where degrees and minutes are seperated by
        a decimal and minutes and secons are always 2 decimals.
    **/
    struct NDEVR_BASE_API DDMMSSAngleUnit : public AngleUnit
    {
        DDMMSSAngleUnit(const String& name, const TranslatedString& translated_name, const TranslatedString& abbreviation, fltp08 scale, const Vector<3, bool>& normalized, const Vector<3, fltp08>& upper_limits, const Vector<3, fltp08>& reflexes, const Vector<3, bool>& reflexes_up);
        DDMMSSAngleUnit(const String& name, const TranslatedString& translated_name, const TranslatedString& abbreviation, const AngleUnit& unit);
        void toString(String& string, const fltp08& local_space, bool add_comma, uint04 min_decimals, uint04 max_decimals, uint04 min_digits, bool use_abv = true, uint01 direction = X) const override;
        fltp08 fromString(const String& unit_string, uint01 direction = X) const override;
 
        String getNextPreferredSeparator(const String& string, uint01 direction = X) const override;
        fltp08 epsilon(fltp08 value, uint01 direction = X) const override;
 
        [[nodiscard]] virtual Unit* clone(const String& name, const TranslatedString& translated_id) const override;
        uint04 max_decimal_digits;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief An Unit that has both a location and elevation (Think Lat/Lon which has meters for elevation)
    **/
    struct NDEVR_BASE_API LocationElevationUnit : public Unit
    {
        LocationElevationUnit(String name, TranslatedString translated_id, const Unit* location_unit, const Unit* elevation_unit);
        [[nodiscard]] virtual fltp08 convertToUnit(const fltp08& program_space, uint01 direction = X) const override;
        [[nodiscard]] virtual fltp08 convertFromUnit(const fltp08& program_space, uint01 direction = X) const override;
        [[nodiscard]] virtual Vertex<3, fltp08> convertToUnit(const Vertex<3, fltp08>& program_space) const override;
        [[nodiscard]] virtual Vertex<3, fltp08> convertFromUnit(const Vertex<3, fltp08>& program_space) const override;
        [[nodiscard]] virtual Ray<3, fltp08> convertToUnit(const Ray<3, fltp08>& program_space) const override;
        [[nodiscard]] virtual Ray<3, fltp08> convertFromUnit(const Ray<3, fltp08>& program_space) const override;
        [[nodiscard]] virtual String convertToString(const fltp08& program_space, bool add_comma, uint04 min_decimals, uint04 max_decimals, uint04 min_digits, bool include_abv = true, uint01 direction = X) const override;
        void toString(String& string, const fltp08& program_space, bool add_comma, uint04 min_decimals, uint04 max_decimals, uint04 min_digits, bool include_abv = true, uint01 direction = X) const override;
        [[nodiscard]] virtual fltp08 convertFromString(const String& unit_string, uint01 direction = X) const override;
        [[nodiscard]] virtual fltp08 fromString(const String& unit_string, uint01 direction = X) const override;
        [[nodiscard]] virtual const TranslatedString& abbreviation(uint01 direction = X) const override;
        [[nodiscard]] virtual String getNextPreferredSeparator(const String& current_string, uint01 direction = X) const override;
        [[nodiscard]] virtual String toFormula(const String& unit_string, uint01 direction = X) const override;
        [[nodiscard]] virtual const Unit* subUnit(uint01 direction) const override;
        [[nodiscard]] virtual Unit* clone(const String& name, const TranslatedString& translated_id) const override;
        fltp08 epsilon(fltp08 value, uint01 direction) const override; 
        [[nodiscard]] virtual TranslatedString translatedAxisName(uint04 index) const override;
        [[nodiscard]] virtual Matrix<fltp08> matrix() const override;
        const Unit* location_unit;
        const Unit* elevation_unit;
    };
    
 
}