DSpiral2dBase.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------+
|
|   Supplied under applicable software license agreement.
|
|   Copyright (c) 2018 Bentley Systems, Incorporated. All rights reserved.
|
+---------------------------------------------------------------------------------------*/
#pragma once

BEGIN_BENTLEY_GEOMETRY_NAMESPACE
// VANCOUVER max stroke length assumes UOR's !!!!
#define DEFAULT_SPIRAL_MAX_STROKE_LENGTH 10000.0
typedef struct DSpiral2dBase *DSpiral2dBaseP;
typedef struct DSpiral2dBase const *DSpiral2dBaseCP;

typedef struct DSpiral2dBase &DSpiral2dBaseR;
typedef struct DSpiral2dBase const &DSpiral2dBaseCR;

// Interface class for callbacks ...
struct AnnounceDoubleDPoint2d
{
GEOMAPI_VIRTUAL void Announce (double fraction, DVec2dCR xy) = 0;
};
typedef struct AnnounceDoubleDPoint2d &AnnounceDoubleDPoint2dR;

struct GEOMDLLIMPEXP DSpiral2dBase : BSIVectorIntegrand
{
public:
static const int TransitionType_Unknown           = 0;
static const int TransitionType_Clothoid          = 10;
static const int TransitionType_Bloss             = 11;
static const int TransitionType_Biquadratic       = 12;
static const int TransitionType_Cosine            = 13;
static const int TransitionType_Sine              = 14;
static const int TransitionType_Viennese          = 20;
static const int TransitionType_WeightedViennese  = 21;
// convention: spirals that really have direct evaluations start at 50.
static const int TransitionType_FirstDirectEvaluate = 50;
static const int TransitionType_NewSouthWales       = 50; // IMPLEMENTED 01/18
static const int TransitionType_Czech               = 51; // NOT IMPLEMENTED
static const int TransitionType_Australian          = 52; // IMPLEMENTED 01/18
static const int TransitionType_Italian             = 53; // NOT IMPLEMENTED
static const int TransitionType_PolishCubic         = 54; // NOT IMPLEMENTED
static const int TransitionType_AremaCubic          = 55; // NOT IMPLEMENTED
static const int TransitionType_MXCubic             = 56; // NOT IMPLEMENTED
static const int TransitionType_MXCubicArc          = 57; // NOT IMPLEMENTED

public: static DSpiral2dBaseP Create (int transitionType);

public: static int StringToTransitionType (Utf8CP name);

public: static bool TransitionTypeToString (int type, Utf8StringR string);
public: static DSpiral2dBaseP CreateBearingCurvatureBearingCurvature
      (
      int transitionType,
      double startRadians,
      double startCurvature,
      double endRadians,
      double endCurvature
      );

public: static DSpiral2dBaseP CreateBearingCurvatureLengthCurvature
      (
      int transitionType,
      double startRadians,
      double startCurvature,
      double length,
      double endCurvature
      );
public:
    // Primary bearing and curvature data:
    double mTheta0, mTheta1;
    double mCurvature0, mCurvature1;

    // Derived length:
    double mLength;
public:
    // Return the recommended default stroke angle control
    static double DefaultStrokeAngle ();

public:
    // Default constructor.
    //
    DSpiral2dBase ();
    // Clone all data ...
    GEOMAPI_VIRTUAL DSpiral2dBaseP Clone () const = 0;
    // Set bearing and angle at start and end of the bounded curve.
    // Return true if able to calculate length
    bool SetBearingAndCurvatureLimits
            (
            double theta0,
            double curvature0,
            double theta1,
            double curvature1
            );


    bool SetBearingCurvatureLengthCurvature
    (
    double theta0,
    double curvature0,
    double length,
    double curvature1
    );

    bool SetBearingCurvatureLengthBearing
    (
    double theta0,
    double curvature0,
    double length,
    double theta1
    );

    // Copy all base class parameters from source.
    void CopyBaseParameters (DSpiral2dBaseCP pSource);
    // Convert distance-along the spiral to fractional coordinate.
    double DistanceToFraction (double distance) const;
    // Convert fractional coordiante to distance-along.
    double FractionToDistance (double fraction) const;

