dmatrix4d.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 DMatrix4d
{
double          coff[4][4];
#ifdef __cplusplus

//BEGIN_FROM_METHODS


static DMatrix4d FromRowValues
(
double          x00,
double          x01,
double          x02,
double          x03,
double          x10,
double          x11,
double          x12,
double          x13,
double          x20,
double          x21,
double          x22,
double          x23,
double          x30,
double          x31,
double          x32,
double          x33
);


static DMatrix4d FromScaleAndTranslation
(
DPoint3dCR      scale,
DPoint3dCR      translation
);

static DMatrix4d From101WeightedProduct
(
TransformCR transformA,
RotMatrixCR   matrixB,
TransformCR transformC
);


static DMatrix4d FromColumnVectors
(
DVec3dCR      col0,
DVec3dCR      col1,
DVec3dCR      col2,
DPoint3dCR      translation
);

static DMatrix4d From (RotMatrixCR B);


static DMatrix4d From (TransformCR transfrom);


static DMatrix4d FromTranslation
(
double          tx,
double          ty,
double          tz
);

static DMatrix4d FromPerspective
(
double          px,
double          py,
double          pz
);

static DMatrix4d FromZero ();

//END_FROM_METHODS
void InitFromRowValues
(
double          x00,
double          x01,
double          x02,
double          x03,
double          x10,
double          x11,
double          x12,
double          x13,
double          x20,
double          x21,
double          x22,
double          x23,
double          x30,
double          x31,
double          x32,
double          x33
);

void TransposeOf (DMatrix4dCR B);

void Multiply
(
DPoint4dP       outPoint,
DPoint4dCP      inPoint,
int             n
) const;

DPoint4d Multiply (DPoint3dCR xyz, double w);


void SymmetricEigenvectors
(
DMatrix4dR      Q,
DPoint4dR       D
) const;

void Multiply
(
GraphicsPointP  outPoint,
GraphicsPointCP inPoint,
size_t n
) const;

bool EvaluateImageGrid
(
DPoint2dP       grid,
double          x00,
double          y00,
int             m,
int             n,
double          tol
) const;

void MultiplyAndRenormalize
(
DPoint3dP       outPoint,
DPoint3dCP      inPoint,
int             n
) const;

void MultiplyAndRenormalize
(
DPoint3dR       outPoint,
DPoint3dCR      inPoint
) const;

void MultiplyAndNormalize
(
DPoint3dP       outPoint,
DPoint4dCP      inPoint,
size_t          n
) const;


void MultiplyAffine
(
DPoint4dP       outPoint,
DPoint4dCP      inPoint,
int             n
) const;


void MultiplyScaleAndTranslate
(
DPoint4dP       outPoint,
DPoint4dCP      inPoint,
int             n
) const;

void MultiplyAffine
(
DPoint3dP       outPoint,
DPoint3dCP      inPoint,
int             n
) const;

void MultiplyAffineVectors
(
DPoint3dP       out,
DPoint3dCP      in,
int             n
) const;

void MultiplyScaleAndTranslate
(
DPoint3dP       outPoint,
DPoint3dCP      inPoint,
int             n
) const;

void Multiply
(
DPoint4dP       hPoint,
DPoint3dCP      point,
const double    *pWeight,
int             n
) const;




void Multiply
(
DPoint4dR       outPoint,
DPoint4dCR      inPoint
) const;

void MultiplyTranspose
(
DPoint4dP       outPoint,
DPoint4dCP      inPoint,
int             n
) const;

void SetRow
(
int             i,
double          c0,
double          c1,
double          c2,
double          c3
);

void SetRow
(
int             i,
DPoint4dCR       data
);



void SetColumn
(
int             i,
double          r0,
double          r1,
double          r2,
double          r3
);

void SetColumn
(
int             i,
DPoint4dCR      point
);

void SwapColumns
(
int             i,
int             j
);

void SwapRows
(
int             i,
int             j
);

void GetColumn
(
DPoint4dR       vec,
int             i
) const;

void GetRow
(
DPoint4dR       vec,
int             i
) const;



void GetRows
(
DPoint4dR       row0,
DPoint4dR       row1,
DPoint4dR       row2,
DPoint4dR       row3
) const;

void InitIdentity ();

void InitFromScaleAndTranslation
(
DPoint3dCR      scale,
DPoint3dCR      translation
);

void InitFromColumnVectors
(
DVec3dCR      col0,
DVec3dCR      col1,
DVec3dCR      col2,
DPoint3dCR      translation
);


void InitFrom (RotMatrixCR B);


void InitFrom (TransformCR transfrom);


void InitFromTranslation
(
double          tx,
double          ty,
double          tz
);

void InitFromPerspective
(
double          px,
double          py,
double          pz
);

void PreMultiplyByTranslateAndScale
(
double          tx,
double          ty,
double          tz,
double          sx,
double          sy,
double          sz,
DMatrix4dCR     matrixA
);

void InitProduct
(
DMatrix4dCR     A,
DMatrix4dCR     B
);

void InitProduct
(
DMatrix4dCR     A,
DMatrix4dCR     B,
DMatrix4dCR     C
);

void DifferenceOf
(
DMatrix4dCR     A,
DMatrix4dCR     B
);

void Add (DMatrix4dCR delta);

void Add (DMatrix4dCR delta, double scaleFactor);

void Scale (double scaleFactor);


void AddSymmetricScaledOuterProduct (DPoint3d xyz, double scale);

void AddSymmetricScaledOuterProduct (DPoint4dCR xyzw, double scale);

void AddSymmetricScaledOuterProduct (DPoint4dCR U, DPoint4dCR V, double scale);

void CopyUpperTriangleToLower ();

void Subtract (DMatrix4dCR delta);


void InitSymmetricProduct
(
DPoint4dCR      sigma,
DMatrix4dCR     B
);

static DMatrix4d FromSandwichProduct
(
TransformCR     transform,
DMatrix4dCR     momentMatrix,
double          scaleFactor
);

bool ConvertInertiaProductsToPrincipalMoments (double &volume, DVec3dR centroid, RotMatrixR axes, DVec3dR momentTensorDiagonal) const;

bool ConvertInertiaProductsToPrincipalMoments (TransformCR localToWorld, double &volume, DVec3dR centroid, RotMatrixR axes, DVec3dR momentTensorDiagonal) const;

bool ConvertInertiaProductsToPrincipalAreaMoments (TransformCR localToWorld, double &area, DVec3dR centroid, RotMatrixR axes, DVec3dR momentTensorDiagonal) const;

bool ConvertInertiaProductsToPrincipalWireMoments (TransformCR localToWorld, double &length, DVec3dR centroid, RotMatrixR axes, DVec3dR momentTensorDiagonal) const;



static DMatrix4d SweepMomentProducts (DMatrix4dCR baseProducts, DVec3d sweepVector);

void GetBlocks (RotMatrixR products, DVec3dR row, DVec3dR column, double &scalar) const;

double MaxAbs () const;

double MaxAbsDiff (DMatrix4dCR other, double &matrixDiff, double &colDiff, double &rowDiff, double &weightDiff) const;

double MaxAbs (double &matrixMax, double &colMax, double &rowMax, double &weightAbs) const;

bool IsIdentity () const;

bool IsAffine () const;

bool ApproximateNullVectorForUpperTriangle
(
DPoint4dR       nullVector,
double          &residual
) const;


#endif
};
END_BENTLEY_GEOMETRY_NAMESPACE