geom Namespace Reference


Classes

struct  ARRAY1D
class  GeomException
struct  ARRAY2D

Typedefs

typedef LIBGEOM_REAL MatriX [4][4]
typedef LIBGEOM_REAL MR3D [3][3]
typedef LIBGEOM_REAL VT3D [3]
typedef LIBGEOM_REAL VHOM [4]
typedef MatriX MatriX_t
typedef MR3D MR3D_t
typedef VT3D VT3D_t
typedef VHOM VHOM_t
typedef LIBGEOM_REAL QUATERNION [4]

Enumerations

enum  { ATTRACTION_NULLE = 0, ATTRACTION_COMPLETE = 1, ATTRACTION_PARTIELLE = 2 }
enum  { GEOM_X_INDEX = 0, GEOM_Y_INDEX = 1, GEOM_Z_INDEX = 2, GEOM_W_INDEX = 3 }

Functions

double safe_acos (double f)
double safe_asin (double f)
void matrix_idt_ (MatriX matrix)
void matrix_copy (const MatriX src, MatriX dst)
void matrix_compose (const MR3D mr, const VT3D vt, MatriX matrix)
void matrix_decompose (MR3D mr, VT3D vt, const MatriX matrix)
void matrix_transpose (const MatriX a, MatriX at)
void matrix_mult_vhom (const MatriX a, const VHOM u, VHOM v)
void matrix_mult_vt3d (const MatriX ma, const VT3D vu, VT3D vv)
void matrix_inverse (const MatriX mdir, MatriX minv)
void matrix_inverse_det (MatriX res, LIBGEOM_REAL determinant, const MatriX source)
LIBGEOM_REAL matrix_cofactor (const MatriX matrix, int i, int j)
LIBGEOM_REAL matrix_determinant (const MatriX matrix)
void matrix_mult (const MatriX ma, const MatriX mb, MatriX mc)
bool matrix_egalite (const MatriX a, const MatriX b)
int matrix_attraction_idt (MatriX a)
int matrix_proximite (const MatriX a, const MatriX b, LIBGEOM_REAL seuil_mr, LIBGEOM_REAL seuil_vt)
bool matrix_write (const MatriX m, FILE *f)
bool matrix_read (MatriX m, FILE *f)
void mr3d_idt_ (MR3D mr)
void mr3d_get (const MatriX matrix, MR3D a)
void mr3d_copy (const MR3D src, MR3D dst)
void mr3d_load (MatriX matrix, const MR3D a)
void mr3d_transpose (const MR3D ma, MR3D mat)
void mr3d_self_transpose (MR3D ma)
void mr3d_perm_circ (MR3D a, MR3D b)
void mr3d_opposite (MR3D a, MR3D b)
void mr3d_symtxy (MR3D a, MR3D b)
void mr3d_scale (const MR3D self, LIBGEOM_REAL scalar, MR3D res)
void mr3d_sub (const MR3D left, const MR3D right, MR3D res)
void mr3d_add (const MR3D left, const MR3D right, MR3D res)
void mr3d_mult (const MR3D a, const MR3D b, MR3D c)
void mr3d_mult_vt3d (const MR3D ma, const VT3D vu, VT3D vv)
void mr3d_from_axis_angle (MR3D mr, const VT3D faxis)
void mr3d_to_axis_angle (VT3D axis, const MR3D mr)
double mr3d_axis_angle (const MR3D mr)
bool mr3d_egalite (const MR3D a, const MR3D b, LIBGEOM_REAL seuil_mr)
int mr3d_attraction_idt (MR3D a, LIBGEOM_REAL seuil_mr)
int mr3d_attraction_ini (MR3D a, LIBGEOM_REAL seuil_mr)
void mr3d_conv_xyz_mob (const MR3D m, LIBGEOM_REAL *ang1, LIBGEOM_REAL *ang2, LIBGEOM_REAL *ang3)
void mr3d_conv_yxz_mob (const MR3D m, LIBGEOM_REAL *ang1, LIBGEOM_REAL *ang2, LIBGEOM_REAL *ang3)
void mr3d_conv_EulerBoulic_zxy (MR3D_t m, LIBGEOM_REAL *ang1, LIBGEOM_REAL *ang2, LIBGEOM_REAL *ang3, bool verbose)
void mr3d_conv_EulerBoulic_zyx (MR3D_t m, LIBGEOM_REAL *ang1, LIBGEOM_REAL *ang2, LIBGEOM_REAL *ang3, bool verbose)
void mr3d_conv_EulerBoulic_zx (MR3D_t m, LIBGEOM_REAL *ang1, LIBGEOM_REAL *ang2, bool verbose)
void mr3d_conv_EulerBoulic_zy (MR3D_t m, LIBGEOM_REAL *ang1, LIBGEOM_REAL *ang2, bool verbose)
void mr3d_conv_EulerBoulic_z (MR3D_t m, LIBGEOM_REAL *ang1, bool verbose)
void mr3d_reorthogonalize (MR3D R, int limit)
bool mr3d_write (const MR3D self, FILE *f)
bool mr3d_read (MR3D self, FILE *f)
void vt3d_get (const MatriX matrix, VT3D v)
void vt3d_load (MatriX matrix, const VT3D v)
void vt3d_vhom (const VT3D vt3d, VHOM vhom)
void vhom_vt3d (const VHOM vhom, VT3D vt3d)
void vt3d_let (LIBGEOM_REAL x, LIBGEOM_REAL y, LIBGEOM_REAL z, VT3D w)
void vt3d_copy (const VT3D src, VT3D dst)
void vt3d_set_null (VT3D dst)
void vt3d_add (const VT3D u, const VT3D v, VT3D w)
void vt3d_sub (const VT3D u, const VT3D v, VT3D w)
void vt3d_mult (const VT3D u, const VT3D v, VT3D w)
void vt3d_div (const VT3D u, const VT3D v, VT3D w)
void vt3d_mults (const VT3D v, LIBGEOM_REAL s, VT3D w)
void vt3d_divs (const VT3D v, LIBGEOM_REAL s, VT3D w)
void vt3d_neg (const VT3D src, VT3D dest)
LIBGEOM_REAL vt3d_get_norm (const VT3D v)
LIBGEOM_REAL vt3d_get_norm2 (const VT3D v)
LIBGEOM_REAL vt3d_get_dist (const VT3D u, const VT3D v)
LIBGEOM_REAL vt3d_get_distptline (const VT3D p, const VT3D q, const VT3D n)
LIBGEOM_REAL vt3d_get_distptplane (const VT3D p, const VT3D q, const VT3D n)
void vt3d_rotv (const VT3D v, LIBGEOM_REAL sa, LIBGEOM_REAL ca, char k, VT3D w)
void vt3d_rotvect (const VT3D v, const VT3D c, VT3D k, LIBGEOM_REAL sa, LIBGEOM_REAL ca, VT3D w)
bool vt3d_normalize (const VT3D u, VT3D v)
void vt3d_cross (const VT3D u, const VT3D v, VT3D w)
void vt3d_scale (const VT3D scale, const VT3D u, VT3D v)
LIBGEOM_REAL vt3d_get_dot (const VT3D u, const VT3D v)
bool vt3d_egalite (const VT3D a, const VT3D b, LIBGEOM_REAL seuil_vt)
int vt3d_attraction_nul (VT3D a, LIBGEOM_REAL seuil_vt)
bool vt3d_write (const VT3D self, FILE *f)
bool vt3d_read (VT3D self, FILE *f)
static void svd_invert (double *target, double *v, double *w, double *J, int width, int height, bool transpose)
void matmxn_compute_LS_and_DLS_inverse (double *LS_inv, double *DLS_inv, double *matrix, int width, int height, double *task, double damping)
void matrix_rotpart (MatriX_t In, MatriX_t Res)
void matrix_mult_opt (const MatriX ma, const MatriX mb, MatriX mc)
void matrix_lerp (const MatriX_t a, const MatriX_t b, LIBGEOM_REAL u, MatriX result)
LIBGEOM_DLL_EXPORT void matrix_idt_ (MatriX_t matrix)
LIBGEOM_DLL_EXPORT void matrix_copy (const MatriX_t src, MatriX_t dst)
LIBGEOM_DLL_EXPORT void matrix_compose (const MR3D_t mr, const VT3D_t vt, MatriX_t matrix)
LIBGEOM_DLL_EXPORT void matrix_decompose (MR3D_t mr, VT3D_t vt, const MatriX_t matrix)
LIBGEOM_DLL_EXPORT void matrix_transpose (const MatriX_t a, MatriX_t at)
LIBGEOM_DLL_EXPORT void matrix_mult_vhom (const MatriX_t a, const VHOM_t u, VHOM_t v)
LIBGEOM_DLL_EXPORT void matrix_mult_vt3d (const MatriX_t a, const VT3D_t u, VT3D_t v)
LIBGEOM_DLL_EXPORT void matrix_inverse (const MatriX_t matrix, MatriX_t matrix_inv)
LIBGEOM_DLL_EXPORT void matrix_inverse_det (MatriX_t res, LIBGEOM_REAL determinant, const MatriX_t source)
LIBGEOM_DLL_EXPORT LIBGEOM_REAL matrix_cofactor (const MatriX_t matrix, int i, int j)
LIBGEOM_DLL_EXPORT LIBGEOM_REAL matrix_determinant (const MatriX_t matrix)
LIBGEOM_DLL_EXPORT void matrix_mult (const MatriX_t ma, const MatriX_t mb, MatriX_t mc)
LIBGEOM_DLL_EXPORT bool matrix_egalite (const MatriX_t a, const MatriX_t b)
LIBGEOM_DLL_EXPORT int matrix_attraction_idt (MatriX_t a)
LIBGEOM_DLL_EXPORT int matrix_proximite (const MatriX_t a, const MatriX_t b, LIBGEOM_REAL seuil_mr, LIBGEOM_REAL seuil_vt)
LIBGEOM_DLL_EXPORT bool matrix_write (const MatriX_t m, FILE *f)
LIBGEOM_DLL_EXPORT bool matrix_read (MatriX_t m, FILE *f)
void mr3d_from_angle_seq_xyz (MR3D mx, LIBGEOM_REAL angX, LIBGEOM_REAL angY, LIBGEOM_REAL angZ)
void mr3d_from_angle_seq_yxz (MR3D mx, LIBGEOM_REAL angY, LIBGEOM_REAL angX, LIBGEOM_REAL angZ)
void mr3d_from_two_vectors (const VT3D_t a, const VT3D_t b, MR3D R)
LIBGEOM_DLL_EXPORT void mr3d_idt_ (MR3D_t mr)
LIBGEOM_DLL_EXPORT void mr3d_get (const MatriX_t matrix, MR3D_t a)
LIBGEOM_DLL_EXPORT void mr3d_copy (const MR3D_t src, MR3D_t dst)
LIBGEOM_DLL_EXPORT void mr3d_load (MatriX_t matrix, const MR3D_t a)
LIBGEOM_DLL_EXPORT void mr3d_transpose (const MR3D_t a, MR3D_t at)
LIBGEOM_DLL_EXPORT void mr3d_self_transpose (MR3D_t ma)
LIBGEOM_DLL_EXPORT void mr3d_perm_circ (MR3D_t a, MR3D_t b)
LIBGEOM_DLL_EXPORT void mr3d_opposite (MR3D_t a, MR3D_t b)
LIBGEOM_DLL_EXPORT void mr3d_symtxy (MR3D_t a, MR3D_t b)
LIBGEOM_DLL_EXPORT void mr3d_scale (const MR3D_t self, LIBGEOM_REAL scalar, MR3D_t res)
LIBGEOM_DLL_EXPORT void mr3d_sub (const MR3D_t left, const MR3D_t right, MR3D_t res)
LIBGEOM_DLL_EXPORT void mr3d_add (const MR3D_t left, const MR3D_t right, MR3D_t res)
LIBGEOM_DLL_EXPORT void mr3d_mult (const MR3D_t a, const MR3D_t b, MR3D_t c)
LIBGEOM_DLL_EXPORT void mr3d_mult_vt3d (const MR3D_t ma, const VT3D_t vu, VT3D_t vv)
LIBGEOM_DLL_EXPORT void mr3d_from_axis_angle (MR3D_t mr, const VT3D_t axis)
LIBGEOM_DLL_EXPORT void mr3d_to_axis_angle (VT3D_t axis, const MR3D_t mr)
LIBGEOM_DLL_EXPORT double mr3d_axis_angle (const MR3D_t mr)
LIBGEOM_DLL_EXPORT bool mr3d_egalite (const MR3D_t a, const MR3D_t b, LIBGEOM_REAL seuil_mr=EPSIL_MR3D)
LIBGEOM_DLL_EXPORT int mr3d_attraction_idt (MR3D_t a, LIBGEOM_REAL seuil_mr)
LIBGEOM_DLL_EXPORT int mr3d_attraction_ini (MR3D_t a, LIBGEOM_REAL seuil_mr)
LIBGEOM_DLL_EXPORT void mr3d_conv_xyz_mob (const MR3D_t m, LIBGEOM_REAL *ang1, LIBGEOM_REAL *ang2, LIBGEOM_REAL *ang3)
LIBGEOM_DLL_EXPORT void mr3d_conv_yxz_mob (const MR3D_t m, LIBGEOM_REAL *ang1, LIBGEOM_REAL *ang2, LIBGEOM_REAL *ang3)
LIBGEOM_DLL_EXPORT void mr3d_reorthogonalize (MR3D_t R, int limit)
LIBGEOM_DLL_EXPORT bool mr3d_write (const MR3D_t self, FILE *f)
LIBGEOM_DLL_EXPORT bool mr3d_read (MR3D_t self, FILE *f)
bool vt3d_inside_polygon (VT3D point, VT3D *p, int N)
void vt3d_rotate_around_axis_angle (const VT3D axis_angle, const VT3D v_in, VT3D v_out)
void vt3d_lerp (const VT3D p1, const VT3D p2, LIBGEOM_REAL u, VT3D result)
void vt3d_slerp (const VT3D p1, const VT3D p2, LIBGEOM_REAL u, VT3D result)
LIBGEOM_DLL_EXPORT void vt3d_get (const MatriX_t matrix, VT3D_t v)
LIBGEOM_DLL_EXPORT void vt3d_load (MatriX_t matrix, const VT3D_t v)
LIBGEOM_DLL_EXPORT void vt3d_copy (const VT3D_t src, VT3D_t dst)
LIBGEOM_DLL_EXPORT void vt3d_set_null (VT3D_t v)
LIBGEOM_DLL_EXPORT bool vt3d_normalize (const VT3D_t u, VT3D_t v)
LIBGEOM_DLL_EXPORT void vt3d_cross (const VT3D_t u, const VT3D_t v, VT3D_t w)
LIBGEOM_DLL_EXPORT void vt3d_scale (const VT3D_t scale, const VT3D_t u, VT3D_t v)
LIBGEOM_DLL_EXPORT LIBGEOM_REAL vt3d_get_dot (const VT3D_t u, const VT3D_t v)
LIBGEOM_DLL_EXPORT void vt3d_vhom (const VT3D_t vt3d, VHOM_t vhom)
LIBGEOM_DLL_EXPORT void vhom_vt3d (const VHOM_t vhom, VT3D_t vt3d)
LIBGEOM_DLL_EXPORT void vt3d_let (LIBGEOM_REAL x, LIBGEOM_REAL y, LIBGEOM_REAL z, VT3D_t w)
LIBGEOM_DLL_EXPORT void vt3d_add (const VT3D_t u, const VT3D_t v, VT3D_t w)
LIBGEOM_DLL_EXPORT void vt3d_sub (const VT3D_t u, const VT3D_t v, VT3D_t w)
LIBGEOM_DLL_EXPORT void vt3d_mult (const VT3D_t u, const VT3D_t v, VT3D_t w)
LIBGEOM_DLL_EXPORT void vt3d_div (const VT3D_t u, const VT3D_t v, VT3D_t w)
LIBGEOM_DLL_EXPORT void vt3d_mults (const VT3D_t v, LIBGEOM_REAL s, VT3D_t w)
LIBGEOM_DLL_EXPORT void vt3d_divs (const VT3D_t v, LIBGEOM_REAL s, VT3D_t w)
LIBGEOM_DLL_EXPORT void vt3d_neg (const VT3D_t src, VT3D_t dest)
LIBGEOM_DLL_EXPORT LIBGEOM_REAL vt3d_get_norm (const VT3D_t v)
LIBGEOM_DLL_EXPORT LIBGEOM_REAL vt3d_get_norm2 (const VT3D_t v)
LIBGEOM_DLL_EXPORT LIBGEOM_REAL vt3d_get_dist (const VT3D_t u, const VT3D_t v)
LIBGEOM_DLL_EXPORT LIBGEOM_REAL vt3d_get_distptline (const VT3D_t p, const VT3D_t q, const VT3D_t n)
LIBGEOM_DLL_EXPORT LIBGEOM_REAL vt3d_get_distptplane (const VT3D_t p, const VT3D_t q, const VT3D_t n)
LIBGEOM_DLL_EXPORT void vt3d_rotv (const VT3D_t v, LIBGEOM_REAL sa, LIBGEOM_REAL ca, char k, VT3D_t w)
LIBGEOM_DLL_EXPORT void vt3d_rotvect (const VT3D_t v, const VT3D_t c, VT3D_t k, LIBGEOM_REAL sa, LIBGEOM_REAL ca, VT3D_t w)
LIBGEOM_DLL_EXPORT bool vt3d_egalite (const VT3D_t a, const VT3D_t b, LIBGEOM_REAL seuil_vt)
LIBGEOM_DLL_EXPORT int vt3d_attraction_nul (VT3D_t a, LIBGEOM_REAL seuil_vt)
LIBGEOM_DLL_EXPORT bool vt3d_write (const VT3D_t self, FILE *f)
LIBGEOM_DLL_EXPORT bool vt3d_read (VT3D_t self, FILE *f)
double * vtn_creation (int n)
void vtn_destr (double *p)
void vtn_nul (double *p, int n)
double vtn_norm (const double *p, int n)
double vtn_anorm (const double *p, int n)
void vtn_copy (const double *psrc, double *pdst, int n)
void vtn_add (const double *p1, const double *p2, double *pdst, int n)
void vtn_sub (const double *p1, const double *p2, double *pdst, int n)
void vtn_mults (const double *psrc, double *pdst, int n, double alpha)
double vtn_dot (const double *p1, const double *p2, int n)
double vtn_inv (const double *p, double *p_inv, int n)
double * matmxn_creation (int lmax, int cmax)
void matmxn_destr (double *p)
void matmxn_nul (double *p, int lmax, int cmax)
void matmxn_idt (double *p, int lmax, int cmax)
void matmxn_copy (const double *a, double *b, int lmax, int cmax)
void matmxn_mult (const double *a, const double *b, double *c, int imax, int jmax, int kmax)
void matmxn_mult_vtn (const double *a, const double *b, double *c, int lmax, int cmax)
void matmxn_write (double *d, int width, int height, FILE *f)
void matmxn_transpose (const double *src, double *dest, int src_width, int src_height)
bool matmxn_pseudo_inverse (double *m, int lmax, int cmax, double *mp)
void matmxn_damped_least_square_inverse (double *j_inv, double *j_mat, int j_width, int j_height, double damping)
void matmxn_svdcmp (double **a, int m, int n, double *w, double **v)
void quat_set (QUATERNION self, LIBGEOM_REAL w, LIBGEOM_REAL x, LIBGEOM_REAL y, LIBGEOM_REAL z)
void quat_set_null (QUATERNION self)
void quat_set_unit (QUATERNION self)
void quat_assign (QUATERNION self, const QUATERNION newQuat)
void quat_copy (const QUATERNION src, QUATERNION dest)
void quat_get_inv (const QUATERNION self, QUATERNION inv)
void quat_get_conj (const QUATERNION self, QUATERNION conj)
LIBGEOM_REAL quat_get_norm (const QUATERNION self)
LIBGEOM_REAL quat_get_distance (const QUATERNION left, const QUATERNION right)
LIBGEOM_REAL quat_get_sdistance (const QUATERNION left, const QUATERNION right)
void quat_neg (QUATERNION self)
void quat_normalize (QUATERNION self)
LIBGEOM_REAL quat_dot (const QUATERNION left, const QUATERNION right)
void quat_pow (const QUATERNION self, LIBGEOM_REAL alpha, QUATERNION result)
void quat_exp (const QUATERNION self, QUATERNION result)
void quat_ln (const QUATERNION self, QUATERNION result)
void quat_mults (const QUATERNION self, LIBGEOM_REAL s, QUATERNION result)
void quat_mult (const QUATERNION left, const QUATERNION right, QUATERNION result)
void quat_sub (const QUATERNION left, const QUATERNION right, QUATERNION result)
void quat_add (const QUATERNION left, const QUATERNION right, QUATERNION result)
void quat_slerp (const QUATERNION left, const QUATERNION right, LIBGEOM_REAL u, QUATERNION result)
void quat_dump (const QUATERNION self)
void quat_from_axis (QUATERNION self, const VT3D axis, LIBGEOM_REAL angle)
void quat_from_axis_angle (QUATERNION q, const VT3D axis_angle)
void quat_to_axis_angle (const QUATERNION quat, VT3D axis)
void quat_from_matrix (const MatriX m, QUATERNION quat)
void quat_from_mr3d (const MR3D m, QUATERNION quat)
void quat_to_matrix (const QUATERNION self, MatriX result)
void quat_to_mr3d (const QUATERNION self, MR3D result)
void quat_from_two_vectors (const VT3D v1, const VT3D v2, QUATERNION q)
void quat_from_swing (QUATERNION q, const LIBGEOM_REAL swing[2])
void quat_from_swing_and_twist (QUATERNION q, const LIBGEOM_REAL swing[2], LIBGEOM_REAL twist)
void quat_to_swing_and_twist (const QUATERNION q, LIBGEOM_REAL swing[2], LIBGEOM_REAL *twist)
ARRAY1D * array1d_creation (int lines)
void array1d_destroy (ARRAY1D *array1d)
void array1d_nul (ARRAY1D *array1d)
double array1d_norm (ARRAY1D *array1d)
double array1d_anorm (ARRAY1D *array1d)
void array1d_copy (ARRAY1D *src, ARRAY1D *dest)
void array1d_add (ARRAY1D *src_left, ARRAY1D *src_right, ARRAY1D *dest)
void array1d_sub (ARRAY1D *src_left, ARRAY1D *src_right, ARRAY1D *dest)
void array1d_mults (ARRAY1D *src, ARRAY1D *dest, double factor)
double array1d_dot (ARRAY1D *src1, ARRAY1D *src2)
double array1d_inv (ARRAY1D *src, ARRAY1D *dest)
void array1d_write (ARRAY1D *a, FILE *file)
ARRAY2D * array2d_creation (int lines, int cols)
void array2d_destroy (ARRAY2D *array2d)
int array2d_same_size (ARRAY2D *a, ARRAY2D *b)
void array2d_nul (ARRAY2D *array2d)
void array2d_idt (ARRAY2D *array2d)
void array2d_copy (ARRAY2D *src, ARRAY2D *dest)
void array2d_mult (ARRAY2D *a, ARRAY2D *b, ARRAY2D *dest)
void array2d_add (ARRAY2D *a, ARRAY2D *b, ARRAY2D *dest)
void array2d_sub (ARRAY2D *a, ARRAY2D *b, ARRAY2D *dest)
void array2d_mult_array1d (ARRAY2D *array2d, ARRAY1D *array1d, ARRAY1D *dest)
void array2d_scale (ARRAY2D *src, float scalar, ARRAY2D *dest)
void array2d_pseudo_inverse (ARRAY2D *src, ARRAY2D *dest)
void array2d_damped_least_square_inverse (ARRAY2D *j_inv, ARRAY2D *j_mat, double damping)
void array2d_compute_LS_and_DLS_inverse (ARRAY2D *LS_inv, ARRAY2D *DLS_inv, ARRAY2D *j_mat, ARRAY1D *task, double damping)
void array2d_write (ARRAY2D *a, FILE *file)
void array2d_set_column (ARRAY2D *array2d, int column, double value)
void array2d_set_line (ARRAY2D *array2d, int line, double value)
void array2d_transpose (ARRAY2D *src, ARRAY2D *dest)
int polynomial_solve_quadric (double c[3], double s[2])
int polynomial_solve_cubic (double c[4], double s[3])
int polynomial_solve_quartic (double c[5], double s[4])

