Curve.h

//  trax track library
//  AD 2013 
//
//  "If there is something they need
//   If there is something they want
//   They've got to raise their hand!"
//
//                  Bruce Springsteen
//
// Copyright (c) 2025 Trend Redaktions- und Verlagsgesellschaft mbH
// Copyright (c) 2019 Marc-Michael Horstmann
//
// Permission is hereby granted to any person obtaining a copy of this software 
// and associated source code (the "Software"), to use, view, and study the 
// Software for personal or internal business purposes, subject to the following 
// conditions:
//
// 1. Redistribution, modification, sublicensing, or commercial use of the 
// Software is NOT permitted without prior written consent from the copyright 
// holder.
//
// 2. The Software is provided "AS IS", without warranty of any kind, express 
// or implied.
//
// 3. All copies of the Software must retain this license notice.
//
// For further information, please contact: horstmann.marc@trendverlag.de
 
#pragma once

 
#include "Configuration.h"
#include "Units.h"
 
#include <memory>
 
#include "common/Interval.h"
#include "spat/Frame.h"
#include "spat/Matrix.h"
#include "spat/VectorBundle.h"
#include "spat/VectorBundle2.h"
#include "spat/Vector2D.h"
 
 
namespace trax
{
    struct Curve{

        enum class CurveType{
            none    = 0,
            Line,               
            Arc,                
            Helix,              
            LineP,              
            ArcP,               
            HelixP,             
            Clothoid,           
            Cubic,              
            Spline,             
            Rotator,            
            RotatorWithOffset,  
            RotatorChain,       
            PolygonalChain,     
            SampledCurve,       
            Parallel,           
            EEPCurve,           
            EEPResidual,        
            EEPAlternative,     
            Unknown,            
            UserDefined         
        };
 

        virtual const char* TypeName() const noexcept = 0;
 

        virtual CurveType GetCurveType() const noexcept = 0;
 

        virtual bool IsValid() const noexcept = 0;
 

        virtual AnglePerLength Curvature( Length s ) const = 0;
 

        virtual AnglePerLength Torsion( Length s ) const = 0;
 

        virtual bool IsFlat() const noexcept = 0;
 

        virtual void Transition( Length s, spat::Position<Length>& pos ) const = 0;
 

        virtual void Transition( Length s, spat::Vector<One>& tan ) const = 0;
 

        virtual void Transition( Length s, spat::VectorBundle<Length,One>& bundle ) const = 0;
 

        virtual void Transition( Length s, spat::VectorBundle2<Length,One>& bundle ) const = 0;
 

        virtual void Transition( Length s, spat::Frame<Length,One>& frame ) const = 0;
 

        virtual std::vector<Length> ZeroSet() const = 0;
 

        virtual common::Interval<Length> Range() const = 0;
 

        virtual spat::Vector<One> LocalUp() const = 0;
 

        virtual spat::Frame<Length,One> GetCurveLocalTransformation() const = 0;
 

        virtual std::unique_ptr<Curve> Clone() const = 0;
 

        virtual bool Mirror( const spat::VectorBundle<Length,One>& mirrorPlane ) = 0;
 

        virtual bool Equals( const Curve& toCurve, common::Interval<Length> range, 
            Length epsilon_length = epsilon__length, 
            Angle epsilon_angle = epsilon__angle ) const = 0;
 
 
        virtual ~Curve() = default;
        Curve( Curve&& ) = delete;
        Curve& operator=( const Curve& ) = delete;
        Curve& operator=( Curve&& ) = delete;
    protected:
        Curve() = default;
        Curve( const Curve& ) = default;
    };
 

    template<class CurveType> inline
    std::unique_ptr<CurveType> Clone( const CurveType& curve ) noexcept{
        return common::dynamic_unique_cast<CurveType>(curve.Clone());
    }
 


    bool dclspc Equals( 
        const std::pair<std::shared_ptr<const Curve>,common::Interval<Length>>& A, 
        const std::pair<std::shared_ptr<const Curve>,common::Interval<Length>>& B, 
        Length epsilon_length = epsilon__length, 
        Angle epsilon_angle = epsilon__angle );

