saf_utility_geometry.h

Go to the documentation of this file.

/*
 * Copyright 2020 Leo McCormack
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

 
#ifndef SAF_GEOMETRY_H_INCLUDED
#define SAF_GEOMETRY_H_INCLUDED
 
#include "saf_utility_misc.h"
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

typedef struct _quaternion_data {
    union {
        struct { _Atomic_FLOAT32 w; 
                 _Atomic_FLOAT32 x; 
                 _Atomic_FLOAT32 y; 
                 _Atomic_FLOAT32 z; 
        };
        _Atomic_FLOAT32 Q[4]; 
    };
} quaternion_data;

typedef enum {
    EULER_ROTATION_Y_CONVENTION,   
    EULER_ROTATION_X_CONVENTION,   
    EULER_ROTATION_YAW_PITCH_ROLL, 
    EULER_ROTATION_ROLL_PITCH_YAW  
 
} EULER_ROTATION_CONVENTIONS;

typedef struct _voronoi_data{
    int nVert;           
    int nFaces;          
    float** vert;        
    int** faces;         
    int* nPointsPerFace; 
 
}voronoi_data;
 
 
/* ========================================================================== */
/*                        Basic Geometrical Functions                         */
/* ========================================================================== */

void quaternion2rotationMatrix(/* Input Arguments */
                               quaternion_data* Q,
                               /* Output Arguments */
                               float R[3][3]);

void rotationMatrix2quaternion(/* Input Arguments */
                               float R[3][3],
                               /* Output Arguments */
                               quaternion_data* Q);

void euler2Quaternion(/* Input Arguments */
                      float alpha,
                      float beta,
                      float gamma,
                      int degreesFlag,
                      EULER_ROTATION_CONVENTIONS convention,
                      /* Output Arguments */
                      quaternion_data* Q);

void quaternion2euler(/* Input Arguments */
                      quaternion_data* Q,
                      int degreesFlag,
                      EULER_ROTATION_CONVENTIONS convention,
                      /* Output Arguments */
                      float* alpha,
                      float* beta,
                      float* gamma);

void euler2rotationMatrix(/* Input Arguments */
                          float alpha,
                          float beta,
                          float gamma,
                          int degreesFlag,
                          EULER_ROTATION_CONVENTIONS convention,
                          /* Output Arguments */
                          float R[3][3]);

void yawPitchRoll2Rzyx (/* Input Arguments */
                        float yaw,
                        float pitch,
                        float roll,
                        int rollPitchYawFLAG,
                        /* Output Arguments */
                        float R[3][3]);

void sph2cart(/* Input Arguments */
              float* sph,
              int nDirs,
              int anglesInDegreesFLAG,
              /* Output Arguments */
              float* cart);

void cart2sph(/* Input Arguments */
              float* cart,
              int nDirs,
              int anglesInDegreesFLAG,
              /* Output Arguments */
              float* sph);

void unitSph2cart(/* Input Arguments */
                  float* dirs,
                  int nDirs,
                  int anglesInDegreesFLAG,
                  /* Output Arguments */
                  float* dirs_xyz);

void unitCart2sph(/* Input Arguments */
                  float* dirs_xyz,
                  int nDirs,
                  int anglesInDegreesFLAG,
                  /* Output Arguments */
                  float* dirs);

void sphElev2incl(/* Input Arguments */
                  float* dirsElev,
                  int nDirs,
                  int degreesFlag,
                  /* Output Arguments */
                  float* dirsIncl);

void sphIncl2Elev(/* Input Arguments */
                  float* dirsIncl,
                  int nDirs,
                  int degreesFlag,
                  /* Output Arguments */
                  float* dirsElev);

float L2_norm3(float v[3]);

float L2_norm(float* v, int lenV);

float Frob_norm(float* M, int lenX, int lenY);

void crossProduct3(/* Input Arguments */
                   float a[3],
                   float b[3],
                   /* Output Arguments */
                   float c[3]);

float getDistBetweenPointAndLine(/* Input Arguments */
                                 float point[3],
                                 float v1[3],
                                 float v2[3]);

float getDistBetween2Points(/* Input Arguments */
                            float point_a[3],
                            float point_b[3]);
 
 
/* ========================================================================== */
/*                     Computational Geometry Functions                       */
/* ========================================================================== */

void convhull3d(/* Input Arguments */
                const float* vertices,
                const int nVert,
                /* Output Arguments */
                int** faces,
                int* nFaces);

void convhullnd(/* Input Arguments */
                const float* points,
                const int nPoints,
                const int nd,
                /* Output Arguments */
                int** faces,
                int* nFaces);

void delaunaynd(/* Input Arguments */
                const float* points,
                const int nPoints,
                const int nd,
                /* Output Arguments */
                int** DT,
                int* nDT);

void sphDelaunay(/* Input Arguments */
                 const float* dirs_deg,
                 const int nDirs,
                 /* Output Arguments */
                 int** faces,
                 int* nFaces,
                 float* vertices);

void sphVoronoi(/* Input Arguments */
                int* faces,
                int nFaces,
                float* vertices,
                int nDirs,
                /* Output Arguments */
                voronoi_data* voronoi);

void sphVoronoiAreas(/* Input Arguments */
                     voronoi_data* voronoi,
                     /* Output Arguments */
                     float* areas);

void getVoronoiWeights(/* Input Arguments */
                       float* dirs_deg,
                       int nDirs,
                       int diagFLAG,
                       /* Output Arguments */
                       float* weights);
 
 
#ifdef __cplusplus
}/* extern "C" */
#endif /* __cplusplus */
 
#endif /* SAF_GEOMETRY_H_INCLUDED */
 /* doxygen addtogroup Utilities */