Variables

const float EPSIL_MR3D = 0.00001f
const float EPSIL_VT3D = 0.001f
static LIBGEOM_REAL coef [10]
LIBGEOM_DLL_EXPORT const float EPSIL_MR3D
LIBGEOM_DLL_EXPORT const float EPSIL_VT3D

Typedef Documentation

typedef LIBGEOM_REAL geom::MatriX[4][4]

A 4x4 matrix. Like "gl.h" MatriX

typedef MatriX geom::MatriX_t

typedef LIBGEOM_REAL geom::MR3D[3][3]

A 3x3 rotation matrix (orthogonal)

typedef MR3D geom::MR3D_t

typedef LIBGEOM_REAL geom::QUATERNION[4]

A quaternion : ((x,y,z), w)

typedef LIBGEOM_REAL geom::VHOM[4]

A 4-components homogeneous vector

typedef VHOM geom::VHOM_t

typedef LIBGEOM_REAL geom::VT3D[3]

A 3-components vector

typedef VT3D geom::VT3D_t

Enumeration Type Documentation

anonymous enum

Enumerator:
ATTRACTION_NULLE 
ATTRACTION_COMPLETE 
ATTRACTION_PARTIELLE 

anonymous enum

Enumerator:
GEOM_X_INDEX 
GEOM_Y_INDEX 
GEOM_Z_INDEX 
GEOM_W_INDEX 