    bool dclspc Equals( 
        const Curve& A,
        const Curve& B,
        common::Interval<Length> range,
        Length epsilon_length = epsilon__length ) noexcept;
 

    dclspc const char* TypeToName( Curve::CurveType ct );
 

    dclspc Curve::CurveType CurveNameToType( const std::string& name ) noexcept;
 

    struct CurveSample{
        spat::Frame<Length,One> F;
        Length s;
        AnglePerLength k;
        AnglePerLength t;
 
        inline bool operator<( const CurveSample& sample ) const noexcept{
            return s < sample.s;
        }
 
        bool dclspc Equals( const CurveSample& sample, Length epsilon_length = epsilon__length, One epsilon_angle = epsilon__angle ) const noexcept;
    };
 
    inline bool operator<( Length s, const CurveSample& sample ) noexcept{
        return s < sample.s;
    }
 

    struct CubicData{
        CubicData() noexcept
            :   a{spat::Origin3D<Length>},
                b{25_m * spat::Ex<One>},
                c{-15_m * spat::Ex<One> + 15_m * spat::Ey<One>},
                d{10_m * spat::Ex<One> - 10_m * spat::Ey<One>}
        {}
 
        CubicData( const spat::Position<Length>& a, const spat::Vector<Length>& b, const spat::Vector<Length>& c, const spat::Vector<Length>& d ) noexcept
            :   a{a},
                b{b},
                c{c},
                d{d}
        {}
 
        CubicData( const spat::VectorBundle<Length>& start, const spat::VectorBundle<Length>& end ) noexcept
            :   a{start.P},
                b{start.T},
                c{3_1*(end.P - start.P) - end.T - 2_1*start.T},
                d{2_1*(start.P - end.P) + start.T + end.T}
        {}
        
        spat::Position<Length> a;
        spat::Vector<Length> b;
        spat::Vector<Length> c;
        spat::Vector<Length> d;
 
        inline bool operator!=( const CubicData& other ) const noexcept{
            return  a != other.a ||
                    b != other.b ||
                    c != other.c ||
                    d != other.d;
        }
 
        inline bool operator==( const CubicData& other ) const noexcept{
            return !operator!=( other );
        }                   
 
        inline spat::Position<Length> CubicPositionAtStart() const noexcept{
            return a;
        }
        inline spat::Vector<Length> CubicOvershootAtStart() const noexcept{
            return b;
        }
        inline spat::Position<Length> CubicPositionAtEnd() const noexcept{
            return a + b + c + d;
        }
        inline spat::Vector<Length> CubicOvershootAtEnd() const noexcept{
            return b + 2_1*c + 3_1*d;
        }
    };
 

    struct Line : Curve{

        static dclspc std::unique_ptr<Line> Make() noexcept;
    };
 

    struct LineP : Curve{

        static dclspc std::unique_ptr<LineP> Make() noexcept;
 

        struct Data{

            Data() noexcept{
                vb.Init();
            }
            Data( const spat::VectorBundle<Length,One>& vb, const spat::Vector<One>& up ) noexcept
                : vb{vb}, up{up}{}
        
            spat::VectorBundle<Length,One> vb;  
            spat::Vector<One> up = Up;          
        };
 

        
        virtual common::Interval<Length> Create( const spat::Position<Length>& start, const spat::Position<Length>& end, const spat::Vector<One>& up = Up ) = 0;

        virtual void Create( const spat::VectorBundle<Length,One>& start, const spat::Vector<One>& up = Up ) = 0;
 
        virtual void Create( const spat::VectorBundle2<Length,One>& start ) = 0;
 
        virtual void Create( const spat::Frame<Length,One>& start ) = 0;

        virtual void Create( const spat::Position<Length>& start, const spat::Vector<One>& tan, const spat::Vector<One>& up = Up ) = 0;
 
        virtual common::Interval<Length> Create( const Data& data ) = 0;
 

