dellipse3d.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
struct GEOMDLLIMPEXP DEllipse3d
{
DPoint3d center;    
DVec3d   vector0;   
DVec3d   vector90;  
double start;       
double sweep;       

#ifdef __cplusplus



//BEGIN_FROM_METHODS
static DEllipse3d From (double cx, double cy, double cz, double ux, double uy, double uz, double vx, double vy, double vz, double theta0, double sweep);

static DEllipse3d FromCenterRadiusXY
(
DPoint3dCR center,  
double radius       
);

static DEllipse3d FromFractionInterval
(
DEllipse3dCR parent,
double startFraction,
double endFraction
);

static DEllipse3d FromXYMajorMinor (double cx, double cy, double cz, double rx, double ry, double thetaX, double theta0, double sweep);

static DEllipse3d FromPoints (DPoint3dCR center, DPoint3dCR point0, DPoint3dCR point90, double theta0, double sweep);

static ValidatedDEllipse3d FromStartTangentNormalRadiusSweep (
DPoint3dCR pointA,          
DVec3dCR tangent,           
DVec3dCR planeNormal,       
double radius,              
double sweepRadians         
);
static DEllipse3d FromPointsOnArc (DPoint3dCR start, DPoint3dCR middle, DPoint3dCR end);

static DEllipse3d FromArcCenterStartEnd (DPoint3dCR center, DPoint3dCR startPoint, DPoint3dCR endTarget);

static DEllipse3d FromVectors
(
DPoint3dCR center, 
DVec3dCR vector0, 
DVec3dCR vector90, 
double theta0,  
double sweep 
);

static DEllipse3d FromScaledRotMatrix
(
DPoint3dCR center,  
RotMatrixCR matrix, 
double r0,          
double r90,          
double theta0,      
double sweep        
);
static DEllipse3d FromScaledVectors
(
DPoint3dCR center, 
DVec3dCR vector0, 
DVec3dCR vector90, 
double r0,          
double r90,          
double theta0,      
double sweep        
);

static DEllipse3d FromScaledVectors
(
DEllipse3dCR source, 
double factor        
);


static DEllipse3d FromMajorMinor (DEllipse3dCR source);

static DEllipse3d FromCenterNormalRadius (DPoint3dCR center, DVec3dCR normal, double radius);

static DEllipse3d FromPerpendicularAxes (DEllipse3dCR source);
static DEllipse3d FromReversed (DEllipse3dCR source);

DEllipse3d FromNegateVector90 (DEllipse3dCR source);


static DEllipse3d FromCopyWithPositiveSweep (DEllipse3dCR source);


static DEllipse3d FromRotatedAxes (DEllipse3dCR source, double newStart);
//END_FROM_METHODS

void Init
(
double          cx,
double          cy,
double          cz,
double          ux,
double          uy,
double          uz,
double          vx,
double          vy,
double          vz,
double          theta0,
double          sweep
);

void InitFromXYMajorMinor
(
double          cx,
double          cy,
double          cz,
double          rx,
double          ry,
double          thetaX,
double          theta0,
double          sweep
);

void InitFromPoints
(
DPoint3dCR      center,
DPoint3dCR      point0,
DPoint3dCR      point90,
double          theta0,
double          sweep
);

bool InitFromPointsOnArc
(
DPoint3dCR      start,
DPoint3dCR      middle,
DPoint3dCR      end
);

bool InitArcFromPointPointArcLength
(
DPoint3dCR      startIN,
DPoint3dCR      end,
double          arcLength,
DVec3dCR      planeVector
);

bool InitArcFromPointTangentPoint
(
DPoint3dCR      startIN,
DVec3d      tangent,
DPoint3dCR      end
);

bool InitFromArcCenterStartEnd
(
DPoint3dCR      centerIN,
DPoint3dCR      startIN,
DPoint3dCR      end
);

void InitFromVectors
(
DPoint3dCR      centerIN,
DVec3dCR        vector0IN,
DVec3dCR        vector90IN,
double          theta0,
double          sweepIN
);


bool SetStartEnd
(
DPoint3dCR      startPoint,
DPoint3dCR      endPoint,
bool            ccw
);

void InitFromScaledRotMatrix
(
DPoint3dCR      centerIN,
RotMatrixCR     matrix,
double          r0,
double          r1,
double          theta0,
double          sweepIN
);



void InitFromScaledVectors
(
DPoint3dCR      centerIN,
DVec3dCR      vector0IN,
DVec3dCR      vector90IN,
double          r0,
double          r1,
double          theta0,
double          sweepIN
);

void InitMajorMinor
(
DEllipse3dCR source
);

void GetScaledRotMatrix
(
DPoint3dR       center,
RotMatrixR      matrix,
double          &r0,
double          &r1,
double          &theta0,
double          &sweep
) const;


void GetScaledTransforms
(
TransformR localToWorld,
double &r0,
double &r1,
double &theta0,
double &sweep,
TransformR worldToLocal
) const;
void InitFromCenterNormalRadius
(
DPoint3dCR      centerIN,
DVec3dCR      normal,
double          radius
);

bool IsFullEllipse () const;

bool IsNearZeroRadius() const;

bool IsAlmostEqual (DEllipse3dCR other, double tolerance) const;
void MakeFullSweep ();

void ComplementSweep ();


DPoint3d RadiansToPoint (double theta) const;
void Evaluate
(
DPoint3dR       point,
double          xx,
double          yy
) const;

void Evaluate
(
DPoint4dR       point,
double          theta
) const;

void EvaluateEndPoints
(
DPoint3dR       startPoint,
DPoint3dR       endPoint
) const;

void Evaluate
(
DPoint3dR       point3dX,
DVec3dR       dX,
DVec3dR       ddX,
double          theta
) const;

void FractionParameterToPoint
(
DPoint3dR       point3dX,
double          fraction
) const;

DPoint3d FractionToPoint (double fraction) const;

void FractionParameterToDerivatives
(
DPoint3dR       point3dX,
DVec3dR       dX,
DVec3dR       ddX,
double          fraction
) const;

void Evaluate
(
DPoint3dP       point3dX,
int             numDerivative,
double          theta
) const;

double FractionToAngle (double fraction) const;

double DeterminantJXY () const;

bool GetLocalFrame
(
TransformR      frame,
TransformR      inverse
) const;

bool GetXYLocalFrame
(
TransformR   frame,
TransformR   inverse
) const;


bool PointToXYLocal
(
DPoint3dR       localPoint,
DPoint3dCR      point
) const;

double PointToAngle (DPoint3dCR point) const;

bool ProjectPointToPlane
(
DPoint3dR       xYZNear,
double          &coff0,
double          &coff90,
DPoint3dCR      xYZ
) const;

int GetStrokeCount
(
int             nDefault = 12,
int             nMax = 180,
double          chordTol = 0.0,
double          angleTol = 0.0
) const;

void EvaluateTrigPairs
(
DPoint3dP       point,
DPoint2dCP      trig,
int             numPoint
) const;

int TestAndEvaluateTrigPairs
(
DPoint3dP       point,
DPoint2dCP      trig,
int             numPoint
) const;

bool IsAngleInSweep (double angle) const;

double AngleToFraction (double angle) const;

void GetLimits
(
double          &startAngle,
double          &endAngle
) const;

void GetSweep
(
double          &startAngle,
double          &sweepAngle
) const;

void SetLimits
(
double          startAngle,
double          endAngle
);

void SetSweep
(
double          startAngle,
double          sweepIN
);

void InitWithPerpendicularAxes (DEllipse3dCR source);

double GetMajorMinorRangeMidlines
(
DSegment3dR     longSegment,
DSegment3dR     shortSegment
) const;

void InitReversed (DEllipse3dCR source);

double TangentMagnitude (double theta) const;

double ArcLength () const;

double InverseArcLength (double arcLength) const;

bool FractionToLength
(
double          &arcLength,
double          fraction0,
double          fraction1
) const;

void GetRange (DRange3dR range) const;

void GetLocalRange (DRange2dR range) const;


DRange1d ProjectedParameterRange (DRay3dCR ray) const;

int IntersectPlane
(
DPoint3dP       trigPoints,
DPoint4dCR      plane
) const;

int SolveTangentsPerpendicularToVector
(
double  *angles,   
DVec3dR vector
) const;
int IntersectXYLine
(
DPoint3dP       cartesianPoints,
double          *pLineParams,
DPoint3dP       ellipseCoffs,
double          *pEllipseAngle,
DPoint3dCR      startPoint,
DPoint3dCR      endPoint
) const;

bool IsCircular () const;

bool IsCircular (double &radius) const;

bool IsCircularXY () const;

bool IsCircularXY (double &radius) const;

bool IsCCWSweepXY () const;

int IntersectXYDEllipse3d
(
DPoint3dP       cartesianPoints,
DPoint3dP       ellipse0Params,
DPoint3dP      ellipse1Params,
DEllipse3dCR    ellipse1
) const;

int IntersectXYDEllipse3dBounded
(
DPoint3dP       cartesianPoints,
DPoint3dP       ellipse0Coffs,
double          *pEllipse0Angle,
DPoint3dP       ellipse1Coffs,
double          *pEllipse1Angle,
DEllipse3dCR    ellipse1
) const;

int IntersectSweptDEllipse3d
(
DPoint3dP       cartesianPoints,
DPoint3dP       ellipse0Params,
DPoint3dP       ellipse1Params,
DEllipse3dCR    ellipse1
) const;

int IntersectSweptDEllipse3dBounded
(
DPoint3dP       cartesianPoints,
DPoint3dP       ellipse0Coffs,
double          *pEllipse0Angle,
DPoint3dP       ellipse1Coffs,
double          *pEllipse1Angle,
DEllipse3dCR    ellipse1
) const;

int IntersectSweptDSegment3d
(
DPoint3dP       pointArray,
DPoint3dP       ellipseParams,
double          *pLineParams,
DSegment3dCR    segment
) const;

int IntersectSweptDSegment3dBounded
(
DPoint3dP       pointArray,
DPoint3dP       ellipseParams,
double          *pLineParams,
DSegment3dCR    segment
) const;

int ProjectPoint
(
DPoint3dP       cartesianPoints,
double          *pEllipseAngle,
DPoint3dCR      point
) const;

int ProjectPointXY
(
DPoint3dP       cartesianPoints,
double          *pEllipseAngle,
DPoint3dCR      point
) const;

int ProjectPointXYBounded
(
DPoint3dP       cartesianPoints,
double          *pEllipseAngle,
DPoint3dCR      point
) const;

int ProjectPointBounded
(
DPoint3dP       cartesianPoints,
double          *pEllipseAngle,
DPoint3dCR      point
) const;

bool ClosestPointXYBounded
(
double          &minAngle,
double          &minDistanceSquared,
DPoint3dR       minPoint,
DPoint3dCR      point
) const;

bool ClosestPointBounded
(
double          &minAngle,
double          &minDistanceSquared,
DPoint3dR       minPoint,
DPoint3dCR      point
) const;

int IntersectXYLineBounded
(
DPoint3dP       cartesianPoints,
double          *pLineParams,
DPoint3dP       ellipseCoffs,
double          *pEllipseAngle,
bool            *pIsTangency,
DPoint3dCR      startPoint,
DPoint3dCR      endPoint
) const;

void XySweepProperties
(
double          &area,
double          &sweepOUT,
DPoint3dCR      point
) const;

void QuadricBezierPoles
(
DPoint4dP       poleArray,
DPoint3dP       circlePoleArray,
double          *angleArray,
int             *pNumPole,
int             *pNumSpan,
int             maxPole
) const;


void QuadricBezierPoles
(
DPoint4dP       poleArray,
DPoint3dP       circlePoleArray,
int             *pNumPole,
int             *pNumSpan,
int             maxPole
) const;



bool InitFromCenterMajorAxisPointAndThirdPoint
(
DPoint3dCR      centerIN,
DPoint3dCR      point0,
DPoint3dCR      point1
);

int ClosestApproach
(
double          *pEllipseAngleBuffer,
double          *pRayFractionBuffer,
DPoint3dP       ellipsePointBuffer,
DPoint3dP       rayPointBuffer,
DRay3dCR        ray
) const;

void InitFromDGNFields3d
(
DPoint3dCR centerIN,
DVec3dCR directionX,
DVec3dCR directionY,
double          rX,
double          rY,
double          startAngle,
double          sweepAngle
);
void InitFromDGNFields3d
(
DPoint3dCR centerIN,
double const*   pQuatWXYZ,
double          rX,
double          rY,
double          startAngle,
double          sweepAngle
);
void InitFromDGNFields2d
(

DPoint2dCR centerIN,
DVec2dCR direction0,
double          rX,
double          rY,
double          startAngle,
double          sweepAngle,
double          zDepth

);
void InitFromDGNFields2d
(
DPoint2dCR centerIN,
double          xAngle,
double          rX,
double          rY,
double          startAngle,
double          sweepAngle,
double          zDepth

);

void GetDGNFields3d
(
DPoint3dR       centerOUT,
double *        pQuatWXYZ,
DVec3dR         directionX,
DVec3dR         directionY,
double          &rx,
double          &ry,
double          &startAngle,
double          &sweepAngle
) const;

void GetDGNFields2d
(
DPoint2dR       centerIN,
double          &xAngle,
DVec2dR         direction0,
double          &rx,
double          &ry,
double          &startAngle,
double          &sweepAngle
) const;

bool AlignedRange
(
TransformR      localToGlobal,
TransformR      globalToLocal,
DRange3dR       range
) const;

double MaxAbs () const;

bool ClosestPointBoundedXY
(
DPoint3dR   closePoint,
double&     closeParam,
double&     distanceXY,
DPoint3dCR  spacePoint,
DMatrix4dCP worldToLocal
) const;

bool ClosestPointBoundedXY
(
DPoint3dR   closePoint,
double&     closeParam,
double&     distanceXY,
DPoint3dCR  spacePoint,
DMatrix4dCP worldToLocal,
bool extend0,
bool extend1
) const;



void WireCentroid
(
double     &length,
DPoint3dR   centroid,
double fraction0 = 0.0,
double fraction1 = 1.0
) const;

static void Construct_XRadius_YRadius_XPoint_EdgePoint
(
bvector<DEllipse3d>&ellipses,
double a,
double b,
DPoint3dCR xPoint,
DPoint3dCR edgePoint
);

static void Construct_XPoint_EdgePoint_EdgePoint_XRadius (
bvector<DEllipse3d> &ellipses,
DPoint3dCR xPoint,
DPoint3dCR edgePoint0,
DPoint3dCR edgePoint1,
double a
);



static bool TryConstruct_EdgePoint_XPoint_EdgePoint_XAngle
(
DEllipse3dR ellipse,
DPoint3dCR edgePoint0,
DPoint3dCR xPoint,
DPoint3dCR edgePoint1,
double xAngle
);

static void Construct_Point_Direction_TangentXY
(
bvector<DEllipse3d> &ellipse,
bvector<double> &fractionB,
DPoint3dCR pointA,
DVec3dCR   directionA,
DRay3d     rayB
);

#endif

};
END_BENTLEY_GEOMETRY_NAMESPACE