Triangles

GTS_TRIANGLE_CLASS()

#define     GTS_TRIANGLE_CLASS(klass)

Casts klass to GtsTriangleClass.

GTS_TRIANGLE()

#define     GTS_TRIANGLE(obj)

Casts obj to GtsTriangle.

GTS_IS_TRIANGLE()

#define     GTS_IS_TRIANGLE(obj)

Evaluates to TRUE if obj is a descendant of GtsTriangle, FALSE otherwise.

struct GtsTriangleClass

struct GtsTriangleClass {

  GtsObjectClass parent_class;
};

The triangle class, just derived from GtsObject.

struct GtsTriangle

struct GtsTriangle {

  GtsObject object;

  GtsEdge * e1;
  GtsEdge * e2;
  GtsEdge * e3;
};

The triangle object.

gts_triangle_class ()

GtsTriangleClass* gts_triangle_class        (void);

gts_triangle_new ()

GtsTriangle* gts_triangle_new               (GtsTriangleClass *klass,
                                             GtsEdge *e1,
                                             GtsEdge *e2,
                                             GtsEdge *e3);

gts_triangle_set ()

void        gts_triangle_set                (GtsTriangle *triangle,
                                             GtsEdge *e1,
                                             GtsEdge *e2,
                                             GtsEdge *e3);

Sets the edge of triangle to e1, e2 and e3 while checking that they define a valid triangle.

gts_triangle_area ()

gdouble     gts_triangle_area               (GtsTriangle *t);

gts_triangle_perimeter ()

gdouble     gts_triangle_perimeter          (GtsTriangle *t);

gts_triangle_quality ()

gdouble     gts_triangle_quality            (GtsTriangle *t);

The quality of a triangle is defined as the ratio of its surface to its perimeter relative to this same ratio for an equilateral triangle with the same area. The quality is then one for an equilateral triangle and tends to zero for a very stretched triangle.

gts_triangle_normal ()

void        gts_triangle_normal             (GtsTriangle *t,
                                             gdouble *x,
                                             gdouble *y,
                                             gdouble *z);

Computes the coordinates of the oriented normal of t as the cross-product of two edges, using the left-hand rule. The normal is not normalized. If this triangle is part of a closed and oriented surface, the normal points to the outside of the surface.

gts_triangle_revert ()

void        gts_triangle_revert             (GtsTriangle *t);

Changes the orientation of triangle t, turning it inside out.

gts_triangle_orientation ()

gdouble     gts_triangle_orientation        (GtsTriangle *t);

Checks for the orientation of the plane (x,y) projection of a triangle. See gts_point_orientation() for details. This function is geometrically robust.

gts_triangle_is_duplicate ()

GtsTriangle* gts_triangle_is_duplicate      (GtsTriangle *t);

gts_triangles_angle ()

gdouble     gts_triangles_angle             (GtsTriangle *t1,
                                             GtsTriangle *t2);

gts_triangles_are_compatible ()

gboolean    gts_triangles_are_compatible    (GtsTriangle *t1,
                                             GtsTriangle *t2,
                                             GtsEdge *e);

Checks if t1 and t2 have compatible orientations i.e. if t1 and t2 can be part of the same surface without conflict in the surface normal orientation.

gts_triangle_enclosing ()

GtsTriangle* gts_triangle_enclosing         (GtsTriangleClass *klass,
                                             GSList *points,
                                             gdouble scale);

Builds a new triangle (including new vertices and edges) enclosing the plane projection of all the points in points. This triangle is equilateral and encloses a rectangle defined by the maximum and minimum x and y coordinates of the points. scale is an homothetic scaling factor. If equal to one, the triangle encloses exactly the enclosing rectangle.

gts_triangles_common_edge ()

GtsEdge*    gts_triangles_common_edge       (GtsTriangle *t1,
                                             GtsTriangle *t2);

gts_triangle_neighbor_number ()

guint       gts_triangle_neighbor_number    (GtsTriangle *t);

gts_triangle_neighbors ()

GSList*     gts_triangle_neighbors          (GtsTriangle *t);

gts_triangle_vertices_edges ()

void        gts_triangle_vertices_edges     (GtsTriangle *t,
                                             GtsEdge *e,
                                             GtsVertex **v1,
                                             GtsVertex **v2,
                                             GtsVertex **v3,
                                             GtsEdge **e1,
                                             GtsEdge **e2,
                                             GtsEdge **e3);

Given t and e, returns v1, v2, v3, e1, e2 and e3. e1 has v1 and v2 as vertices, e2 has v2 and v3 as vertices and e3 has v3 and v1 as vertices. v1, v2 and v3 respects the orientation of t. If e is not NULL, e1 and e are identical.

gts_triangle_vertex_opposite ()

GtsVertex*  gts_triangle_vertex_opposite    (GtsTriangle *t,
                                             GtsEdge *e);

This function fails if e is not an edge of t.

gts_triangle_edge_opposite ()

GtsEdge*    gts_triangle_edge_opposite      (GtsTriangle *t,
                                             GtsVertex *v);

gts_triangle_vertices ()

void        gts_triangle_vertices           (GtsTriangle *t,
                                             GtsVertex **v1,
                                             GtsVertex **v2,
                                             GtsVertex **v3);

Fills v1, v2 and v3 with the oriented set of vertices, summits of t.

gts_triangle_vertex()

#define     gts_triangle_vertex(t)

Evaluates to the GtsVertex of t not used by t->e1.

gts_triangle_is_ok ()

gboolean    gts_triangle_is_ok              (GtsTriangle *t);

gts_triangle_use_edges ()

GtsTriangle* gts_triangle_use_edges         (GtsEdge *e1,
                                             GtsEdge *e2,
                                             GtsEdge *e3);

gts_triangle_circumcircle_center ()

GtsPoint*   gts_triangle_circumcircle_center
                                            (GtsTriangle *t,
                                             GtsPointClass *point_class);

gts_triangle_is_stabbed ()

GtsObject*  gts_triangle_is_stabbed         (GtsTriangle *t,
                                             GtsPoint *p,
                                             gdouble *orientation);

gts_triangles_are_folded ()

gboolean    gts_triangles_are_folded        (GSList *triangles,
                                             GtsVertex *A,
                                             GtsVertex *B,
                                             gdouble max);

Given a list of triangles sharing A and B as vertices, checks if any two triangles in the list make an angle larger than a given value defined by max.

gts_triangles_from_edges ()

GSList*     gts_triangles_from_edges        (GSList *edges);

Builds a list of unique triangles which have one of their edges in edges.