        virtual const Data& GetData() const noexcept = 0;
    };
 

    
    bool dclspc Equals( const LineP::Data& A, const LineP::Data& B, common::Interval<Length> range, 
        Length epsilon_length = epsilon__length, Angle epsilon_angle = epsilon__angle );
 

    struct Arc : Curve{

        static dclspc std::unique_ptr<Arc> Make() noexcept;

        struct Data{
            AnglePerLength k; 
 
            inline Length radius() const noexcept { return 1/k; } 
        };
 

        virtual spat::Matrix<One,2,3> Jacobian( Length s ) const = 0;
 

        virtual common::Interval<Length> Create( const Data& data ) = 0;
 

        virtual const Data& GetData() const noexcept = 0;
    };
 

    
    bool dclspc Equals( const Arc::Data& A, const Arc::Data& B, Length epsilon_length = epsilon__length ) noexcept;
 

    struct ArcP : Curve{

        static dclspc std::unique_ptr<ArcP> Make() noexcept;
 

        struct Data{
            Data() noexcept{
                vb2.Init();
                vb2.N *= _m(10_m);
            }
            Data( Length radius ) noexcept{
                vb2.Init();
                vb2.N *= _m(radius);
            }
            Data( const spat::VectorBundle2<Length,One>& vb2 ) noexcept
                : vb2{vb2}{}
        
            spat::VectorBundle2<Length,One> vb2;    
        };
 

        virtual Length Radius() const noexcept = 0;
 

        virtual spat::Matrix<One,2,3> Jacobian( Length s ) const = 0;
 

        
        virtual void Create( const spat::VectorBundle2<Length,One>& center ) = 0;
 

        virtual common::Interval<Length> Create( const spat::VectorBundle<Length,One>& start, const spat::Position<Length>& end, Angle e_angle = epsilon__angle ) = 0;
 

        virtual common::Interval<Length> Create( const spat::Position<Length>& start, const spat::VectorBundle<Length,One>& end, Angle e_angle = epsilon__angle ) = 0;
 

        virtual void Create( const spat::Position<Length>& start, const spat::Vector<One>& tan, const spat::Vector<One>& nor, AnglePerLength curvature ) = 0;
 

        virtual void Create( const spat::VectorBundle2<Length,One>& start, AnglePerLength curvature ) = 0;
 

        virtual common::Interval<Length> Create( const Data& data ) = 0;
 

        virtual const Data& GetData() const noexcept = 0;
    };
 


    bool dclspc Equals( const ArcP::Data& A, const ArcP::Data& B, common::Interval<Length> range, 
        Length epsilon_length = epsilon__length, Angle epsilon_angle = epsilon__angle );
 

    struct Helix : Curve{

        static dclspc std::unique_ptr<Helix> Make() noexcept;

        struct Data{
            Data() noexcept
                : k{0_1Im}, t{0_1Im}
            {}
            Data( AnglePerLength k, AnglePerLength t ) noexcept
                : k{k}, t{t}
            {}
            Data( Length a, Length b ) noexcept
                : k{a / (a*a + b*b)}, t{b / (a*a + b*b)}
            {}
 
            AnglePerLength k;   
            AnglePerLength t;   
 
            constexpr Length a() const noexcept { return k / (k*k + t*t); } 
            constexpr Length b() const noexcept { return t / (k*k + t*t); } 
            constexpr One slope() const noexcept { return b()/a(); };           
        };
 

        virtual spat::SquareMatrix<One,3> Jacobian( Length s ) const = 0;
 

        virtual common::Interval<Length> Create( const Data& data ) = 0;
 

        virtual const Data& GetData() const noexcept = 0;
    };
 


    bool dclspc Equals( const Helix::Data& A, const Helix::Data& B, Length epsilon_length = epsilon__length ) noexcept;
 

    struct HelixP : Curve{

        static dclspc std::unique_ptr<HelixP> Make() noexcept;
 