Function Documentation

LIBGEOM_DLL_EXPORT void geom::array1d_add ( ARRAY1D *  src_left,
ARRAY1D *  src_right,
ARRAY1D *  dest 
)

Vector addition: dest = src_left + src_right

LIBGEOM_DLL_EXPORT double geom::array1d_anorm ( ARRAY1D *  array1d  ) 

Returns the sum of the absolute values of each entry of the given vector.

LIBGEOM_DLL_EXPORT void geom::array1d_copy ( ARRAY1D *  src,
ARRAY1D *  dest 
)

Copies the contennt of the "src" array into the "dest" array.

LIBGEOM_DLL_EXPORT ARRAY1D * geom::array1d_creation ( int  lines  ) 

Creates an ARRAY1D object describing an 1D array of doubles, with a given number of lines, and returns a pointer to it.

LIBGEOM_DLL_EXPORT void geom::array1d_destroy ( ARRAY1D *  array1d  ) 

Destroys an ARRAY1D object, thus freeing its memory.

LIBGEOM_DLL_EXPORT double geom::array1d_dot ( ARRAY1D *  src1,
ARRAY1D *  src2 
)

Returns the dot product of vectors src1 and src2, i.e. src1 * src2

LIBGEOM_DLL_EXPORT double geom::array1d_inv ( ARRAY1D *  src,
ARRAY1D *  dest 
)

Computes an array "dest" from a given array "src": dest_i = src_i / norm2, where norm2 is the squared norm of src1.