    int  GetVectorIntegrandCount () override;

    void EvaluateVectorIntegrand (double distance, double *pF) override;

    double DistanceToGlobalAngle (double distance) const;
    
    // Apply a scale factor (e.g. change of units) in place.
    // return true if the scale is nonzero.
    bool ScaleInPlace (double s);

    // Return derivatives of the position vector with respect to fraction parameter.
    bool FractionToDerivatives (double fraction, DVec2dR dXdf, DVec2dR ddXdfdf, DVec2dR dddXdfdfdf);

    // Derived classes must implement 2 virtuals:
    // Return the accumulated turning angle at specified distance, i.e. always 0 at distanece 0;
    GEOMAPI_VIRTUAL double DistanceToLocalAngle  (double distance) const = 0;
    // Return the curvature at specified distance from start ...
    GEOMAPI_VIRTUAL double DistanceToCurvature   (double distance) const = 0;
    // Return the derivative of curvature wrt arc length at specified distance from start ...
    GEOMAPI_VIRTUAL double DistanceToCurvatureDerivative (double distance) const = 0;

    // Return the type code for this spiral.
    GEOMAPI_VIRTUAL int GetTransitionTypeCode () const = 0;


#define DECLARE_DSPIRAL2DBASE_OVERRIDES \
    double DistanceToLocalAngle  (double distance) const override;\
    double DistanceToCurvature   (double distance) const override;\
    DSpiral2dBaseP Clone () const override;\
    double DistanceToCurvatureDerivative (double distance) const override;\
    int GetTransitionTypeCode () const override;

#define DECLARE_DSPIRAL2DBASE_DIRECT_EVALUATION_MIDLEVEL_OVERRIDES \
    double DistanceToLocalAngle  (double distance) const override;\
    double DistanceToCurvature   (double distance) const override;\
    double DistanceToCurvatureDerivative (double distance) const override;

#define DECLARE_DSPIRAL2DBASE_DIRECT_EVALUATION_OVERRIDES \
    DSpiral2dBaseP Clone () const override;\
    int GetTransitionTypeCode () const override;

static bool Stroke
    (
    DSpiral2dBase &spiral,
    double maxRadians,
    DVec2d *pDXY,
    int    &numDXY,
    int    maxDXY,
    double &errorBound
    );


static bool Stroke
    (
    DSpiral2dBase &spiral,
    double maxRadians,
    DPoint3dCR xyz0,
    DPoint3dP  pXYZ,
    int    &numXYZ,
    int    maxXYZ,
    double &errorBound
    );

static bool Stroke
(
DSpiral2dBase &spiral,
double startFraction,
double endFraction,
double maxRadians,
DVec2dR delta,
double &errorBound
);

static bool Stroke
(
DSpiral2dBase &spiral,
double startFraction,
double endFraction,
double maxRadians,
DVec2d *pDXY,
int    &numDXY,
int    maxDXY,
double &errorBound
);

static bool Stroke
(
DSpiral2dBase &spiral,
double startFraction,
double endFraction,
double maxRadians,
DVec2d *pDXY,
double *pFraction,
int    &numDXY,
int    maxDXY,
double &errorBound
);

static bool Stroke
(
DSpiral2dBase &spiral,
double startFraction,
double endFraction,
double maxRadians,
DVec2dR delta,
double &errorBound,
double maxStrokeLength
);

static bool Stroke
(
DSpiral2dBase &spiral,
double startFraction,
double endFraction,
double maxRadians,
bvector<DVec2d> &uvPoints,
bvector<double> &fractions,
double &errorBound,
double maxStrokeLength = DEFAULT_SPIRAL_MAX_STROKE_LENGTH
);


static bool StrokeToAnnouncer
(
DSpiral2dBase &spiral,
double startFraction,
double endFraction,
double maxRadians,
AnnounceDoubleDPoint2dR F,
double &errorBound,
int minInterval = 0,
double maxStrokeLength = DEFAULT_SPIRAL_MAX_STROKE_LENGTH
);


static size_t GetIntervalCount
(
DSpiral2dBase &spiral,
double startFraction,
double endFraction,
double maxRadians,
int minInterval = 0,
double maxStrokeLength = DEFAULT_SPIRAL_MAX_STROKE_LENGTH
);
static bool ClosestPoint
(
DSpiral2dBase &spiral,
double startFraction,
double endFraction,
TransformCR spiralToWorld,
DPoint3dCR spacePoint,
DPoint3dR spiralPoint,
double&   spiralFraction,
double&   minDistance
);


static bool LineSpiralArcSpiralLineTransition
(
DPoint3dCR lineAPoint,
DPoint3dCR lineBPoint,
DPoint3dCR lineLineIntersection,
double     radius,
double      lengthA,
double     lengthB,
DSpiral2dBase &spiralA,
DSpiral2dBase &spiralB,
DPoint3dR  lineToSpiralA,
DPoint3dR  lineToSpiralB,
DPoint3dR  spiralAToArc,
DPoint3dR  spiralBToArc,
DEllipse3dR arc
);

static bool SymmetricLineSpiralSpiralLineTransition
(
DPoint3dCR lineAPoint,
DPoint3dCR lineBPoint,
DPoint3dCR lineLineIntersection,
double      length,
DSpiral2dBase &spiralA,
DSpiral2dBase &spiralB,
DPoint3dR  lineToSpiralA,
DPoint3dR  lineToSpiralB,
DPoint3dR  spiralToSpiral,
double     &junctionRadius
);
//   First spiral begins exactly at the start point and aims at the shoulder
//   Second spiral ends somewhere on the line from shoulder to target.
static bool SymmetricPointShoulderTargetTransition
(
DPoint2dCR startPoint,
DPoint2dCR shoulderPoint,
DPoint2dCR targetPoint,
DSpiral2dBase &spiralA,
DSpiral2dBase &spiralB,
DPoint2dR    junctionPoint,
DPoint2dR    endPoint
);

struct ASLSACollector
    {