        struct Data{
            Data() noexcept
                :   a{10_m},
                    b{5_m/(2*pi)}
            {
                center.Init();
            }
            Data( Length radius, One slope ) noexcept
                :   a{radius},
                    b{radius*slope}
            {
                center.Init();
            }
            constexpr Data( const spat::VectorBundle2<Length,One>& center, Length a, Length b ) noexcept
                :   center{center},
                    a{a},
                    b{b}
            {}
 
        
            spat::VectorBundle2<Length,One> center; 
            Length a;                               
            Length b;                               
 
            constexpr AnglePerLength Curvature() noexcept { return a / (a*a + b*b); }
            constexpr AnglePerLength Torsion() noexcept { return b / (a*a + b*b); }
            constexpr One Slope() const noexcept { return b/a; };   
        };
 

        virtual spat::VectorBundle2<Length,One> Center() const noexcept = 0;
 

        virtual Length Radius() const noexcept = 0;
 

        virtual One Slope() const noexcept = 0;
 

        virtual spat::SquareMatrix<One,3> Jacobian( Length s ) const = 0;
 

        
        virtual void Create( const spat::Frame<Length,One>& start, AnglePerLength curvature, AnglePerLength torsion ) = 0;
 

        virtual common::Interval<Length> Create( const spat::VectorBundle<Length,One>& start, const spat::Position<Length>& end, const spat::Vector<One>& up = Up, Angle e_angle = epsilon__angle ) = 0;
 

        virtual common::Interval<Length> Create( const spat::Position<Length>& start, const spat::VectorBundle<Length,One>& end, const spat::Vector<One>& up = Up, Angle e_angle = epsilon__angle ) = 0;
 

        virtual void Create( const spat::VectorBundle2<Length,One>& center, AnglePerLength curvature, AnglePerLength torsion ) = 0;
 

        virtual common::Interval<Length> Create( const Data& data ) = 0;
 

        virtual const Data& GetData() const noexcept = 0;
    };
 


    bool dclspc Equals( const HelixP::Data& A, const HelixP::Data& B, common::Interval<Length> range, 
        Length epsilon_length = epsilon__length, Angle epsilon_angle = epsilon__angle );
 

    struct Cubic : Curve{

        static dclspc std::unique_ptr<Cubic> Make() noexcept;
 
 
        using Data = CubicData; 
 

        virtual spat::Vector<Length> CubicOvershootAt( Length s ) const noexcept = 0;
 


        virtual common::Interval<Length> Create( const spat::VectorBundle<Length,Length>& start, const spat::VectorBundle<Length,Length>& end ) = 0;
 

        virtual common::Interval<Length> CreateBezier( const spat::Position<Length>& P0, const spat::Position<Length>& P1, const spat::Position<Length>& P2, const spat::Position<Length>& P3 ) = 0;
 

        virtual std::pair<common::Interval<Length>,Length> Create( const Curve& originalCurve, common::Interval<Length> range, Length maxDeviation = epsilon__length ) = 0;
 

        virtual common::Interval<Length> Create( const Data& data ) = 0;
 

        virtual common::Interval<Length> Shorten( common::Interval<Length> toRange ) = 0;
 

        virtual const Data& GetData() const noexcept = 0;
    };
 


    bool dclspc Equals( const Cubic::Data& A, const Cubic::Data& B, common::Interval<Length> range, 
        Length epsilon_length = epsilon__length, Angle epsilon_angle = epsilon__angle ) noexcept;
 

    struct Spline : Curve{

        static dclspc std::unique_ptr<Spline> Make() noexcept;
 

        enum class WrapTypes{
            none = 0,
            nonperiodic, 
            periodic, 
            pinned 
        };
 
        using SegmentValueType = CubicData; 
        using Data = std::vector<SegmentValueType>;
 

        virtual int CountControlPoints() const noexcept = 0;
 

        virtual common::Interval<Length> ResetControlPointAndTangent( int idx, const spat::VectorBundle<Length>& controlPointAndTangent ) = 0;
 

        virtual spat::VectorBundle<Length> GetControlPointAndTangent( int idx ) const = 0;
 

        virtual Length GetParameter( int idx ) const = 0;
 

        virtual int UpperBound( Length s ) const = 0;
 