LIBGEOM_DLL_EXPORT void geom::array1d_mults ( ARRAY1D *  src,
ARRAY1D *  dest,
double  factor 
)

Vector scaling by a given factor: dest = factor * src

LIBGEOM_DLL_EXPORT double geom::array1d_norm ( ARRAY1D *  array1d  ) 

Returns the Euclidean norm of the given vector.

LIBGEOM_DLL_EXPORT void geom::array1d_nul ( ARRAY1D *  array1d  ) 

Initializes each entry of an ARRAY1D to zero.

LIBGEOM_DLL_EXPORT void geom::array1d_sub ( ARRAY1D *  src_left,
ARRAY1D *  src_right,
ARRAY1D *  dest 
)

Vector substraction: dest = src_left - src_right

LIBGEOM_DLL_EXPORT void geom::array1d_write ( ARRAY1D *  a,
FILE *  file 
)

Writes the content of an ARRAY1D object to a given file.

LIBGEOM_DLL_EXPORT void geom::array2d_add ( ARRAY2D *  a,
ARRAY2D *  b,
ARRAY2D *  dest 
)

Matrix addition: dest = a + b

Remarks:
The size of the three matrices must be the same, otherwis a fatal error will occur.

LIBGEOM_DLL_EXPORT void geom::array2d_compute_LS_and_DLS_inverse ( ARRAY2D *  LS_inv,
ARRAY2D *  DLS_inv,
ARRAY2D *  j_mat,
ARRAY1D *  task,
double  damping 
)

Warning:
Obsolete.

LIBGEOM_DLL_EXPORT void geom::array2d_copy ( ARRAY2D *  src,
ARRAY2D *  dest 
)

Copies the content of the "src" ARRAY2D object into the "dest" ARRAY2D object.

LIBGEOM_DLL_EXPORT ARRAY2D * geom::array2d_creation ( int  lines,
int  cols 
)

Creates an ARRAY2D object with a given number of lines and columns, and returns a pointer to it.

LIBGEOM_DLL_EXPORT void geom::array2d_damped_least_square_inverse ( ARRAY2D *  j_inv,
ARRAY2D *  j_mat,
double  damping 
)

Computes the damped pseudo-inverse of a given "j_mat" ARRAY2D, with a given damping factor. The result is stored in the "j_mat" ARRAY2D.

Parameters:
j_inv  output matrix
j_mat  input matrix

LIBGEOM_DLL_EXPORT void geom::array2d_destroy ( ARRAY2D *  array2d  ) 

Desrtoys an ARRAY2D object, and thus frees its memory.

LIBGEOM_DLL_EXPORT void geom::array2d_idt ( ARRAY2D *  array2d  ) 

Initializes each (i,j)-th element of the given ARRAY2D according to the following rule: the element is set to one if i == j, and to zero otherwise.

Remarks:
If the ARRAY2D object is square, this is equivalent to an initialization with the identity matrix.

LIBGEOM_DLL_EXPORT void geom::array2d_mult ( ARRAY2D *  a,
ARRAY2D *  b,
ARRAY2D *  dest 
)

Matrix multiplication: dest = a * b

Remarks:
The size of the three matrices must be compatible, otherwise a fatal error will occur. The compatibility conditions are as follows:

LIBGEOM_DLL_EXPORT void geom::array2d_mult_array1d ( ARRAY2D *  array2d,
ARRAY1D *  array1d,
ARRAY1D *  dest 
)

Multiplication of a matrix by a vector : dest = array2d * array1d

Remarks:
The size of the objects must be compatible, otherwise a fatal error will occur.

LIBGEOM_DLL_EXPORT void geom::array2d_nul ( ARRAY2D *  array2d  ) 

Initializes each element of the given ARRAY2D object to zero.

LIBGEOM_DLL_EXPORT void geom::array2d_pseudo_inverse ( ARRAY2D *  src,
ARRAY2D *  dest 
)

Computes the pseudo-inverse of a given "src" ARRAY2D.

Remarks:
The size of the "dest" matrix must be equal to the size of the transpose of the "src" matrix, otherwise a fatal error will occur.

This function is based on Greville's recursive algorithm.

LIBGEOM_DLL_EXPORT int geom::array2d_same_size ( ARRAY2D *  a,
ARRAY2D *  b 
)

Returns TRUE if the two given ARRAY2D objects have same size, i.e. same number of rows (lines) and same number of columns.

LIBGEOM_DLL_EXPORT void geom::array2d_scale ( ARRAY2D *  src,
float  scalar,
ARRAY2D *  dest 
)

Multiplies each element of the src array by a given scalar, and stores the result in the "dest" array.

LIBGEOM_DLL_EXPORT void geom::array2d_set_column ( ARRAY2D *  array2d,
int  column,
double  value 
)

Initializes all elements of a column of an ARRAY2D object with a given value.

LIBGEOM_DLL_EXPORT void geom::array2d_set_line ( ARRAY2D *  array2d,
int  line,
double  value 
)

Initializes all elements of a row (line) of an ARRAY2D object with a given value.

LIBGEOM_DLL_EXPORT void geom::array2d_sub ( ARRAY2D *  a,
ARRAY2D *  b,
ARRAY2D *  dest 
)

Matrix substraction: dest = a - b

Remarks:
The size of the three matrices must be the same, otherwise a fatal error will occur.

LIBGEOM_DLL_EXPORT void geom::array2d_transpose ( ARRAY2D *  src,
ARRAY2D *  dest 
)

Computes the transpose of a given "src" ARRAY2D object, and stores it into the "dest" object.

Remarks:
The size of "src" object must be equal to the size of the transpose of the "dest" object, otherwise a fatal error will occur.

LIBGEOM_DLL_EXPORT void geom::array2d_write ( ARRAY2D *  a,
FILE *  file 
)

Writes the content of a given ARARY2D to a file.

void geom::matmxn_compute_LS_and_DLS_inverse ( double *  LS_inv,
double *  DLS_inv,
double *  matrix,
int  width,
int  height,
double *  task,
double  damping 
)

LIBGEOM_DLL_EXPORT void geom::matmxn_copy ( const double *  a,
double *  b,
int  lmax,
int  cmax 
)

LIBGEOM_DLL_EXPORT double * geom::matmxn_creation ( int  lmax,
int  cmax 
)

LIBGEOM_DLL_EXPORT void geom::matmxn_damped_least_square_inverse ( double *  j_inv,
double *  j_mat,
int  j_width,
int  j_height,
double  damping 
)

LIBGEOM_DLL_EXPORT void geom::matmxn_destr ( double *  p  ) 

LIBGEOM_DLL_EXPORT void geom::matmxn_idt ( double *  p,
int  lmax,
int  cmax 
)

LIBGEOM_DLL_EXPORT void geom::matmxn_mult ( const double *  a,
const double *  b,
double *  c,
int  imax,
int  jmax,
int  kmax 
)

LIBGEOM_DLL_EXPORT void geom::matmxn_mult_vtn ( const double *  a,
const double *  b,
double *  c,
int  lmax,
int  cmax 
)

LIBGEOM_DLL_EXPORT void geom::matmxn_nul ( double *  p,
int  lmax,
int  cmax 
)

LIBGEOM_DLL_EXPORT bool geom::matmxn_pseudo_inverse ( double *  m,
int  lmax,
int  cmax,
double *  mp 
)

LIBGEOM_DLL_EXPORT void geom::matmxn_svdcmp ( double **  a,
int  m,
int  n,
double *  w,
double **  v 
)

LIBGEOM_DLL_EXPORT void geom::matmxn_transpose ( const double *  src,
double *  dest,
int  src_width,
int  src_height 
)

LIBGEOM_DLL_EXPORT void geom::matmxn_write ( double *  d,
int  width,
int  height,
FILE *  f 
)

LIBGEOM_DLL_EXPORT int geom::matrix_attraction_idt ( MatriX_t  a  ) 

This procedure tries to attract a given matrix to the identity.

Returns:
ATTRACTION_NULLE, ATTRACTION_PARTIELLE, ATTRACTION_TOTALE

int geom::matrix_attraction_idt ( MatriX  a  ) 

LIBGEOM_DLL_EXPORT LIBGEOM_REAL geom::matrix_cofactor ( const MatriX_t  matrix,
int  i,
int  j 
)

Returns the cofactor of a given matrix at given indices (i,j)

LIBGEOM_REAL geom::matrix_cofactor ( const MatriX  matrix,
int  i,
int  j 
)

LIBGEOM_DLL_EXPORT void geom::matrix_compose ( const MR3D_t  mr,
const VT3D_t  vt,
MatriX_t  matrix 
)

Builds a 4x4 matrix from given MR3D and VT3D components.

void geom::matrix_compose ( const MR3D  mr,
const VT3D  vt,
MatriX  matrix 
)

LIBGEOM_DLL_EXPORT void geom::matrix_copy ( const MatriX_t  src,
MatriX_t  dst 
)

Copy the "src" matrix into the "dst" matrix.

void geom::matrix_copy ( const MatriX  src,
MatriX  dst 
)

LIBGEOM_DLL_EXPORT void geom::matrix_decompose ( MR3D_t  mr,
VT3D_t  vt,
const MatriX_t  matrix 
)

