## surfaces_points surfaces_points — Define a structure to store a set of triangles defining a surface. |

## Synopsis

    #define             SurfacesPoints_normalOffset
    #define             SurfacesPoints_translationOffset
    #define             SurfacesPoints_userOffset
                        SurfacesPoints;
    void                isosurfacesPointsInit               (SurfacesPoints *points,
                                                             int bufferSize);
    void                isosurfacesPointsAllocate           (SurfacesPoints *points,
                                                             int nsurf,
                                                             int npolys,
                                                             int npoints);
    void                isosurfacesPointsFree               (SurfacesPoints *points);
    void                isosurfacesPointsRemove             (SurfacesPoints *points,
                                                             int pos);
    void                isosurfacesPointsTranslate          (SurfacesPoints *points,
                                                             float xyz[3]);
    void                isosurfacesPointsCheck              (SurfacesPoints *points);

## Description

This structure is used to store and draw polyedges as a set of XYZ points and a set of link to them.

## Details

### SurfacesPoints_normalOffset

    #define SurfacesPoints_normalOffset 3

The offset to read the normal values in poly_points.

### SurfacesPoints_translationOffset

    #define SurfacesPoints_translationOffset 6

The offset to read the translation values in poly_points.

### SurfacesPoints_userOffset

    #define SurfacesPoints_userOffset 9

The offset to read the user values in poly_points.

### SurfacesPoints

    typedef struct {
      /* Number of different surfaces. */
      int nsurf;
      /* This is the size of additional data on each points in addition to
         (x,y,z) coordinates, normal and translation. Then poly_points is
         allocated to (num_points * (9 + bufferSize)). */
      int bufferSize;

      /* Number of polygons */
      int num_polys, num_points;

      /* Number of polygons per surface. */
      int *num_polys_surf;

      /* Give the number of the surface when the number of the
         polygon is given. */
      int *poly_surf_index;

      /* Return the number of vertices when the id of
         the polygon is given. */
      int *poly_num_vertices;

      /* Return the id in poly_points_data of the vertice j of polygon i. */
      int **poly_vertices;

      /* Vectors giving points and normal of the vertice i. */
      float **poly_points_data;
    } SurfacesPoints;

This structure stores geometric description of surfaces. Several surfaces are stored in a single structure for improved performances.

int `nsurf`; | number of surfaces encoded in this structure ;
int `bufferSize`; | number of stored float in addition to coordinates and normals ;
int `num_polys`; | number of polygoins stored in this structure ;
int `num_points`; | number of vertices stored in this structure ;
int *`num_polys_surf`; | number of visible polygons stored in this structure per surface ;
int *`poly_surf_index`; | gives the id of the surface for each polygon, this value ranges from - nsurf to + nsurf. abs(id - 1) gives the index of the surface the polygon is attached to. If values are negative, then the polygon is currently not used ;
int *`poly_num_vertices`; | gives the number of vertices used by each polygons ;
int **`poly_vertices`; | returns the id j of the vertices of polygon i ;
float **`poly_points_data`; | vectors giving additional data of vertex i.

### isosurfacesPointsInit ()

    void                isosurfacesPointsInit               (SurfacesPoints *points,
                                                             int bufferSize);

Initialise a SurfacesPoints structure. It must be done before any use.

`points` : | a pointer on a set of points (not initialised) ;
`bufferSize` : | the number of additional data to coordinates and normals.

### isosurfacesPointsAllocate ()

    void                isosurfacesPointsAllocate           (SurfacesPoints *points,
                                                             int nsurf,
                                                             int npolys,
                                                             int npoints);

Allocate the arrays to store a set of points.

`points` : | a pointer on a set of points (not allocated) ;
`nsurf` : | the number of stored surfaces ;
`npolys` : | the number of stored polygons ;
`npoints` : | the corresponding number of points ;

### isosurfacesPointsFree ()

    void                isosurfacesPointsFree               (SurfacesPoints *points);

Free all allocated arrays of the given set of points. The point structure itself is not freed.

`points` : | a set of points.

### isosurfacesPointsRemove ()

    void                isosurfacesPointsRemove             (SurfacesPoints *points,
                                                             int pos);

Remove the points belonging to surface number `pos`.

`points` : | a set of points ;
`pos` : | an integer between 0 and points->nsurf.

### isosurfacesPointsTranslate ()

    void                isosurfacesPointsTranslate          (SurfacesPoints *points,
                                                             float xyz[3]);

In devel...

`points` : | a set of points.
`xyz` : | a given translation in cartesian coordinates.

### isosurfacesPointsCheck ()

    void                isosurfacesPointsCheck              (SurfacesPoints *points);

A debug routines to check that all pointers and size are relevant. It should not be used outside a debug area because it can be slow.

`points` : | a set of points.