        virtual bool HasGaps( Length epsilon = epsilon__length ) const noexcept = 0;
 

        virtual bool HasKinks( Angle epsilon = epsilon__angle ) const noexcept = 0;
 

        
        virtual common::Interval<Length> Create( const Curve& originalCurve, common::Interval<Length> range, Length maxDeviation = epsilon__length, common::Interval<Length> sampleDistanceLimits = { 1_m, 1000_m } ) = 0;
        

        virtual common::Interval<Length> Create( std::pair<std::shared_ptr<const Curve>,common::Interval<Length>> originalCurve, Length maxDeviation = epsilon__length, common::Interval<Length> sampleDistanceLimits = { 1_m, 1000_m } ) = 0;
 

        virtual common::Interval<Length> Create( const std::vector<spat::VectorBundle<Length>>& controlPointsAndTangents ) = 0;
 

        virtual common::Interval<Length> Create( const std::vector<spat::Position<Length>>& controlPoints ) = 0;
 

        virtual common::Interval<Length> Create( const std::vector<spat::Position<Length>>& controlPoints, bool bClampedAtStart, const spat::Vector<Length>& startTangent, bool bClampedAtEnd, const spat::Vector<Length>& endTangent ) = 0;
 

        virtual common::Interval<Length> CreateCatmullRom( const std::vector<spat::Position<Length>>& controlPoints, One tension = 0.5f, WrapTypes wrap = WrapTypes::nonperiodic ) = 0;
 

        virtual common::Interval<Length> CreateCatmullRom( const std::vector<spat::VectorBundle<Length,One>>& controlPoints, One tension = 0.5f, WrapTypes wrap = WrapTypes::nonperiodic ) = 0;
 

        virtual common::Interval<Length> CreateBezier( const std::vector<spat::Position<Length>>& controlPoints, WrapTypes wrap = WrapTypes::nonperiodic ) = 0;
 

        virtual common::Interval<Length> Create( const Data& data ) = 0;
 

        virtual common::Interval<Length> Shorten( common::Interval<Length> toRange ) = 0;
 

        virtual const Data& GetData() const noexcept = 0;
    };
 


    bool dclspc Equals( const Spline::Data& A, const Spline::Data& B, common::Interval<Length> range, 
        Length epsilon_length = epsilon__length, Angle epsilon_angle = epsilon__angle ) noexcept;
 
 

    struct Clothoid : Curve{

        static dclspc std::unique_ptr<Clothoid> Make() noexcept;
 

        struct Data{
            Length a{ 100_m }; 
        };
 

        static Angle dclspc MaxAngle() noexcept;
 

        
        static std::tuple<common::Interval<AnglePerLength>, common::Interval<AnglePerLength>, common::Interval<Length>> 
        dclspc Limits( AnglePerLength curvature0, AnglePerLength curvature1, Length length );
 
        static std::tuple<common::Interval<Length>, common::Interval<Length>, common::Interval<Length>>
        dclspc Limits( Length radius0, Length radius1, Length length );
 

        virtual spat::SquareMatrix<One,2> Jacobian( Length s ) const = 0;
 

            
        virtual common::Interval<Length> Create( Area a2 ) = 0;
 

        virtual common::Interval<Length> Create( AnglePerLength curvature0, AnglePerLength curvature1, Length length ) = 0;
 

        virtual common::Interval<Length> Create( Length radius0, Length radius1, Length length ) = 0;
 

        virtual common::Interval<Length> Create( const Data& data ) = 0;
 

        virtual const Data& GetData() const noexcept = 0;
    };
 


    bool dclspc Equals( const Clothoid::Data& A, const Clothoid::Data& B, common::Interval<Length> range, 
        Length epsilon_length = epsilon__length, Angle epsilon_angle = epsilon__angle );
 

    struct Rotator : Curve{

        static dclspc std::unique_ptr<Rotator> Make( CurveType type = CurveType::Rotator ) noexcept;
 

        struct Data{
            AnglePerLength a = 0_1Im;   
            AnglePerLength b = 0_1Im;   
            Angle a0 = 0_deg;           
            Angle b0 = 0_deg;           
        };
 