Decompose a given 4x4 matrix into its rotatin (mr) and translation (vt) components.

void geom::matrix_decompose ( MR3D  mr,
VT3D  vt,
const MatriX  matrix 
)

LIBGEOM_DLL_EXPORT LIBGEOM_REAL geom::matrix_determinant ( const MatriX_t  matrix  ) 

Computes the determinant of a 4x4 matrix.

LIBGEOM_REAL geom::matrix_determinant ( const MatriX  matrix  ) 

LIBGEOM_DLL_EXPORT bool geom::matrix_egalite ( const MatriX_t  a,
const MatriX_t  b 
)

Compares two matrices.

Returns:
Returns TRUE if both matrices are equal, FALSE otherwise.

bool geom::matrix_egalite ( const MatriX  a,
const MatriX  b 
)

LIBGEOM_DLL_EXPORT void geom::matrix_idt_ ( MatriX_t  matrix  ) 

Initializes a matrix with a 4x4 identity matrix.

void geom::matrix_idt_ ( MatriX  matrix  ) 

LIBGEOM_DLL_EXPORT void geom::matrix_inverse ( const MatriX_t  matrix,
MatriX_t  matrix_inv 
)

Computes the inverse of a given matrix.

Warning:
The input matrix is supposed to be affine, i.e. a combination of rotation and translation only.

void geom::matrix_inverse ( const MatriX  mdir,
MatriX  minv 
)

LIBGEOM_DLL_EXPORT void geom::matrix_inverse_det ( MatriX_t  res,
LIBGEOM_REAL  determinant,
const MatriX_t  source 
)

Computes the inverse of a given matrix. Its determinant must be provided.

Warning:
The deteminant must be non-zero (i.e. the matrix must be inversible).

void geom::matrix_inverse_det ( MatriX  res,
LIBGEOM_REAL  determinant,
const MatriX  source 
)

LIBGEOM_DLL_EXPORT void geom::matrix_lerp ( const MatriX_t  a,
const MatriX_t  b,
LIBGEOM_REAL  u,
MatriX  result 
)

Compute interpolation of two matrices, which is a spherical linear interpolation of corresponding quaternions.

Parameters:
a Input matrix
b Input matrix
u interpolation parameter (between 0 and 1)
result Output matrix

LIBGEOM_DLL_EXPORT void geom::matrix_mult ( const MatriX_t  ma,
const MatriX_t  mb,
MatriX_t  mc 
)

Computes matrix multiplication : mc = ma * mb

void geom::matrix_mult ( const MatriX  ma,
const MatriX  mb,
MatriX  mc 
)

LIBGEOM_DLL_EXPORT void geom::matrix_mult_opt ( const MatriX  ma,
const MatriX  mb,
MatriX  mc 
)

Computes matrix multiplication : mc = ma * mb, optimized, *for affine matrices only*

LIBGEOM_DLL_EXPORT void geom::matrix_mult_vhom ( const MatriX_t  a,
const VHOM_t  u,
VHOM_t  v 
)

void geom::matrix_mult_vhom ( const MatriX  a,
const VHOM  u,
VHOM  v 
)

LIBGEOM_DLL_EXPORT void geom::matrix_mult_vt3d ( const MatriX_t  a,
const VT3D_t  u,
VT3D_t  v 
)

Multiplies a 4x4 matrix by a 3-vector.

Remarks:
The term vector may be confusing since in many graphics libs (e.g. Performer), this operation is rather called point multiplication. If you want a true matrix-vector multiply, extract the 3x3 rotation matrix and use mr3d_mult.
Warning:
The matrix is supposed to be affine (i.e. rotation and translation components).
Parameters:
a The input 4x4 matrix
u The input vector
v The output vector

void geom::matrix_mult_vt3d ( const MatriX  ma,
const VT3D  vu,
VT3D  vv 
)

LIBGEOM_DLL_EXPORT int geom::matrix_proximite ( const MatriX_t  a,
const MatriX_t  b,
LIBGEOM_REAL  seuil_mr,
LIBGEOM_REAL  seuil_vt 
)

???

int geom::matrix_proximite ( const MatriX  a,
const MatriX  b,
LIBGEOM_REAL  seuil_mr,
LIBGEOM_REAL  seuil_vt 
)

LIBGEOM_DLL_EXPORT bool geom::matrix_read ( MatriX_t  m,
FILE *  f 
)

Reads a given matrix from a file.

bool geom::matrix_read ( MatriX  m,
FILE *  f 
)

LIBGEOM_DLL_EXPORT void geom::matrix_rotpart ( MatriX_t  In,
MatriX_t  Res 
)

Produces a copy of a given matrix, but with null translation component.

LIBGEOM_DLL_EXPORT void geom::matrix_transpose ( const MatriX_t  a,
MatriX_t  at 
)

Computes the transpose (at) of a given matrix a

void geom::matrix_transpose ( const MatriX  a,
MatriX  at 
)

LIBGEOM_DLL_EXPORT bool geom::matrix_write ( const MatriX_t  m,
FILE *  f 
)

Writes a given matrix to a file.

bool geom::matrix_write ( const MatriX  m,
FILE *  f 
)

LIBGEOM_DLL_EXPORT void geom::mr3d_add ( const MR3D_t  left,
const MR3D_t  right,
MR3D_t  res 
)

Matrix addition: res = left + right

void geom::mr3d_add ( const MR3D  left,
const MR3D  right,
MR3D  res 
)

LIBGEOM_DLL_EXPORT int geom::mr3d_attraction_idt ( MR3D_t  a,
LIBGEOM_REAL  seuil_mr 
)

Attraction towards the identity matrix.

int geom::mr3d_attraction_idt ( MR3D  a,
LIBGEOM_REAL  seuil_mr 
)

LIBGEOM_DLL_EXPORT int geom::mr3d_attraction_ini ( MR3D_t  a,
LIBGEOM_REAL  seuil_mr 
)

???

int geom::mr3d_attraction_ini ( MR3D  a,
LIBGEOM_REAL  seuil_mr 
)

LIBGEOM_DLL_EXPORT double geom::mr3d_axis_angle ( const MR3D_t  mr  ) 

Returns the angle of rotation of the given matrix. The result is in the interval [0, PI].

double geom::mr3d_axis_angle ( const MR3D  mr  ) 

void geom::mr3d_conv_EulerBoulic_z ( MR3D_t  m,
LIBGEOM_REAL *  ang1,
bool  verbose 
)

void geom::mr3d_conv_EulerBoulic_zx ( MR3D_t  m,
LIBGEOM_REAL *  ang1,
LIBGEOM_REAL *  ang2,
bool  verbose 
)

void geom::mr3d_conv_EulerBoulic_zxy ( MR3D_t  m,
LIBGEOM_REAL *  ang1,
LIBGEOM_REAL *  ang2,
LIBGEOM_REAL *  ang3,
bool  verbose 
)

void geom::mr3d_conv_EulerBoulic_zy ( MR3D_t  m,
LIBGEOM_REAL *  ang1,
LIBGEOM_REAL *  ang2,
bool  verbose 
)

void geom::mr3d_conv_EulerBoulic_zyx ( MR3D_t  m,
LIBGEOM_REAL *  ang1,
LIBGEOM_REAL *  ang2,
LIBGEOM_REAL *  ang3,
bool  verbose 
)

LIBGEOM_DLL_EXPORT void geom::mr3d_conv_xyz_mob ( const MR3D_t  m,
LIBGEOM_REAL *  ang1,
LIBGEOM_REAL *  ang2,
LIBGEOM_REAL *  ang3 
)

conversion de la matrice ligne m en trois angles XYZ mobile ang1 et ang3 sont normalises entre + ou - PI, ang2 entre + ou - PI/2

void geom::mr3d_conv_xyz_mob ( const MR3D  m,
LIBGEOM_REAL *  ang1,
LIBGEOM_REAL *  ang2,
LIBGEOM_REAL *  ang3 
)

LIBGEOM_DLL_EXPORT void geom::mr3d_conv_yxz_mob ( const MR3D_t  m,
LIBGEOM_REAL *  ang1,
LIBGEOM_REAL *  ang2,
LIBGEOM_REAL *  ang3 
)

Conversion de la matrice ligne m en trois angles YXZ mobile ang1 et ang3 sont normalises entre + ou - PI, ang2 entre +- PI/2 correspond a la sequence pour l'analyse des mvts en orthopedie.

void geom::mr3d_conv_yxz_mob ( const MR3D  m,
LIBGEOM_REAL *  ang1,
LIBGEOM_REAL *  ang2,
LIBGEOM_REAL *  ang3 
)

LIBGEOM_DLL_EXPORT void geom::mr3d_copy ( const MR3D_t  src,
MR3D_t  dst 
)

Copies an MR3D matrix from "src" to "dest".

void geom::mr3d_copy ( const MR3D  src,
MR3D  dst 
)

LIBGEOM_DLL_EXPORT bool geom::mr3d_egalite ( const MR3D_t  a,
const MR3D_t  b,
LIBGEOM_REAL  seuil_mr = EPSIL_MR3D 
)

Compares two MR3D matrices, with a given tolerance (seuil_mr). Returns TRUE if the difference between two corresponding elements is always lower than the tolerance.

