F5surface.h

Go to the documentation of this file.

/*
 *
 *  $Id: F5surface.h,v 1.16 2008/02/26 23:27:14 werner Exp $
 *
 */
 
#ifndef __F5surface_H
#define __F5surface_H
 
#include "F5types.h"
#include "F5coordinates.h"
#include "F5F.h"
 
#include "F5WinDLLApi.h"
 
#ifdef  __cplusplus
extern "C"
{
#endif
 
/**\defgroup surfaces Two-dimensional Surfaces
  */
 
/**\ingroup surfaces
   A helper struct for vertices and connectivity
   for surfaces and similar grid types.
 */
struct  F5Vertices_and_Connectivity
{
        F5Path  *Vertices, *Cells;
};
 
/**\ingroup surfaces
 */
typedef struct  F5Vertices_and_Connectivity F5Vertices_and_Connectivity_t;
 
/**\ingroup surfaces
   Close whatever can be closed here.
*/
F5_API  void    F5closeVC( F5Vertices_and_Connectivity_t* );
 
 
/**\ingroup surfaces
   Write a triangular surface.
   @param file_id    Some HDF5 id corresponding to some already opened HDF5 file.
   @param time       The physical time for this data set.
   @param name       Some textual description of this surface; should be simple
                     (avoid spaces, special characters and extensively long names).
                     It is used to identify surfaces over multiple timesteps,
                     so must be identical for subsequent calls on evolving surfaces.
   @param Coords     The cartesian coordinates of the points
   @param nCoords    How many points are there
   @param Triangles  The connectivity of the triangles, ie. which points belong to
                     each triangle
   @param nTriangles How many triangles are there
   \todo Use the new Field interface from uniform grids
 
   @note This version saves data in SINGLE PRECISION, both for coordinates as
         well as triangle indices. If you need another precision, inspect the
         source of this function and do it manually.
  */
F5_API F5Path*F5write_triangular_surface(hid_t file_id, double time,
                                         const char*name,
                                         const F5_point3f_t*Coords, int nCoords,
                                         const F5_triangle32_t*Triangles, int nTriangles);
 
F5_API  F5Vertices_and_Connectivity_t
        F5write_triangular_surface_vc(hid_t file_id, double time,
                                      const char*name,
                                      const F5_point3f_t*Coords, int nCoords,
                                      const F5_triangle32_t*Triangles, int nTriangles);
 
 
 
/**\ingroup surfaces
   Write a triangular surface.
   Similar to F5write_triangular_surface(), but allow specification of non-standard cartesian coordinate system.
   \todo merge with F5write_triangular_surface
*/
F5_API F5Path*F5Cwrite_triangular_surface(hid_t file_id, double time,
                                          const char*name,
                                          const F5_point3f_t*Coords, int nCoords,
                                          const F5_triangle32_t*Triangles, int nTriangles,
                                          const char*coordinate_system);
 
F5_API F5Vertices_and_Connectivity_t
        F5Cwrite_triangular_surface_vc(hid_t file_id, double time,
                                       const char*name,
                                       const F5_point3f_t*Coords, int nCoords,
                                       const F5_triangle32_t*Triangles, int nTriangles,
                                       const char*coordinate_system);
 
 
/**\ingroup surfaces
   Similar to F5write_triangular_surface(), but instead of writing the
   vertices and triangles as its own dataset, it references those of
   another surface object. The vertices and triangles are then shared
   (in HDF5: symbolic links to the target surface).
   @param Coords The vertices of this surface; if none are given, re-use
                 the vertices from the target surface.
   @param Triangles The triangles of this surfaces; if none are given,
                reuse the triangles from the target surface.
 
   @note Only the Vertex coordinates and Triangle connectivity are shared,
         all other fields remain separate.
 
   @todo make F5Flink_triangular_surface() failsafe. Extend the concept
         of linking datasets for sharing available for other grid
         types as well.
 */
F5_API F5Path*F5Flink_triangular_surface(F5Path*target, double time,
                                         const char*gridname,
                                         const F5_point3f_t*Coords, int nCoords,
                                         const F5_triangle_t*Triangles, int nTriangles,
                                         const char*coordinate_system
#ifdef __cplusplus
                                         = FIBER_HDF5_DEFAULT_CHART
#endif
        );
 
 
 
 
/**\ingroup surfaces
   VertexNormals to be added to the Rep_hid_t
 */
F5_API void F5write_triangular_surface_vertex_vectors(hid_t file_id, double time,
                                               const char*name,
                                               const F5_point3f_t*Coords, int nCoords,
                                               const F5_triangle_t*Triangles, int nTriangles,
                                               const char*fieldname,
                                               const F5_vec3_float_t*VertexNormals);
 
/**\ingroup surfaces
   CellNormals to be added to the Cell_Rep_hid_t
 */
F5_API void F5write_triangular_surface_cell_vectors(hid_t file_id, double time,
                                             const char*name,
                                             const F5_vec3_point_t*Coords, int nCoords,
                                             const F5_triangle_t*Triangles, int nTriangles,
                                             const char*fieldname,
                                             const F5_vec3_float_t*CellNormals);
 
 
/**\ingroup surfaces
   Write a regular surface.
   @param file_id    Some HDF5 id corresponding to some already opened HDF5 file.
   @param time       The physical time for this data set.
   @param name       Some textual description of this surface; should be simple
                     (avoid spaces, special characters and extensively long names).
                     It is used to identify surfaces over multiple timesteps,
                     so must be identical for subsequent calls on evolving surfaces.
   @param Coords     The cartesian coordinates of the points
   @param Xdims      Extension in first dimension
   @param Ydims      Extension in first dimension
  */
F5_API void F5write_regular_surface(hid_t file_id, double time,
                             const char*name,
                             const F5_vec3_point_t*Coords,
                             int Xdims, int Ydims);
 
/**\ingroup surfaces
   A regular surface with a data field on the vertices.
   \note Put data into the `Rep_hid'
 */
F5_API void F5write_regular_surface_vertex_field_dbl(hid_t file_id, double time,
                                              const char*name,
                                              const F5_vec3_point_t*Coords,
                                              int Xdims, int Ydims,
                                              const char*fieldname,
                                              double*data);
 
/**\ingroup surfaces
   A regular surface with a data field on the cells.
   \note Put data into the `Cell_Rep_hid'
      \todo use newer field interface
 */
F5_API void F5write_regular_surface_cell_field_dbl(hid_t file_id, double time,
                                            const char*name,
                                            const F5_vec3_point_t*Coords,
                                            int Xdims, int Ydims,
                                            const char*fieldname,
                                            double*data);
 
/**\ingroup surfaces
   A field of colors given on the vertices.
   \todo use newer field interface
 */
F5_API void F5write_regular_surface_vertex_field_rgb(hid_t file_id, double time,
                                              const char*name,
                                              const F5_vec3_point_t*Coords,
                                              int Xdims, int Ydims,
                                              const char*fieldname,
                                              F5_rgb_t*data);
 
/**\ingroup surfaces
   Write a regular surface.
   Similar to F5write_regular_surface(), but allow specification of non-standard cartesian coordinate system.
   \todo merge with F5Cwrite_regular_surface
*/
F5_API void F5Cwrite_regular_surface(hid_t file_id, double time,
                              const char*name,
                              const F5_vec3_point_t*Coords, int Xdims, int Ydims,
                              const char*coordinate_system);
 
/**\ingroup surfaces
   A surface constructed by cells with four points (quads)
  */
F5_API void F5write_quad_surface(hid_t file_id, double time,
                          const char*name,
                          const F5_vec3_point_t*Coords, int nCoords,
                          const F5_quad_t*Quads, int nQuads);
 
 
 
/**\ingroup surfaces
   Write a surface constructed by cells with four points (quads).
   Similar to F5write_quad_surface(), but allow specification of non-standard cartesian coordinate system.
*/
F5_API void F5Cwrite_quad_surface(hid_t file_id, double time,
                          const char*name,
                          const F5_vec3_point_t*Coords, int nCoords,
                          const F5_quad_t*Quads, int nQuads,
                          const char*coordinate_system);
 
 
 
/**\ingroup surfaces
   A surface with changing number of vertices per cell.
  */
F5_API void F5write_irregular_surface(hid_t file_id, double time,
                               const char*name,
                               const F5_vec3_point_t*Coords,
                               int nCells,
                               const int*CellSizes,
                               const int**CellVertices);
 
#ifdef  __cplusplus
}    /* extern "C" */
#endif
 
#endif  /* __F5surface_H */