        virtual spat::SquareMatrix<Real,3> Jacobian( Length s ) const = 0;
 

        virtual common::Interval<Length> Create( const Data& data ) = 0;
 

        virtual const Data& GetData() const noexcept = 0;
    };
 


    bool dclspc Equals( const Rotator::Data& A, const Rotator::Data& B, common::Interval<Length> range, 
        Length epsilon_length = epsilon__length, Angle epsilon_angle = epsilon__angle ) noexcept;
 

    struct RotatorChain : Curve{

        static dclspc std::unique_ptr<RotatorChain> Make() noexcept;
 
        using SegmentValueType = std::tuple<Angle,Angle,Length>;
        using Data = std::vector<SegmentValueType>;
 

        
        virtual common::Interval<Length> Create( const spat::Vector<Length>& advance ) = 0;
 

        virtual common::Interval<Length> Create( const Data& data ) = 0;

        virtual const Data& GetData() const noexcept = 0;
    };
 


    bool dclspc Equals( const RotatorChain::Data& A, const RotatorChain::Data& B, common::Interval<Length> range, 
        Length epsilon_length = epsilon__length, Angle epsilon_angle = epsilon__angle ) noexcept;
 
 
    struct Track;

    struct PointToPointParallel : Curve
    {
        struct Data{
            const Track* pTrack = nullptr;
            spat::Vector2D<Length> d = { 0_m, 0_m };
        };

        virtual common::Interval<Length> Create( const Data& data ) = 0;
 

        virtual const Data& GetData() const noexcept = 0;
 
        virtual Length OriginalParameterFrom( Length sParallelParameter ) const noexcept = 0;
 
        virtual Length ParallelParameterFrom( Length sOriginalParameter ) const noexcept = 0;
 
        virtual bool IsTrackRelative() const noexcept = 0;
    };
 


    bool dclspc Equals( const PointToPointParallel::Data& A, const PointToPointParallel::Data& B, common::Interval<Length> range, 
        Length epsilon_length = epsilon__length, Angle epsilon_angle = epsilon__angle ) noexcept;
 

    struct PolygonalChain : Curve{

        static dclspc std::unique_ptr<PolygonalChain> Make() noexcept;
 

        enum class WrapTypes{
            none = 0,
            nonperiodic, 
            periodic, 
        };
 
        using SegmentValueType = spat::VectorBundle<Length, One>; 
        using Data = std::vector<SegmentValueType>;

        virtual Length GetParameter( int idx ) const = 0;
 

        virtual int UpperBound( Length s ) const = 0;
 


        virtual common::Interval<Length> Create( const Curve& originalCurve, common::Interval<Length> range, Length maxDeviation, Length minPointDistance ) = 0;
 

        virtual common::Interval<Length> Create( std::pair<std::shared_ptr<const Curve>, common::Interval<Length>> originalCurve, Length maxDeviation, Length minPointDistance ) = 0;
 

        virtual common::Interval<Length> Create( const std::vector<spat::Position<Length>>& samples, WrapTypes wrap = WrapTypes::nonperiodic ) = 0;
 

        virtual common::Interval<Length> CreateCatmullRom( const std::vector<spat::Position<Length>>& samples, WrapTypes wrap = WrapTypes::nonperiodic ) = 0;
 

        virtual common::Interval<Length> Create( const Data& data ) = 0;
 

        virtual const Data& GetData() const noexcept = 0;
    };
 


    bool dclspc Equals( const PolygonalChain::Data& A, const PolygonalChain::Data& B, common::Interval<Length> range, 
        Length epsilon_length = epsilon__length, Angle epsilon_angle = epsilon__angle );
 

    struct SampledCurve : Curve{

        static dclspc std::unique_ptr<SampledCurve> Make() noexcept;
 
 
        using Data = std::vector<CurveSample>;
 

        virtual int UpperBound( Length s ) const = 0;
 

        
        virtual common::Interval<Length> Create( const Curve& originalCurve, common::Interval<Length> range, Length maxDeviationLength = epsilon__length, Angle maxDeviationAngle = epsilon__angle, common::Interval<Length> sampleDistanceLimits = { epsilon__length, 20_m } ) = 0;
 