    GEOMAPI_VIRTUAL void Collect
        (
        DPoint3dCR     centerA,
        DPoint3dCR      arcToSpiralA,
        DSpiral2dBase   &spiralA,
        DPoint3dCR      spiralToLineA,
        DPoint3dCR      centerB,
        DPoint3dCR      arcToSpiralB,
        DSpiral2dBase   &spiralB,
        DPoint3dCR      spiralToLineB
        ) = 0;
    };
static int ArcSpiralLineSpiralArcTransition
(
DPoint3dCR      centerA,
double          radiusA,
double          lengthA,
DPoint3dCR      centerB,
double          radiusB,
double          lengthB,
DSpiral2dBase  &spiralA,
DSpiral2dBase  &spiralB,
ASLSACollector &collector
);



};


// CLOTHOID spiral
// Curvature function is simple linear variation from K0 to K1, i.e.
//         K(u) = K0 + u (K1 - K0)
struct GEOMDLLIMPEXP DSpiral2dClothoid : DSpiral2dBase
{
public:
    DSpiral2dClothoid ();
    DECLARE_DSPIRAL2DBASE_OVERRIDES
};

// BLOSS Spiral
// Curvature function has linear first derivative, constant second derivative ...
//       K(u) = K0 + (3u^2 - 2 u^3)(K1 - K0)
struct GEOMDLLIMPEXP DSpiral2dBloss : DSpiral2dBase
{
public:
    DSpiral2dBloss ();
    DECLARE_DSPIRAL2DBASE_OVERRIDES
};

// BIQUADRATIC Spiral
// Curvature function is a pair of quadratics with continuous K and K' at midpoint,
//           i.e. K(u) = K0 + 2U^2 (K1 - K0) for u in (0,1/2); reverse from 1.
// Second derivative is piecewise constant at 1 and -1 over the first and second half intervals.
struct GEOMDLLIMPEXP DSpiral2dBiQuadratic : DSpiral2dBase
{
public:
    DSpiral2dBiQuadratic ();
    DECLARE_DSPIRAL2DBASE_OVERRIDES
};


