Isosurfaces from 3D functions

struct GtsCartesianGrid

struct GtsCartesianGrid {

  guint nx, ny, nz;
  gdouble x, dx, y, dy, z, dz;
};

A regular cartesian grid is defined by the number of points in each direction, the spatial increment in each direction and the coordinates of the first point.

struct GtsGridPlane

struct GtsGridPlane {

  GtsPoint ** p;
  guint nx, ny;
};

gts_grid_plane_new ()

GtsGridPlane* gts_grid_plane_new            (guint nx,
                                             guint ny);

gts_grid_plane_destroy ()

void        gts_grid_plane_destroy          (GtsGridPlane *g);

struct GtsIsoSlice

struct GtsIsoSlice;

A GtsIsoSlice is an opaque data structure containing the coordinates of the points located on the isosurface for a given slice of the user-defined function.

gts_iso_slice_new ()

GtsIsoSlice* gts_iso_slice_new              (guint nx,
                                             guint ny);

gts_iso_slice_fill ()

void        gts_iso_slice_fill              (GtsIsoSlice *slice,
                                             GtsGridPlane *plane1,
                                             GtsGridPlane *plane2,
                                             gdouble **f1,
                                             gdouble **f2,
                                             gdouble iso,
                                             GtsVertexClass *klass);

Fill slice with the coordinates of the vertices defined by f1 (x,y,z) = iso and f2 (x, y, z) = iso.

gts_iso_slice_fill_cartesian ()

void        gts_iso_slice_fill_cartesian    (GtsIsoSlice *slice,
                                             GtsCartesianGrid g,
                                             gdouble **f1,
                                             gdouble **f2,
                                             gdouble iso,
                                             GtsVertexClass *klass);

Fill slice with the coordinates of the vertices defined by f1 (x,y,z) = iso and f2 (x, y, z) = iso.

gts_iso_slice_destroy ()

void        gts_iso_slice_destroy           (GtsIsoSlice *slice);

Free all memory allocated for slice.

gts_isosurface_slice ()

void        gts_isosurface_slice            (GtsIsoSlice *slice1,
                                             GtsIsoSlice *slice2,
                                             GtsSurface *surface);

Given two successive slices slice1 and slice2 link their vertices with segments and triangles which are added to surface.

GtsIsoCartesianFunc ()

void        (*GtsIsoCartesianFunc)          (gdouble **a,
                                             GtsCartesianGrid g,
                                             guint i,
                                             gpointer data);

This user-defined function is passed to the gts_isosurface_cartesian() function. Given a particular GtsCartesianGrid g it must fill the array a with the values of the function for the plane z=g.z (or for the corresponding index i). This function is always called in order by gts_isosurface_cartesian(), i.e. i varies from 0 to g.nz - 1 with an increment of one (and similarly g.z is incremented every time by g.dz).

gts_isosurface_cartesian ()

void        gts_isosurface_cartesian        (GtsSurface *surface,
                                             GtsCartesianGrid g,
                                             GtsIsoCartesianFunc f,
                                             gpointer data,
                                             gdouble iso);

Adds to surface new faces defining the isosurface f(x,y,z) = iso. By convention, the normals to the surface are pointing toward the positive values of f(x,y,z) - iso.

The user function f is called successively for each value of the z coordinate defined by g. It must fill the corresponding (x,y) plane with the values of the function for which the isosurface is to be computed.

gts_isosurface_tetra ()

void        gts_isosurface_tetra            (GtsSurface *surface,
                                             GtsCartesianGrid g,
                                             GtsIsoCartesianFunc f,
                                             gpointer data,
                                             gdouble iso);

Adds to surface new faces defining the isosurface f(x,y,z) = iso. By convention, the normals to the surface are pointing toward the positive values of f(x,y,z) - iso.

The user function f is called successively for each value of the z coordinate defined by g. It must fill the corresponding (x,y) plane with the values of the function for which the isosurface is to be computed.

gts_isosurface_tetra_bounded ()

void        gts_isosurface_tetra_bounded    (GtsSurface *surface,
                                             GtsCartesianGrid g,
                                             GtsIsoCartesianFunc f,
                                             gpointer data,
                                             gdouble iso);

Adds to surface new faces defining the isosurface f(x,y,z) = iso. By convention, the normals to the surface are pointing toward the positive values of f(x,y,z) - iso. To ensure a closed object, a boundary of G_MINDOUBLE is added around the domain

The user function f is called successively for each value of the z coordinate defined by g. It must fill the corresponding (x,y) plane with the values of the function for which the isosurface is to be computed.

gts_isosurface_tetra_bcl ()

void        gts_isosurface_tetra_bcl        (GtsSurface *surface,
                                             GtsCartesianGrid g,
                                             GtsIsoCartesianFunc f,
                                             gpointer data,
                                             gdouble iso);

Adds to surface new faces defining the isosurface f(x,y,z) = iso. By convention, the normals to the surface are pointing toward the positive values of f(x,y,z) - iso.

The user function f is called successively for each value of the z coordinate defined by g. It must fill the corresponding (x,y) plane with the values of the function for which the isosurface is to be computed.

This version produces the dual "body-centered" faces relative to the faces produced by gts_isosurface_tetra().