        virtual common::Interval<Length> Create( std::pair<std::shared_ptr<const Curve>,common::Interval<Length>> originalCurve, Length maxDeviationLength = epsilon__length, Angle maxDeviationAngle = epsilon__angle, common::Interval<Length> sampleDistanceLimits = { epsilon__length, 20_m } ) = 0;
 

        virtual common::Interval<Length> Create( const Data& data ) = 0;
 

        virtual const Data& GetData() const noexcept = 0;
    };
 


    bool dclspc Equals( const SampledCurve::Data& A, const SampledCurve::Data& B, common::Interval<Length> range, 
        Length epsilon_length = epsilon__length, Angle epsilon_angle = epsilon__angle ) noexcept;
 

    struct EEPCurve : Curve {

        static dclspc std::unique_ptr<EEPCurve> Make(CurveType type = CurveType::EEPCurve) noexcept;
 

        struct Data {

            Data() noexcept
                : gc_Kruemmung{ 0 },
                gc_Windung{ 0 },
                gc_Verdrillung{ 0 },
                gc_Laenge{ _cm(10_m) }, //cm
                gc_Kurve{ 0 },
                m_FuehrungsVerdrehung{ 0 }
            {
                m_AnfangsBein.Init();
            }

 
            Data(const Data&) noexcept = default;
            Data& operator=(const Data&) noexcept = default;
 
            bool operator==(const Data& data) const noexcept {
                return  gc_Kruemmung == data.gc_Kruemmung &&
                    gc_Windung == data.gc_Windung &&
                    gc_Verdrillung == data.gc_Verdrillung &&
                    gc_Laenge == data.gc_Laenge &&
                    gc_Kurve == data.gc_Kurve &&
                    m_FuehrungsVerdrehung == data.m_FuehrungsVerdrehung &&
                    m_AnfangsBein == data.m_AnfangsBein;
            }
 


            Real gc_Kruemmung;
            Real gc_Windung;
            Real gc_Verdrillung;
            Real gc_Laenge;
            Real gc_Kurve;
            Real m_FuehrungsVerdrehung;
            spat::Frame<Real> m_AnfangsBein;
        };
 

        //virtual common::Interval<Length> Create( const spat::Frame<Length,One>& start, const spat::Position<Length>& end ) = 0;
 

        virtual common::Interval<Length> Create(const Data& data) = 0;
 

        virtual const Data& GetData() const noexcept = 0;
    };
 


    bool dclspc Equals(const EEPCurve::Data& A, const EEPCurve::Data& B, common::Interval<Length> range,
        Length epsilon_length = epsilon__length, Angle epsilon_angle = epsilon__angle) noexcept;
 

    std::unique_ptr<Curve> dclspc CreateNonEEPCurve(const EEPCurve::Data& fromEEPCurveData);
 

    
    Angle dclspc TotalAngle( const Curve& curve, common::Interval<Length> range, Angle accuracy = epsilon__angle );

    Angle dclspc TotalAngle( std::pair<std::shared_ptr<const Curve>,common::Interval<Length>> curve, Angle accuracy = epsilon__angle );
 

    
    std::pair<std::unique_ptr<Curve>,common::Interval<Length>> dclspc CreateCurve( 
        const spat::Position<Length>& start,
        const spat::Position<Length>& end,
        const spat::Vector<One>& up );

    std::pair<std::unique_ptr<Curve>,common::Interval<Length>> dclspc CreateCurve( 
              spat::VectorBundle<Length,One> start, 
        const spat::Position<Length>& end, 
        const spat::Vector<One>& up, Length e_length = epsilon__length );

    std::pair<std::unique_ptr<Curve>,common::Interval<Length>> dclspc CreateCurve( 
        const spat::Position<Length>& start, 
              spat::VectorBundle<Length,One> end, 
        const spat::Vector<One>& up, Length e_length = epsilon__length );