// COSINE spiral ..
// Curvature function second derivative is 180 degrees of cosine.
struct GEOMDLLIMPEXP DSpiral2dCosine : DSpiral2dBase
{
public:
    DSpiral2dCosine ();
    DECLARE_DSPIRAL2DBASE_OVERRIDES
};

// SINE spiral ...
// Curvature function second derivative is 360 degrees of sine.
struct GEOMDLLIMPEXP DSpiral2dSine : DSpiral2dBase
{
public:
    DSpiral2dSine ();
    DECLARE_DSPIRAL2DBASE_OVERRIDES
};



// VIENNESE spiral
// Curvature function second derivative is
struct GEOMDLLIMPEXP DSPiral2dViennese : DSpiral2dBase
{
private:
    double mPhi;
public:
    DSPiral2dViennese
    (
    double cant,
    double h,
    double e
    );

    DECLARE_DSPIRAL2DBASE_OVERRIDES
};

// Specialization for VIENNESE with caller-specified multipliers for primary and roll terms
//   <list>
//    <item>Spiral part second derivative Ks''(u) proportional to u^2 (1-u)^2 (1-2u), i.e. has double roots at 0 and 1, single root at 0.5.</item>
//    <item>Roll part curvature Kr(u) is proportioanl to u^2 (1-u)^2 (1-2u)
//   </list>
struct GEOMDLLIMPEXP DSPiral2dWeightedViennese : DSpiral2dBase
{
private:
    double mPhi;
    double mF0;
    double mF1;
public:
    DSPiral2dWeightedViennese
    (
    double cant,
    double h,
    double e,
    double weight0,    // multiplier for standard term
    double weight1     // multiplier for roll term.
    );

    DECLARE_DSPIRAL2DBASE_OVERRIDES
};

struct GEOMDLLIMPEXP DSpiral2dDirectEvaluation : DSpiral2dBase
{
    DECLARE_DSPIRAL2DBASE_DIRECT_EVALUATION_MIDLEVEL_OVERRIDES

public:
virtual bool EvaluateAtDistance
    (
    double distanceAlong, 
    DPoint2dR xyz,          
    DVec2dP d1XYZ,   
    DVec2dP d2XYZ,   
    DVec2dP d3XYZ    
    ) const = 0;
void EvaluateVectorIntegrand (double distance, double *pF) override;
static void ApplyCCWRotation (
    double radians,
    DPoint2dR xyz,          
    DVec2dP d1XYZ,   
    DVec2dP d2XYZ,   
    DVec2dP d3XYZ    
    );
};
// NEWSOUTHWALES Spiral
// Let a = 1/ (40 R*R*L*L) for exit radius R, spiral length L
// Let b = 1/(6 R L)
//  at distance s along the spiral
//     x =  s *(1-a *s^4)
//     y = b * s^3

struct GEOMDLLIMPEXP DSpiral2dNewSouthWales : DSpiral2dDirectEvaluation
{
    DECLARE_DSPIRAL2DBASE_DIRECT_EVALUATION_OVERRIDES
public:
    DSpiral2dNewSouthWales ();

bool EvaluateAtDistance
    (
    double distanceAlong, 
    DPoint2dR xyz,          
    DVec2dP d1XYZ,   
    DVec2dP d2XYZ,   
    DVec2dP d3XYZ   
    ) const override;

static bool EvaluateAtDistanceInStandardOrientation
    (
    double s,           
    double length,      
    double curvature1,  
    DPoint2dR xy,      
    DVec2dP d1XY,   
    DVec2dP d2XY,   
    DVec2dP d3XY   
    );
};