bool geom::mr3d_egalite ( const MR3D  a,
const MR3D  b,
LIBGEOM_REAL  seuil_mr 
)

LIBGEOM_DLL_EXPORT void geom::mr3d_from_angle_seq_xyz ( MR3D  mx,
LIBGEOM_REAL  angX,
LIBGEOM_REAL  angY,
LIBGEOM_REAL  angZ 
)

LIBGEOM_DLL_EXPORT void geom::mr3d_from_angle_seq_yxz ( MR3D  mx,
LIBGEOM_REAL  angY,
LIBGEOM_REAL  angX,
LIBGEOM_REAL  angZ 
)

LIBGEOM_DLL_EXPORT void geom::mr3d_from_axis_angle ( MR3D_t  mr,
const VT3D_t  axis 
)

Converts an axis-angle vector representation of orientation into an MR3D matrix.

void geom::mr3d_from_axis_angle ( MR3D  mr,
const VT3D  faxis 
)

LIBGEOM_DLL_EXPORT void geom::mr3d_from_two_vectors ( const VT3D_t  a,
const VT3D_t  b,
MR3D  R 
)

Set R to the rotation matrix that transforms vector a into b i.e. b = a.R a and b remain untouched and need not be of unit length

LIBGEOM_DLL_EXPORT void geom::mr3d_get ( const MatriX_t  matrix,
MR3D_t  a 
)

Copies the rotation component of a given 4x4 matrix into an MR3D matrix.

void geom::mr3d_get ( const MatriX  matrix,
MR3D  a 
)

LIBGEOM_DLL_EXPORT void geom::mr3d_idt_ ( MR3D_t  mr  ) 

Initializes an MR3D matrix with the identity matrix.

void geom::mr3d_idt_ ( MR3D  mr  ) 

LIBGEOM_DLL_EXPORT void geom::mr3d_load ( MatriX_t  matrix,
const MR3D_t  a 
)

Copies an MR3D matrix into the rotation component of a 4x4 matrix.

void geom::mr3d_load ( MatriX  matrix,
const MR3D  a 
)

LIBGEOM_DLL_EXPORT void geom::mr3d_mult ( const MR3D_t  a,
const MR3D_t  b,
MR3D_t  c 
)

Matrix multiplication: c = a * b

void geom::mr3d_mult ( const MR3D  a,
const MR3D  b,
MR3D  c 
)

LIBGEOM_DLL_EXPORT void geom::mr3d_mult_vt3d ( const MR3D_t  ma,
const VT3D_t  vu,
VT3D_t  vv 
)

Computes matrix-by-vector multiplication: vv = ma * vu

void geom::mr3d_mult_vt3d ( const MR3D  ma,
const VT3D  vu,
VT3D  vv 
)

LIBGEOM_DLL_EXPORT void geom::mr3d_opposite ( MR3D_t  a,
MR3D_t  b 
)

Like mr3d_perm_circ, but the "z" vector (the third row) is negated as well. The result is stored in the "b" matrix.

void geom::mr3d_opposite ( MR3D  a,
MR3D  b 
)

LIBGEOM_DLL_EXPORT void geom::mr3d_perm_circ ( MR3D_t  a,
MR3D_t  b 
)

Circular permutation of the rows. The first row becomes the third row; the second row becomes the first row; the third row becomes the second row. The result is stored into the "b" matrix.

void geom::mr3d_perm_circ ( MR3D  a,
MR3D  b 
)

LIBGEOM_DLL_EXPORT bool geom::mr3d_read ( MR3D_t  self,
FILE *  f 
)

Read an MR3D matri

bool geom::mr3d_read ( MR3D  self,
FILE *  f 
)

LIBGEOM_DLL_EXPORT void geom::mr3d_reorthogonalize ( MR3D_t  R,
int  limit 
)

Re-orthogonalize a given MR3D matrix.

Parameters:
limit ???

void geom::mr3d_reorthogonalize ( MR3D  R,
int  limit 
)

LIBGEOM_DLL_EXPORT void geom::mr3d_scale ( const MR3D_t  self,
LIBGEOM_REAL  scalar,
MR3D_t  res 
)

Multiplies each element of the "self" matrix by the given scalar. The result is stored in the "res" matrix.

void geom::mr3d_scale ( const MR3D  self,
LIBGEOM_REAL  scalar,
MR3D  res 
)

LIBGEOM_DLL_EXPORT void geom::mr3d_self_transpose ( MR3D_t  ma  ) 

Transposes a given MR3D matrix.

void geom::mr3d_self_transpose ( MR3D  ma  ) 

LIBGEOM_DLL_EXPORT void geom::mr3d_sub ( const MR3D_t  left,
const MR3D_t  right,
MR3D_t  res 
)

Matrix substraction: res = left - right

void geom::mr3d_sub ( const MR3D  left,
const MR3D  right,
MR3D  res 
)

LIBGEOM_DLL_EXPORT void geom::mr3d_symtxy ( MR3D_t  a,
MR3D_t  b 
)

Negates the "x" and "y" vectors (the first and second rows). The result is stored in the "b" matrix.

void geom::mr3d_symtxy ( MR3D  a,
MR3D  b 
)

LIBGEOM_DLL_EXPORT void geom::mr3d_to_axis_angle ( VT3D_t  axis,
const MR3D_t  mr 
)

Converts a given MR3D to an axis-angle vector representation.

void geom::mr3d_to_axis_angle ( VT3D  axis,
const MR3D  mr 
)

LIBGEOM_DLL_EXPORT void geom::mr3d_transpose ( const MR3D_t  a,
MR3D_t  at 
)

Computes the transpose of a given MR3D matrix (a) into at.

void geom::mr3d_transpose ( const MR3D  ma,
MR3D  mat 
)

LIBGEOM_DLL_EXPORT bool geom::mr3d_write ( const MR3D_t  self,
FILE *  f 
)

Write the MR3D matrix to a file.

bool geom::mr3d_write ( const MR3D  self,
FILE *  f 
)

LIBGEOM_DLL_EXPORT int geom::polynomial_solve_cubic ( double  c[4],
double  s[3] 
)

LIBGEOM_DLL_EXPORT int geom::polynomial_solve_quadric ( double  c[3],
double  s[2] 
)

LIBGEOM_DLL_EXPORT int geom::polynomial_solve_quartic ( double  c[5],
double  s[4] 
)

LIBGEOM_DLL_EXPORT void geom::quat_add ( const QUATERNION  left,
const QUATERNION  right,
QUATERNION  result 
)

Quaternion addition : result = left + right

LIBGEOM_DLL_EXPORT void geom::quat_assign ( QUATERNION  self,
QUATERNION  newQuat 
)

self = newQuat

LIBGEOM_DLL_EXPORT void geom::quat_copy ( const QUATERNION  src,
QUATERNION  dest 
)

dest = src

LIBGEOM_DLL_EXPORT LIBGEOM_REAL geom::quat_dot ( const QUATERNION  left,
const QUATERNION  right 
)

Returns the dot product of two quaternions: left * right

LIBGEOM_DLL_EXPORT void geom::quat_dump ( const QUATERNION  self  ) 

Writes the quaternion to stdout

LIBGEOM_DLL_EXPORT void geom::quat_exp ( const QUATERNION  self,
QUATERNION  result 
)

Exponentiate quaternion, assuming LIBGEOM_REAL part 0 (w==0)

LIBGEOM_DLL_EXPORT void geom::quat_from_axis ( QUATERNION  self,
const VT3D  axis,
LIBGEOM_REAL  angle 
)

given an angle (radians) and an axis: self = (cos(angle/2),sin(angle/2) * axis)

LIBGEOM_DLL_EXPORT void geom::quat_from_axis_angle ( QUATERNION  q,
const VT3D  axis_angle 
)

Transforms a given axis-angle vector into an equivalent unit quaternion.

LIBGEOM_DLL_EXPORT void geom::quat_from_matrix ( const MatriX  m,
QUATERNION  result 
)

Transforms a rotation matrix (4x4) into a unit quaternion.

LIBGEOM_DLL_EXPORT void geom::quat_from_mr3d ( const MR3D  m,
QUATERNION  result 
)

Transforms a rotation matrix (3x3) into a unit quaternion.

LIBGEOM_DLL_EXPORT void geom::quat_from_swing ( QUATERNION  q,
const LIBGEOM_REAL  swing[2] 
)

Converts a swing parametrization into a unit quaternion.

Remarks:
The swing parametrization is described in Grassia's paper (JGT 98).

LIBGEOM_DLL_EXPORT void geom::quat_from_swing_and_twist ( QUATERNION  q,
const LIBGEOM_REAL  swing[2],
LIBGEOM_REAL  twist 
)

Converts a (swing, twist) parametrization into a unit quaternion.

Remarks:
The swing-twist parametrization is described in Grassia's paper (JGT 98).

LIBGEOM_DLL_EXPORT void geom::quat_from_two_vectors ( const VT3D  v1,
const VT3D  v2,
QUATERNION  q 
)

Computes the unit quaternion that represents the direct rotation that transforms a given vector v1 into another given vector v2.