    std::pair<std::unique_ptr<Curve>,common::Interval<Length>> dclspc CreateCurve( 
        const spat::VectorBundle<Length,One>& start, 
        const spat::VectorBundle<Length,One>& end, 
        const spat::Vector<One>& up, Length e_length = epsilon__length, Angle e_angle = epsilon__angle );
    

    
    std::pair<std::unique_ptr<Curve>, common::Interval<Length>> dclspc CreateCurve( Curve::CurveType type, std::pair<std::shared_ptr<const Curve>,common::Interval<Length>> fromCurve );
 
    std::pair<std::unique_ptr<Curve>,common::Interval<Length>> dclspc CreateCurve( Curve::CurveType type, const Curve& fromCurve, common::Interval<Length> range );
    
    std::pair<std::unique_ptr<Line>,common::Interval<Length>> dclspc CreateLine( const Curve& fromCurve, common::Interval<Length> range );
 
    std::pair<std::unique_ptr<LineP>,common::Interval<Length>> dclspc CreateLineP( const Curve& fromCurve, common::Interval<Length> range );
 
    std::pair<std::unique_ptr<Arc>,common::Interval<Length>> dclspc CreateArc( const Curve& fromCurve, common::Interval<Length> range );
 
    std::pair<std::unique_ptr<ArcP>,common::Interval<Length>> dclspc CreateArcP( const Curve& fromCurve, common::Interval<Length> range );
 
    std::pair<std::unique_ptr<Helix>,common::Interval<Length>> dclspc CreateHelix( const Curve& fromCurve, common::Interval<Length> range );
 
    std::pair<std::unique_ptr<HelixP>,common::Interval<Length>> dclspc CreateHelixP( const Curve& fromCurve, common::Interval<Length> range );
 
    std::pair<std::unique_ptr<Cubic>,common::Interval<Length>> dclspc CreateCubic( const Curve& fromCurve, common::Interval<Length> range );
 
    std::pair<std::unique_ptr<Spline>,common::Interval<Length>> dclspc CreateSpline( const Curve& fromCurve, common::Interval<Length> range );
 
    std::pair<std::unique_ptr<Clothoid>,common::Interval<Length>> dclspc CreateClothoid( const Curve& fromCurve, common::Interval<Length> range );
 
    std::pair<std::unique_ptr<Rotator>,common::Interval<Length>> dclspc CreateRotator( const Curve& fromCurve, common::Interval<Length> range );
 
    std::pair<std::unique_ptr<Rotator>,common::Interval<Length>> dclspc CreateRotatorWithOffset( const Curve& fromCurve, common::Interval<Length> range );
    
    std::pair<std::unique_ptr<RotatorChain>,common::Interval<Length>> dclspc CreateRotatorChain( const Curve& fromCurve, common::Interval<Length> range );
 
    std::pair<std::unique_ptr<PolygonalChain>,common::Interval<Length>> dclspc CreatePolygonalChain( const Curve& fromCurve, common::Interval<Length> range );
 

    struct CurvatureStrecher{

        static dclspc const CurvatureStrecher* InterfaceFrom( const Curve& curve ) noexcept;
 
        static dclspc CurvatureStrecher* InterfaceFrom( Curve& curve ) noexcept;
        

        virtual spat::Vector<One> Direction( Length s ) const = 0;
 
        virtual AnglePerLength Start( Length s, const spat::Position<Length>& Z, common::Interval<AnglePerLength> curvatureLimits = {epsilon__angle/maximum__length,180_deg/epsilon__length} ) = 0;
 
        virtual AnglePerLength Strech( Length s, const spat::Position<Length>& Z ) = 0;
 
 
        virtual ~CurvatureStrecher() = default;
        CurvatureStrecher( CurvatureStrecher&& ) = delete;
        CurvatureStrecher& operator=( const CurvatureStrecher& ) = delete;
        CurvatureStrecher& operator=( CurvatureStrecher&& ) = delete;
    protected:
        CurvatureStrecher() = default;
        CurvatureStrecher( const CurvatureStrecher& ) = default;
    };
}