// AUSTRALIAN Spiral
// In local coordinates, with specific constants  a1,a2,a3,a4 and m based on length and final radius  . . .
// x = s (1 - a1 m^2 s^4 + a2 m^4 s^8 - a3 m^6 s^12 + a4 m^8 s^16)
// y = m * s^3
struct GEOMDLLIMPEXP DSpiral2dAustralian : DSpiral2dDirectEvaluation
{
    DECLARE_DSPIRAL2DBASE_DIRECT_EVALUATION_OVERRIDES
public:
    DSpiral2dAustralian ();

bool EvaluateAtDistance
    (
    double distanceAlong, 
    DPoint2dR xy,          
    DVec2dP d1XY,   
    DVec2dP d2XY,   
    DVec2dP d3XY   
    ) const override;
static bool EvaluateAtDistanceInStandardOrientation
    (
    double s,           
    double length,      
    double curvature1,  
    DPoint2dR xy,      
    DVec2dP d1XY,   
    DVec2dP d2XY,   
    DVec2dP d3XY   
    );
};

// MX approximate Spiral
// In local coordinates, with specific constants  a1,a2,a3,a4 and m based on length and final radius  . . .
// x = s (1 - a1 m^2 s^4 + a2 m^4 s^8 - a3 m^6 s^12 + a4 m^8 s^16)
// y = m * s^3
struct GEOMDLLIMPEXP DSpiral2dMXCubic : DSpiral2dDirectEvaluation
{
    DECLARE_DSPIRAL2DBASE_DIRECT_EVALUATION_OVERRIDES
public:
    DSpiral2dMXCubic ();

bool EvaluateAtDistance
    (
    double distanceAlong, 
    DPoint2dR xy,          
    DVec2dP d1XY,   
    DVec2dP d2XY,   
    DVec2dP d3XY   
    ) const override;
static bool EvaluateAtDistanceInStandardOrientation
    (
    double s,           
    double length,      
    double curvature1,  
    DPoint2dR xy,      
    DVec2dP d1XY,   
    DVec2dP d2XY,   
    DVec2dP d3XY   
    );
};


struct DSpiral2dPlacement;
typedef DSpiral2dPlacement *DSpiral2dPlacementP;
typedef DSpiral2dPlacement const *DSpiral2dPlacementCP;
typedef DSpiral2dPlacement &DSpiral2dPlacementR;
typedef DSpiral2dPlacement const &DSpiral2dPlacementCR;

struct DSpiral2dPlacement
{
DSpiral2dBaseP spiral;
Transform frame;
double fractionA;
double fractionB;
DSpiral2dPlacement ();
DSpiral2dPlacement (DSpiral2dBaseCR source, TransformCR frame, double fractionA, double fractionB);

DSpiral2dPlacement (DSpiral2dBaseP _spiral, TransformCR frame, double fractionA, double fractionB);

DSpiral2dPlacementP Clone (DSpiral2dPlacementCR source) const;
~DSpiral2dPlacement ();
void ReplaceSpiral (DSpiral2dBaseP callerSpiral);
bool ReverseInPlace ();
bool AlmostEqual (DSpiral2dPlacement const &other, double tolerance = 0.0) const;
bool AlmostEqual01 (DSpiral2dPlacement const &other, double tolerance = 0.0) const;
DSegment1d FractionInterval () const;

DPoint3d FractionToPoint (double fraction) const;
DRay3d FractionToPointAndDerivative (double fraction) const;
DRay3d FractionToPointAndUnitTangent (double fraction) const;

DPoint3d ActiveFractionToPoint (double fraction) const;
DRay3d ActiveFractionToPointAndDerivative (double fraction) const;
DRay3d ActiveFractionToPointAndUnitTangent (double fraction) const;

double ActiveFractionToGlobalFraction (double activeFraction) const;

RotMatrix FractionToDerivatives (double fraction) const;
RotMatrix ActiveFractionToDerivatives (double fraction) const;


Transform FractionToFrenetFrame (double fraction) const;
Transform ActiveFractionToFrenetFrame (double fraction) const;
double SpiralLength01 () const;
double SpiralLengthActiveInterval () const;
double MappedSpiralLengthActiveInterval (RotMatrixCR matrix) const;

DVec3d DisplacementBetweenFractions (double f0, double f1) const;
DVec3d DisplacementBetweenActiveFractions (double g0, double g1) const;
};
END_BENTLEY_GEOMETRY_NAMESPACE
#endif