LIBGEOM_DLL_EXPORT void geom::quat_get_conj ( const QUATERNION  self,
QUATERNION  conj 
)

Sets conj to be the conjugate of self.

Remarks:
The conjugate of a unit quaternion represents the opposite rotation (i.e. it is equivalent to a transpose in matrix format).

LIBGEOM_DLL_EXPORT LIBGEOM_REAL geom::quat_get_distance ( const QUATERNION  left,
const QUATERNION  right 
)

Returns the distance between left and right

LIBGEOM_DLL_EXPORT void geom::quat_get_inv ( const QUATERNION  self,
QUATERNION  inv 
)

Sets inv to the inverse of self

Remarks:
The product of a quaternion by its inverse is the unit quaternion.

LIBGEOM_DLL_EXPORT LIBGEOM_REAL geom::quat_get_norm ( const QUATERNION  self  ) 

Returns the norm of quaternion self

LIBGEOM_DLL_EXPORT LIBGEOM_REAL geom::quat_get_sdistance ( const QUATERNION  left,
const QUATERNION  right 
)

Returns the shortest distance between left and right

LIBGEOM_DLL_EXPORT void geom::quat_ln ( const QUATERNION  self,
QUATERNION  result 
)

Take the natural logarithm of a normalized quaternion

LIBGEOM_DLL_EXPORT void geom::quat_mult ( const QUATERNION  left,
const QUATERNION  right,
QUATERNION  result 
)

Quaternion multiplication : result = left * right

Remarks:
This operation is not commutative : left * right != right * left

LIBGEOM_DLL_EXPORT void geom::quat_mults ( const QUATERNION  self,
LIBGEOM_REAL  s,
QUATERNION  result 
)

Quaternion scaling: result = self * s

LIBGEOM_DLL_EXPORT void geom::quat_neg ( QUATERNION  self  ) 

Negates a quaternion (i.e. negates all its components), to optain its opposite.

Warning:
A unit quaternion and its opposite represent the same orientation.

LIBGEOM_DLL_EXPORT void geom::quat_normalize ( QUATERNION  self  ) 

Normalizes a quaternion (self)

LIBGEOM_DLL_EXPORT void geom::quat_pow ( const QUATERNION  self,
LIBGEOM_REAL  alpha,
QUATERNION  result 
)

Raise a normalized quaternion to the power alpha

LIBGEOM_DLL_EXPORT void geom::quat_set ( QUATERNION  self,
LIBGEOM_REAL  w,
LIBGEOM_REAL  x,
LIBGEOM_REAL  y,
LIBGEOM_REAL  z 
)

Sets quaternion self to have components w, x, y, z

Remarks:
Note the unusual order or parameters.

LIBGEOM_DLL_EXPORT void geom::quat_set_null ( QUATERNION  self  ) 

Sets self to the zero quaternion.

LIBGEOM_DLL_EXPORT void geom::quat_set_unit ( QUATERNION  self  ) 

Sets self to the unit (identity) quaternion

LIBGEOM_DLL_EXPORT void geom::quat_slerp ( const QUATERNION  left,
const QUATERNION  right,
LIBGEOM_REAL  u,
QUATERNION  result 
)

Spherical linear interpolation between left and right. As u goes from 0 to 1, result goes from left to right.

LIBGEOM_DLL_EXPORT void geom::quat_sub ( const QUATERNION  left,
const QUATERNION  right,
QUATERNION  result 
)

Quaternion substraction : result = left - right

LIBGEOM_DLL_EXPORT void geom::quat_to_axis_angle ( const QUATERNION  q,
VT3D  axis_angle 
)

Transforms a given unit quaternion into an equivalent axis-angle vector, whose norm (angle) is included in the interval [0, PI].

LIBGEOM_DLL_EXPORT void geom::quat_to_matrix ( const QUATERNION  self,
MatriX  result 
)

Transforms a unit quaternion into a 4x4 rotation matrix.

LIBGEOM_DLL_EXPORT void geom::quat_to_mr3d ( const QUATERNION  self,
MR3D  result 
)

Transforms a unit quaternion into a 3x3 rotation matrix.

LIBGEOM_DLL_EXPORT void geom::quat_to_swing_and_twist ( const QUATERNION  q,
LIBGEOM_REAL  swing[2],
LIBGEOM_REAL *  twist 
)

Converts a unit quaternion into a (swing, twist) parametrization.

Warning:
The swing-twist parametrization possesses a singularity located at a rotation angle of +- PI, due to the swing component.

LIBGEOM_DLL_EXPORT double geom::safe_acos ( double  f  ) 

Unlike acos, this function is tolerant to numerical errors near domain boundaries.

LIBGEOM_DLL_EXPORT double geom::safe_asin ( double  f  ) 

Unlike asin, this function is tolerant to numerical errors near domain boundaries.

static void geom::svd_invert ( double *  target,
double *  v,
double *  w,
double *  J,
int  width,
int  height,
bool  transpose 
) [static]

LIBGEOM_DLL_EXPORT void geom::vhom_vt3d ( const VHOM_t  vhom,
VT3D_t  vt3d 
)

Transcripts a given 4-components homogeneous vector (vhom), into a 3-components vector (vt3d).

void geom::vhom_vt3d ( const VHOM  vhom,
VT3D  vt3d 
)

LIBGEOM_DLL_EXPORT void geom::vt3d_add ( const VT3D_t  u,
const VT3D_t  v,
VT3D_t  w 
)

Computes vector addition: w = u + v

void geom::vt3d_add ( const VT3D  u,
const VT3D  v,
VT3D  w 
)

LIBGEOM_DLL_EXPORT int geom::vt3d_attraction_nul ( VT3D_t  a,
LIBGEOM_REAL  seuil_vt 
)

int geom::vt3d_attraction_nul ( VT3D  a,
LIBGEOM_REAL  seuil_vt 
)

LIBGEOM_DLL_EXPORT void geom::vt3d_copy ( const VT3D_t  src,
VT3D_t  dst 
)

Copies a source (src) vector to a destination (dst) vector.

void geom::vt3d_copy ( const VT3D  src,
VT3D  dst 
)

LIBGEOM_DLL_EXPORT void geom::vt3d_cross ( const VT3D_t  u,
const VT3D_t  v,
VT3D_t  w 
)

Computes the cross product of two vectors: w = u X v

void geom::vt3d_cross ( const VT3D  u,
const VT3D  v,
VT3D  w 
)

LIBGEOM_DLL_EXPORT void geom::vt3d_div ( const VT3D_t  u,
const VT3D_t  v,
VT3D_t  w 
)

Vector division, component-wise : w_i = u_i / v_i

void geom::vt3d_div ( const VT3D  u,
const VT3D  v,
VT3D  w 
)

LIBGEOM_DLL_EXPORT void geom::vt3d_divs ( const VT3D_t  v,
LIBGEOM_REAL  s,
VT3D_t  w 
)

Vector scaling (division by a scalar s) : w = v / s

void geom::vt3d_divs ( const VT3D  v,
LIBGEOM_REAL  s,
VT3D  w 
)

LIBGEOM_DLL_EXPORT bool geom::vt3d_egalite ( const VT3D_t  a,
const VT3D_t  b,
LIBGEOM_REAL  seuil_vt 
)

Tests equality of two VT3D vectors, within a given tolerance (seuil_vt).

Returns:
Returns TRUE if the vectors are considered equal, and FALSE otherwise.

bool geom::vt3d_egalite ( const VT3D  a,
const VT3D  b,
LIBGEOM_REAL  seuil_vt 
)

LIBGEOM_DLL_EXPORT void geom::vt3d_get ( const MatriX_t  matrix,
VT3D_t  v 
)

Gets the translation component of a 4x4 matrix into the "vt" vector.

void geom::vt3d_get ( const MatriX  matrix,
VT3D  v 
)

LIBGEOM_DLL_EXPORT LIBGEOM_REAL geom::vt3d_get_dist ( const VT3D_t  u,
const VT3D_t  v 
)

Returns the norm of the vector u-v

LIBGEOM_REAL geom::vt3d_get_dist ( const VT3D  u,
const VT3D  v 
)

LIBGEOM_DLL_EXPORT LIBGEOM_REAL geom::vt3d_get_distptline ( const VT3D_t  p,
const VT3D_t  q,
const VT3D_t  n 
)

Returns the distance between a point p and a line described by a point (q) and a unit direction vector (n).

LIBGEOM_REAL geom::vt3d_get_distptline ( const VT3D  p,
const VT3D  q,
const VT3D  n 
)

LIBGEOM_DLL_EXPORT LIBGEOM_REAL geom::vt3d_get_distptplane ( const VT3D_t  p,
const VT3D_t  q,
const VT3D_t  n 
)

Returns the distance between a point p and a plane described by a point (q) and a unit normal vector to the plane (n).

LIBGEOM_REAL geom::vt3d_get_distptplane ( const VT3D  p,
const VT3D  q,
const VT3D  n 
)

LIBGEOM_DLL_EXPORT LIBGEOM_REAL geom::vt3d_get_dot ( const VT3D_t  u,
const VT3D_t  v 
)

Returns the dot product of the two given vectors.

LIBGEOM_REAL geom::vt3d_get_dot ( const VT3D  u,
const VT3D  v 
)

