dpoint4d.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 DPoint4d
{
double  x;
double  y;
double  z;
double  w;

#ifdef __cplusplus



static DPoint4d From
(
double x,
double y,
double z,
double w
);

static DPoint4d From
(
DPoint3dCR xyz,
double w
);

static DPoint4d FromSumOf
(
DPoint4dCR xyzw0,
double scale0,
DPoint4dCR xyzw1,
double scale1,
DPoint4dCR xyzw2,
double scale2
);


static DPoint4d FromMultiply
(
DMatrix4dCP matrix,
DPoint3dCR  point
);

static DPoint4d FromMultiply
(
DMatrix4dCP matrix,
DPoint4dCR  point
);

void Zero ();

void SetComponents
(
double          xComponent,
double          yComponent,
double          zComponent,
double          wComponent
);

void Init
(
DPoint3dCR      source,
double          w
);

void Init (double x, double y, double z, double w);



void InitFromArray
(
double          *pArray
);

void GetComponents
(
double          &xCoord,
double          &yCoord,
double          &zCoord,
double          &wCoord
) const;

void SetComponent
(
double          a,
int             index
);

double GetComponent (int index) const;

double MagnitudeXYZW () const;

double DotProduct (DPoint4dCR point) const;

double DotProductXY (DPoint4dCR point) const;

double DotProductXYZ (DPoint4dCR point2) const;

double DotProductXYW (DPoint4dCR point) const;

double DotProduct
(
double          x,
double          y,
double          z,
double          w
) const;

double DotProduct
(
DPoint3dCR      point2,
double          w
) const;

double EyePlaneTest
(
DPoint3dCR      origin,
DPoint3dCR      normal
) const;

double RealDistance (DPoint4dCR vec2) const;

bool RealDistanceSquaredXY
(
double          *pDistanceSquared,
DPoint3dCR      vec2
) const;

bool RealDistanceXY
(
double    &distance,
DPoint4dCR pointB
) const;

bool RealDistanceSquared
(
double          *pDistanceSquared,
DPoint3dCR      vec2
) const;

bool RealDistanceSquared
(
double          *pDistanceSquared,
DPoint4dCR      vec2
) const;

void Interpolate
(
DPoint4dCR      point0,
double          s,
DPoint4dCR      point1
);

static DPoint4d FromInterpolate
(
DPoint4dCR      point0,
double          s,
DPoint4dCR      point1
);


void InitFrom
(
DPoint3dCR      point,
double          w
);

void GetXYZ (DPoint3dR point) const;

void GetXYW (DPoint3dR point) const;

void GetXYZ
(
DPoint3dR       point,
int             xIndex,
int             yIndex,
int             zIndex
) const;

bool PlaneFromOriginAndNormal
(
DPoint3dCR      origin,
DPoint3dCR      normal
);

bool PlaneFrom3Points
(
DPoint3dCR      origin,
DPoint3dCR      point1,
DPoint3dCR      point2
);

bool PlaneFromOriginAndVectors
(
DPoint4dCR      origin,
DPoint3dCR      vector0,
DPoint3dCR      vector1
);

bool OriginAndNormalFromPlane
(
DPoint3dR       origin,
DPoint3dR       normal
) const;

void SumOf
(
DPoint4dCR      pt1,
DPoint4dCR      pt2
);

void WeightedDifferenceOf
(
DPoint4dCR      A,
DPoint4dCR      B
);

void WeightedDifferenceOf
(
DPoint4dCR      A,
DPoint3dCR      B,
double          wB
);

void WeightedDifferenceOf
(
DPoint3dCR      A,
double          wA,
DPoint4dCR      B
);

void Add (DPoint4dCR vector);

void Subtract (DPoint4dCR vector);

void DifferenceOf
(
DPoint4dCR      point1,
DPoint4dCR      point2
);

void SumOf
(
DPoint4dCR      point0,
DPoint4dCR      point1,
double          scale1,
DPoint4dCR      point2,
double          scale2
);

void SumOf
(
DPoint4dCR      point1,
double          scale1,
DPoint4dCR      point2,
double          scale2
);

void SumOf
(
DPoint4dCR      point0,
DPoint4dCR      point1,
double          scale1,
DPoint4dCR      point2,
double          scale2,
DPoint4dCR      point3,
double          scale3
);

void SumOf
(
DPoint4dCR      point1,
double          scale1,
DPoint4dCR      point2,
double          scale2,
DPoint4dCR      point3,
double          scale3
);


void SumOf
(
DPoint4dCR      point0,
DPoint4dCR      point1,
double          scale1
);

bool GetProjectedXYZ (DPoint3dR rPoint) const;

bool InitWithNormalizedWeight (DPoint4dCR source);

bool NormalizeWeightInPlace ();

bool NormalizePlaneOf (DPoint4dCR plane0);

void Scale
(
DPoint4dCR      point,
double          scale
);

void Scale (double scale);

void Negate (DPoint4dCR point);

void Negate ();

bool IsEqual (DPoint4dCR vec2) const;

bool IsEqual
(
DPoint4dCR      vec2,
double          tolerance
) const;

bool IsEqual
(
DPoint4dCR      vec2,
double          xyzTol,
double          wTol
) const;

static bool AlmostEqual
(
bvector<DPoint4d> const &dataA,     
bvector<DPoint4d> const &dataB,     
double xyzTol,                      
double wTol                         
);

static bool AlmostEqualReversed
(
bvector<DPoint4d> const &dataA,     
bvector<DPoint4d> const &dataB,     
double xyzTol,                      
double wTol                         
);

static bool AlmostEqual
(
DPoint4dCP dataA,     
DPoint4dCP dataB,     
size_t n,             
double xyzTol,        
double wTol           
);

static bool AlmostEqualReversed
(
DPoint4dCP dataA,     
DPoint4dCP dataB,     
size_t n,             
double xyzTol,        
double wTol           
);


double MaxAbs () const;

double MaxAbsUnnormalizedXYZ () const;

double MaxUnnormalizedXYZDiff (DPoint4dCR other) const;

double GetRotationAngleAndVectorFromQuaternion (DPoint3dR axis) const;

bool IsDisconnect () const;

void InitDisconnect ();

static DPoint4d FromCrossProduct (DPoint4dCR pointA, DPoint4dCR pointB, DPoint4dCR pointC);

static ValidatedDPlane3dByVectors TryNormalizePointAndDerivatives
(
DPoint4dCR homogeneousPoint,        
DPoint4dCR homogeneousDerivative1,  
DPoint4dCR homogeneousDerivative2   
);


};
#endif

END_BENTLEY_GEOMETRY_NAMESPACE