LIBGEOM_DLL_EXPORT LIBGEOM_REAL geom::vt3d_get_norm ( const VT3D_t  v  ) 

Returns the norm of the given vector.

LIBGEOM_REAL geom::vt3d_get_norm ( const VT3D  v  ) 

LIBGEOM_DLL_EXPORT LIBGEOM_REAL geom::vt3d_get_norm2 ( const VT3D_t  v  ) 

Returns the squared norm of the given vector v, i.e. the dot product of v by itself.

LIBGEOM_REAL geom::vt3d_get_norm2 ( const VT3D  v  ) 

LIBGEOM_DLL_EXPORT bool geom::vt3d_inside_polygon ( VT3D  point,
VT3D *  p,
int  N 
)

Test for point inclusion inside a 2D polygon, non necessarily convex, and lying in the X-Y plane.

Parameters:
point The point to be tested. Only (x,y) components are considered.
p A pointer to an array of points, which are the vertices of the polygon.
N The number of vertices of the polygon.
Returns:
TRUE if the point is inside the polygon, FALSE otherwise.
Warning:
The vertices must be ordered in a clock-wise way.

LIBGEOM_DLL_EXPORT void geom::vt3d_lerp ( const VT3D  p1,
const VT3D  p2,
LIBGEOM_REAL  u,
VT3D  result 
)

Linear interpolation between two 3D vectors.

Parameters:
u The interpolation factor between 0. and 1.
Returns:
The result ranges from p1 (when u=0) to p2 (when u=1)

LIBGEOM_DLL_EXPORT void geom::vt3d_let ( LIBGEOM_REAL  x,
LIBGEOM_REAL  y,
LIBGEOM_REAL  z,
VT3D_t  w 
)

Initializes the three components of a vector (w) with given values x, y and z.

void geom::vt3d_let ( LIBGEOM_REAL  x,
LIBGEOM_REAL  y,
LIBGEOM_REAL  z,
VT3D  w 
)

LIBGEOM_DLL_EXPORT void geom::vt3d_load ( MatriX_t  matrix,
const VT3D_t  v 
)

Puts a given vector into the translation component of a 4x4 matrix.

void geom::vt3d_load ( MatriX  matrix,
const VT3D  v 
)

LIBGEOM_DLL_EXPORT void geom::vt3d_mult ( const VT3D_t  u,
const VT3D_t  v,
VT3D_t  w 
)

Vector multiplication, component-wise : w_i = u_i * v_i

void geom::vt3d_mult ( const VT3D  u,
const VT3D  v,
VT3D  w 
)

LIBGEOM_DLL_EXPORT void geom::vt3d_mults ( const VT3D_t  v,
LIBGEOM_REAL  s,
VT3D_t  w 
)

Vector scaling (multiplication by a scalar s) : w = s * v

void geom::vt3d_mults ( const VT3D  v,
LIBGEOM_REAL  s,
VT3D  w 
)

LIBGEOM_DLL_EXPORT void geom::vt3d_neg ( const VT3D_t  src,
VT3D_t  dest 
)

Vector negation: dest = - src

void geom::vt3d_neg ( const VT3D  src,
VT3D  dest 
)

LIBGEOM_DLL_EXPORT bool geom::vt3d_normalize ( const VT3D_t  u,
VT3D_t  v 
)

Computes a normalized vector (v) from a given arbitrary vector u. If the given vector is close to the null vector, the "v" vector is set to zero and FAILURE is returned, otherwise SUCCESS is returned.

bool geom::vt3d_normalize ( const VT3D  u,
VT3D  v 
)

LIBGEOM_DLL_EXPORT bool geom::vt3d_read ( VT3D_t  self,
FILE *  f 
)

Reads a VT3D vector (self) from a file.

bool geom::vt3d_read ( VT3D  self,
FILE *  f 
)

LIBGEOM_DLL_EXPORT void geom::vt3d_rotate_around_axis_angle ( const VT3D  axis_angle,
const VT3D  v_in,
VT3D  v_out 
)

Rotates a given vector (v_in) by an axis-angle vector. The result is stored in the v_out vector. This is based on Rodrigues formula.

LIBGEOM_DLL_EXPORT void geom::vt3d_rotv ( const VT3D_t  v,
LIBGEOM_REAL  sa,
LIBGEOM_REAL  ca,
char  k,
VT3D_t  w 
)

Rotates a given vector (v) around a special axis (x, y or z) by an angle whose sine and cosine must be provided.

Parameters:
v The vector to be rotated
sa The sine of the rotation angle
ca The cosine of the rotation angle
k A char that indicates which axis is to be used ('x', 'y' or 'z')
w The resulting vector

void geom::vt3d_rotv ( const VT3D  v,
LIBGEOM_REAL  sa,
LIBGEOM_REAL  ca,
char  k,
VT3D  w 
)

LIBGEOM_DLL_EXPORT void geom::vt3d_rotvect ( const VT3D_t  v,
const VT3D_t  c,
VT3D_t  k,
LIBGEOM_REAL  sa,
LIBGEOM_REAL  ca,
VT3D_t  w 
)

Rotate v around k passing by point c by angle A radians, whose sine (sa) and cosine (ca) must be provided.

void geom::vt3d_rotvect ( const VT3D  v,
const VT3D  c,
VT3D  k,
LIBGEOM_REAL  sa,
LIBGEOM_REAL  ca,
VT3D  w 
)

LIBGEOM_DLL_EXPORT void geom::vt3d_scale ( const VT3D_t  scale,
const VT3D_t  u,
VT3D_t  v 
)

Scales a given vector: v = scale * u

void geom::vt3d_scale ( const VT3D  scale,
const VT3D  u,
VT3D  v 
)

LIBGEOM_DLL_EXPORT void geom::vt3d_set_null ( VT3D_t  v  ) 

Set to zero the three elements of the given vector.

void geom::vt3d_set_null ( VT3D  dst  ) 

LIBGEOM_DLL_EXPORT void geom::vt3d_slerp ( const VT3D  p1,
const VT3D  p2,
LIBGEOM_REAL  u,
VT3D  result 
)

Spherical linear interpolation between two unit 3D vectors. The result is also a unit norm vector.

Parameters:
u The interpolation factor between 0. and 1.
Returns:
The result ranges from p1 (when u=0) to p2 (when u=1)
Remarks:
This is a sub-case of the 4D version for quaternions (see quat_slerp()).

LIBGEOM_DLL_EXPORT void geom::vt3d_sub ( const VT3D_t  u,
const VT3D_t  v,
VT3D_t  w 
)

Computes vector substraction: w = u - v

void geom::vt3d_sub ( const VT3D  u,
const VT3D  v,
VT3D  w 
)

LIBGEOM_DLL_EXPORT void geom::vt3d_vhom ( const VT3D_t  vt3d,
VHOM_t  vhom 
)

Transcripts a given 3-vector (vt3d) into a 4-components homogeneous vector (vhom), whose fourth component is 1.

void geom::vt3d_vhom ( const VT3D  vt3d,
VHOM  vhom 
)

LIBGEOM_DLL_EXPORT bool geom::vt3d_write ( const VT3D_t  self,
FILE *  f 
)

Writes a VT3D vector (self) to a file.

bool geom::vt3d_write ( const VT3D  self,
FILE *  f 
)

LIBGEOM_DLL_EXPORT void geom::vtn_add ( const double *  p1,
const double *  p2,
double *  pdst,
int  n 
)

LIBGEOM_DLL_EXPORT double geom::vtn_anorm ( const double *  p,
int  n 
)

LIBGEOM_DLL_EXPORT void geom::vtn_copy ( const double *  psrc,
double *  pdst,
int  n 
)

LIBGEOM_DLL_EXPORT double * geom::vtn_creation ( int  n  ) 

LIBGEOM_DLL_EXPORT void geom::vtn_destr ( double *  p  ) 

LIBGEOM_DLL_EXPORT double geom::vtn_dot ( const double *  p1,
const double *  p2,
int  n 
)

LIBGEOM_DLL_EXPORT double geom::vtn_inv ( const double *  p,
double *  p_inv,
int  n 
)

LIBGEOM_DLL_EXPORT void geom::vtn_mults ( const double *  psrc,
double *  pdst,
int  n,
double  alpha 
)

LIBGEOM_DLL_EXPORT double geom::vtn_norm ( const double *  p,
int  n 
)

LIBGEOM_DLL_EXPORT void geom::vtn_nul ( double *  p,
int  n 
)

LIBGEOM_DLL_EXPORT void geom::vtn_sub ( const double *  p1,
const double *  p2,
double *  pdst,
int  n 
)

Variable Documentation

LIBGEOM_REAL geom::coef[10] [static]

Initial value:

                        
  { 1., -1./2., 3./8., -5./16., 35./128., -63./256.,
    231./1024., -429./2048., 6435./32768., -12155./65536. }

LIBGEOM_DLL_EXPORT const float geom::EPSIL_MR3D

const float geom::EPSIL_MR3D = 0.00001f

LIBGEOM_DLL_EXPORT const float geom::EPSIL_VT3D

const float geom::EPSIL_VT3D = 0.001f

Generated on Thu Jan 18 10:06:28 2007 for vhdPLUS by  doxygen 1.5.1-p1