Bindings.GTS

Bindings DSL file for the Gnu Triangulated Surface Library

Documentation

c'GTS_1_OUT_2 :: Num a => a

c'GTS_1_IN_2 :: Num a => a

c'GTS_2_OUT_1 :: Num a => a

c'GTS_2_IN_1 :: Num a => a

c'GTS_CHECK_VERSION :: C'guint -> C'guint -> C'guint -> IO C'gboolean

p'gts_allow_floating_vertices :: Ptr (IO C'gboolean)

data C'GSList

Constructors

C'GSList

Fields

c'GSList'data :: C'gpointer

c'GSList'next :: Ptr C'GSList

Instances

Eq C'GSList

Show C'GSList

Storable C'GSList

data C'GList

Constructors

C'GList

Instances

Eq C'GList

Show C'GList

Storable C'GList

Allocate a node in a GSList from gobject. Note this function should not be used as the append/insert functions call it internally

c'g_slist_alloc :: IO (Ptr C'GSList)

p'g_slist_alloc :: FunPtr (IO (Ptr C'GSList))

Free all the nodes in an GSList. See the glib library

c'g_slist_free :: Ptr C'GSList -> IO ()

p'g_slist_free :: FunPtr (Ptr C'GSList -> IO ())

Free one node in a GSList

c'g_slist_free_1 :: Ptr C'GSList -> IO ()

p'g_slist_free_1 :: FunPtr (Ptr C'GSList -> IO ())

Get the pointer to the next element in the GSList

c'g_slist_next :: Ptr C'GSList -> IO (Ptr C'GSList)

c'g_slist_last :: Ptr C'GSList -> IO (Ptr C'GSList)

Get the pointer to the last element in the GSList

p'g_slist_last :: FunPtr (Ptr C'GSList -> IO (Ptr C'GSList))

Get the length of the GSList

c'g_slist_length :: Ptr C'GSList -> IO C'guint

p'g_slist_length :: FunPtr (Ptr C'GSList -> IO C'guint)

Get the n-th element of the GSList counting from 0

c'g_slist_nth :: Ptr C'GSList -> C'guint -> IO (Ptr C'GSList)

p'g_slist_nth :: FunPtr (Ptr C'GSList -> C'guint -> IO (Ptr C'GSList))

Append a new node to a GSList

c'g_slist_append :: Ptr C'GSList -> C'gpointer -> IO (Ptr C'GSList)

p'g_slist_append :: FunPtr (Ptr C'GSList -> C'gpointer -> IO (Ptr C'GSList))

Insert a new node in a GSList before the referenced node

c'g_slist_insert_before :: Ptr C'GSList -> Ptr C'GSList -> C'gpointer -> IO (Ptr C'GSList)

p'g_slist_insert_before :: FunPtr (Ptr C'GSList -> Ptr C'GSList -> C'gpointer -> IO (Ptr C'GSList))

Insert a new node in a GSList at the specified position

c'g_slist_insert :: Ptr C'GSList -> C'gpointer -> C'gint -> IO (Ptr C'GSList)

p'g_slist_insert :: FunPtr (Ptr C'GSList -> C'gpointer -> C'gint -> IO (Ptr C'GSList))

Callback for the GTS Object class initialization - don't use this unless you know what you are doing

type C'GtsObjectClassInitFunc = FunPtr (Ptr C'GtsObjectClass -> IO ())

mk'GtsObjectClassInitFunc :: (Ptr C'GtsObjectClass -> IO ()) -> IO C'GtsObjectClassInitFunc

type C'GtsObjectInitFunc = FunPtr (Ptr C'GtsObject -> IO ())

Callback for the GTS Object initialization - don't use this unless you know what you are doing

mK'GtsObjectClassInitFunc :: C'GtsObjectClassInitFunc -> Ptr C'GtsObjectClass -> IO ()

mk'GtsObjectInitFunc :: (Ptr C'GtsObject -> IO ()) -> IO C'GtsObjectInitFunc

type C'GtsArgSetFunc = FunPtr (Ptr C'GtsObject -> IO ())

Callback for the GTS argument set method - don't use this unless you know what you are doing

mK'GtsObjectInitFunc :: C'GtsObjectInitFunc -> Ptr C'GtsObject -> IO ()

mk'GtsArgSetFunc :: (Ptr C'GtsObject -> IO ()) -> IO C'GtsArgSetFunc

type C'GtsArgGetFunc = FunPtr (Ptr C'GtsObject -> IO ())

Callback for the GTS argument get method - don't use this unless you know what you are doing

mK'GtsArgSetFunc :: C'GtsArgSetFunc -> Ptr C'GtsObject -> IO ()

mk'GtsArgGetFunc :: (Ptr C'GtsObject -> IO ()) -> IO C'GtsArgGetFunc

c'GTS_CLASS_NAME_LENGTH :: Num a => a

mK'GtsArgGetFunc :: C'GtsArgGetFunc -> Ptr C'GtsObject -> IO ()

data C'GtsVector

Type of the GTS Vector object in Haskell

Constructors

C'GtsVector

Instances

Eq C'GtsVector

Show C'GtsVector

Storable C'GtsVector

Type of the GTS Matrix object in Haskell

data C'GtsMatrix

Constructors

C'GtsMatrix

Instances

Eq C'GtsMatrix

Show C'GtsMatrix

Storable C'GtsMatrix

Create a new GTS Matrix 4x4 object and return the pointer to it.

c'gts_matrix_new :: C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> IO (Ptr C'GtsMatrix)

p'gts_matrix_new :: FunPtr (C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> IO (Ptr C'GtsMatrix))

Set the fields of an existing GTS Matrix object

c'gts_matrix_assign :: Ptr C'GtsMatrix -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> IO (Ptr C'GtsMatrix)

p'gts_matrix_assign :: FunPtr (Ptr C'GtsMatrix -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> C'gdouble -> IO (Ptr C'GtsMatrix))

Destroy a GTS matrix and free the associated memory - Use this with ForeignPtr for GC

c'gts_matrix_destroy :: Ptr C'GtsMatrix -> IO ()

p'gts_matrix_destroy :: FunPtr (Ptr C'GtsMatrix -> IO ())

Set a GTS matrix to the Zero matrix (if the matrix is NULL a new one is allocated)

c'gts_matrix_zero :: Ptr C'GtsMatrix -> IO (Ptr C'GtsMatrix)

p'gts_matrix_zero :: FunPtr (Ptr C'GtsMatrix -> IO (Ptr C'GtsMatrix))

Set a GTS matrix to the Identity matrix (if the matrix is NULL a new one is allocated)

c'gts_matrix_identity :: Ptr C'GtsMatrix -> IO (Ptr C'GtsMatrix)

p'gts_matrix_identity :: FunPtr (Ptr C'GtsMatrix -> IO (Ptr C'GtsMatrix))

Transpose a GTS Matrix and return the newly allocated matrix

c'gts_matrix_transpose :: Ptr C'GtsMatrix -> IO (Ptr C'GtsMatrix)

p'gts_matrix_transpose :: FunPtr (Ptr C'GtsMatrix -> IO (Ptr C'GtsMatrix))

Invert a GTS Matrix and return the newly allocated matrix or NULL if the matrix can't be inverted

c'gts_matrix_inverse :: Ptr C'GtsMatrix -> IO (Ptr C'GtsMatrix)

p'gts_matrix_inverse :: FunPtr (Ptr C'GtsMatrix -> IO (Ptr C'GtsMatrix))

Calculate the product of two matricies and return the newly allocated matrix

c'gts_matrix_product :: Ptr C'GtsMatrix -> Ptr C'GtsMatrix -> IO (Ptr C'GtsMatrix)

p'gts_matrix_product :: FunPtr (Ptr C'GtsMatrix -> Ptr C'GtsMatrix -> IO (Ptr C'GtsMatrix))

Scale a GTS Matrix in place

c'gts_matrix_scale :: Ptr C'GtsMatrix -> Ptr C'GtsVector -> IO (Ptr C'GtsMatrix)

p'gts_matrix_scale :: FunPtr (Ptr C'GtsMatrix -> Ptr C'GtsVector -> IO (Ptr C'GtsMatrix))

Translate the GTS Matrix by the GTS Vector (If the Matrix is NULL a new one is allocated and translated)

c'gts_matrix_translate :: Ptr C'GtsMatrix -> Ptr C'GtsVector -> IO (Ptr C'GtsMatrix)

p'gts_matrix_translate :: FunPtr (Ptr C'GtsMatrix -> Ptr C'GtsVector -> IO (Ptr C'GtsMatrix))

Rotate the GTS Matrix around the vector by the

c'gts_matrix_rotate :: Ptr C'GtsMatrix -> Ptr C'GtsVector -> C'gdouble -> IO (Ptr C'GtsMatrix)

p'gts_matrix_rotate :: FunPtr (Ptr C'GtsMatrix -> Ptr C'GtsVector -> C'gdouble -> IO (Ptr C'GtsMatrix))

Type for an (r,g,b) triple in GTS (floating point)

data C'GtsColor

Constructors

C'GtsColor

Fields

c'GtsColor'r :: C'gfloat

c'GtsColor'g :: C'gfloat

c'GtsColor'b :: C'gfloat

Instances

Eq C'GtsColor

Show C'GtsColor

Storable C'GtsColor

Callback for most GTS visitors

type C'GtsFunc = FunPtr (C'gpointer -> C'gpointer -> IO C'gint)

mk'GtsFunc :: (C'gpointer -> C'gpointer -> IO C'gint) -> IO C'GtsFunc

type C'GtsVertexMergeFunc = FunPtr (Ptr C'GtsVertex -> Ptr C'GtsVertex -> IO C'gboolean)

Callback for gts_vertices_merge

mK'GtsFunc :: C'GtsFunc -> C'gpointer -> C'gpointer -> IO C'gint

mk'GtsVertexMergeFunc :: (Ptr C'GtsVertex -> Ptr C'GtsVertex -> IO C'gboolean) -> IO C'GtsVertexMergeFunc

mK'GtsVertexMergeFunc :: C'GtsVertexMergeFunc -> Ptr C'GtsVertex -> Ptr C'GtsVertex -> IO C'gboolean

GTS formatted data file

data C'GtsFile

Constructors

C'GtsFile

Fields

c'GtsFile'line :: C'guint

c'GtsFile'pos :: C'guint

c'GtsFile'error :: Ptr C'gchar

Instances

Eq C'GtsFile

Show C'GtsFile

Storable C'GtsFile

A GTS formatted data file variable

data C'GtsFileVariable

Constructors

C'GtsFileVariable

Instances

Eq C'GtsFileVariable

Show C'GtsFileVariable

Storable C'GtsFileVariable

Open a C file

c'fopen :: CString -> CString -> IO (Ptr CFile)

p'fopen :: FunPtr (CString -> CString -> IO (Ptr CFile))

Close a C file

c'fclose :: Ptr CFile -> IO Int

p'fclose :: FunPtr (Ptr CFile -> IO Int)

Create a new GTS file handle from an C file

c'gts_file_new :: Ptr CFile -> IO (Ptr C'GtsFile)

p'gts_file_new :: FunPtr (Ptr CFile -> IO (Ptr C'GtsFile))

Create a new GTS file handle from a C String. Note this method doesn't seem to work

c'gts_file_new_from_string :: Ptr C'gchar -> IO (Ptr C'GtsFile)

p'gts_file_new_from_string :: FunPtr (Ptr C'gchar -> IO (Ptr C'GtsFile))

Get a character from a GTS file (Don't use this)

c'gts_file_getc :: Ptr C'GtsFile -> IO C'gint

p'gts_file_getc :: FunPtr (Ptr C'GtsFile -> IO C'gint)

Destroy a GTS file handle and free the memory

c'gts_file_destroy :: IO (Ptr C'GtsFile)

p'gts_file_destroy :: FunPtr (IO (Ptr C'GtsFile))

data C'GtsObjectClassInfo

Constructors

C'GtsObjectClassInfo

Fields

c'GtsObjectClassInfo'name :: [C'gchar]

c'GtsObjectClassInfo'object_size :: C'guint

c'GtsObjectClassInfo'class_size :: C'guint

Instances

Eq C'GtsObjectClassInfo

Show C'GtsObjectClassInfo

Storable C'GtsObjectClassInfo

data C'GtsObjectClass

Constructors

C'GtsObjectClass

Fields

c'GtsObjectClass'info :: C'GtsObjectClassInfo

c'GtsObjectClass'parent_class :: Ptr C'GtsObjectClass

Instances

Eq C'GtsObjectClass

Show C'GtsObjectClass

Storable C'GtsObjectClass

data C'GtsObject

Constructors

C'GtsObject

Fields

c'GtsObject'klass :: Ptr C'GtsObjectClass

c'GtsObject'flags :: C'guint32

Instances

Eq C'GtsObject

Show C'GtsObject

Storable C'GtsObject

data C'GtsPointClass

Constructors

C'GtsPointClass

Fields

c'GtsPointClass'parent_class :: C'GtsObjectClass

c'GtsPointClass'binary :: C'gboolean

Instances

Eq C'GtsPointClass

Show C'GtsPointClass

Storable C'GtsPointClass

data C'GtsPoint

Constructors

C'GtsPoint

Fields

c'GtsPoint'object :: Ptr C'GtsObject

c'GtsPoint'x :: C'gdouble

c'GtsPoint'y :: C'gdouble

c'GtsPoint'z :: C'gdouble

Instances

Eq C'GtsPoint

Show C'GtsPoint

Storable C'GtsPoint

c'gts_object_class :: IO C'gpointer

c'gts_object_class_new :: Ptr C'GtsObjectClass -> Ptr C'GtsObjectClassInfo -> IO C'gpointer

p'gts_object_class :: FunPtr (IO C'gpointer)

c'gts_object_check_cast :: C'gpointer -> C'gpointer -> IO C'gpointer

c'gts_object_class_check_cast :: C'gpointer -> C'gpointer -> IO C'gpointer

p'gts_object_class_new :: FunPtr (Ptr C'GtsObjectClass -> Ptr C'GtsObjectClassInfo -> IO C'gpointer)

p'gts_object_check_cast :: FunPtr (C'gpointer -> C'gpointer -> IO C'gpointer)

p'gts_object_class_check_cast :: FunPtr (C'gpointer -> C'gpointer -> IO C'gpointer)

c'gts_object_class_from_name :: Ptr C'gchar -> IO (Ptr C'GtsObjectClass)

p'gts_object_class_from_name :: FunPtr (Ptr C'gchar -> IO (Ptr C'GtsObjectClass))

data C'GtsRange

Constructors

C'GtsRange

Fields

c'GtsRange'min :: C'gdouble

c'GtsRange'max :: C'gdouble

c'GtsRange'sum :: C'gdouble

c'GtsRange'sum2 :: C'gdouble

c'GtsRange'mean :: C'gdouble

c'GtsRange'stddev :: C'gdouble

c'GtsRange'n :: C'guint

Instances

Eq C'GtsRange

Show C'GtsRange

Storable C'GtsRange

data C'GtsSegment

Constructors

C'GtsSegment

Instances

Eq C'GtsSegment

Show C'GtsSegment

Storable C'GtsSegment

data C'GtsTriangleClass

Constructors

C'GtsTriangleClass

Instances

Eq C'GtsTriangleClass

Show C'GtsTriangleClass

Storable C'GtsTriangleClass

data C'GtsTriangle

Constructors

C'GtsTriangle

Fields

c'GtsTriangle'e1 :: Ptr C'GtsEdge

c'GtsTriangle'e2 :: Ptr C'GtsEdge

c'GtsTriangle'e3 :: Ptr C'GtsEdge

Instances

Eq C'GtsTriangle

Show C'GtsTriangle

Storable C'GtsTriangle

Create a triangle which is guarenteed to enclose all the points in the list

c'gts_triangle_enclosing :: Ptr C'GtsTriangleClass -> Ptr C'GSList -> C'gdouble -> IO (Ptr C'GtsTriangle)

p'gts_triangle_enclosing :: FunPtr (Ptr C'GtsTriangleClass -> Ptr C'GSList -> C'gdouble -> IO (Ptr C'GtsTriangle))

Get the class descriptor for the GTS Triangle class

c'gts_triangle_class :: IO (Ptr C'GtsTriangleClass)

p'gts_triangle_class :: FunPtr (IO (Ptr C'GtsTriangleClass))

Create a new triangle from 3 edges

c'gts_triangle_new :: Ptr C'GtsTriangleClass -> Ptr C'GtsEdge -> Ptr C'GtsEdge -> Ptr C'GtsEdge -> IO (Ptr C'GtsTriangle)

p'gts_triangle_new :: FunPtr (Ptr C'GtsTriangleClass -> Ptr C'GtsEdge -> Ptr C'GtsEdge -> Ptr C'GtsEdge -> IO (Ptr C'GtsTriangle))

Discard the existing edges of the triangle and replace with the new ones

c'gts_triangle_set :: Ptr C'GtsTriangleClass -> Ptr C'GtsEdge -> Ptr C'GtsEdge -> Ptr C'GtsEdge -> IO ()

p'gts_triangle_set :: FunPtr (Ptr C'GtsTriangleClass -> Ptr C'GtsEdge -> Ptr C'GtsEdge -> Ptr C'GtsEdge -> IO ())

Get the area of this triangle

c'gts_triangle_area :: Ptr C'GtsTriangle -> IO C'gdouble

p'gts_triangle_area :: FunPtr (Ptr C'GtsTriangle -> IO C'gdouble)

Get the perimeter of this triangle

c'gts_triangle_perimeter :: Ptr C'GtsTriangle -> IO C'gdouble

p'gts_triangle_perimeter :: FunPtr (Ptr C'GtsTriangle -> IO C'gdouble)

Get a measure of the quality of this triangle (how close to equilateral it is?)

c'gts_triangle_quality :: Ptr C'GtsTriangle -> IO C'gdouble

p'gts_triangle_quality :: FunPtr (Ptr C'GtsTriangle -> IO C'gdouble)

Get the normal to the plane of this triangle

c'gts_triangle_normal :: Ptr C'GtsTriangle -> Ptr C'gdouble -> Ptr C'gdouble -> Ptr C'gdouble -> IO ()

p'gts_triangle_normal :: FunPtr (Ptr C'GtsTriangle -> Ptr C'gdouble -> Ptr C'gdouble -> Ptr C'gdouble -> IO ())

Changes the orientation of triangle t, turning it inside out

c'gts_triangle_revert :: Ptr C'GtsTriangle -> IO ()

c'gts_triangle_orientation :: Ptr C'GtsTriangle -> IO C'gdouble

p'gts_triangle_revert :: FunPtr (Ptr C'GtsTriangle -> IO ())

c'gts_triangle_neighbors :: Ptr C'GtsTriangle -> IO (Ptr C'GSList)

p'gts_triangle_orientation :: FunPtr (Ptr C'GtsTriangle -> IO C'gdouble)

c'gts_triangle_vertices_edges :: Ptr C'GtsTriangle -> Ptr C'GtsEdge -> Ptr (Ptr C'GtsVertex) -> Ptr (Ptr C'GtsVertex) -> Ptr (Ptr C'GtsVertex) -> Ptr (Ptr C'GtsEdge) -> Ptr (Ptr C'GtsEdge) -> Ptr (Ptr C'GtsEdge) -> IO ()

p'gts_triangle_neighbors :: FunPtr (Ptr C'GtsTriangle -> IO (Ptr C'GSList))

c'gts_triangle_vertices :: Ptr C'GtsTriangle -> Ptr C'GtsEdge -> Ptr (Ptr C'GtsVertex) -> Ptr (Ptr C'GtsVertex) -> Ptr (Ptr C'GtsVertex) -> IO ()

c'gts_triangle_vertex_opposite :: Ptr C'GtsTriangle -> Ptr C'GtsEdge -> IO (Ptr C'GtsVertex)

p'gts_triangle_vertices_edges :: FunPtr (Ptr C'GtsTriangle -> Ptr C'GtsEdge -> Ptr (Ptr C'GtsVertex) -> Ptr (Ptr C'GtsVertex) -> Ptr (Ptr C'GtsVertex) -> Ptr (Ptr C'GtsEdge) -> Ptr (Ptr C'GtsEdge) -> Ptr (Ptr C'GtsEdge) -> IO ())

c'gts_triangle_edge_opposite :: Ptr C'GtsTriangle -> Ptr C'GtsVertex -> IO (Ptr C'GtsEdge)

p'gts_triangle_vertices :: FunPtr (Ptr C'GtsTriangle -> Ptr C'GtsEdge -> Ptr (Ptr C'GtsVertex) -> Ptr (Ptr C'GtsVertex) -> Ptr (Ptr C'GtsVertex) -> IO ())

c'gts_triangle_is_ok :: Ptr C'GtsTriangle -> IO C'gboolean

p'gts_triangle_vertex_opposite :: FunPtr (Ptr C'GtsTriangle -> Ptr C'GtsEdge -> IO (Ptr C'GtsVertex))

c'gts_triangle_circumcircle_center :: Ptr C'GtsTriangle -> Ptr C'GtsPointClass -> IO (Ptr C'GtsPoint)

p'gts_triangle_edge_opposite :: FunPtr (Ptr C'GtsTriangle -> Ptr C'GtsVertex -> IO (Ptr C'GtsEdge))

p'gts_triangle_is_ok :: FunPtr (Ptr C'GtsTriangle -> IO C'gboolean)

c'gts_triangle_interpolate_height :: Ptr C'GtsTriangle -> Ptr C'GtsPoint -> IO ()

c'gts_triangles_from_edges :: Ptr C'GSList -> IO (Ptr C'GSList)

p'gts_triangle_circumcircle_center :: FunPtr (Ptr C'GtsTriangle -> Ptr C'GtsPointClass -> IO (Ptr C'GtsPoint))

p'gts_triangle_interpolate_height :: FunPtr (Ptr C'GtsTriangle -> Ptr C'GtsPoint -> IO ())

p'gts_triangles_from_edges :: FunPtr (Ptr C'GSList -> IO (Ptr C'GSList))

data C'GtsVertex

Constructors

C'GtsVertex

Fields

c'GtsVertex'p :: C'GtsPoint

Instances

Eq C'GtsVertex

Show C'GtsVertex

Storable C'GtsVertex

data C'GtsVertexClass

Constructors

C'GtsVertexClass

Instances

Eq C'GtsVertexClass

Show C'GtsVertexClass

Storable C'GtsVertexClass

Clear a range

c'gts_range_init :: Ptr C'GtsRange -> IO ()

c'gts_range_reset :: Ptr C'GtsRange -> IO ()

p'gts_range_init :: FunPtr (Ptr C'GtsRange -> IO ())

c'gts_range_add_value :: Ptr C'GtsRange -> C'gdouble -> IO ()

c'gts_range_update :: Ptr C'GtsRange -> IO ()

p'gts_range_reset :: FunPtr (Ptr C'GtsRange -> IO ())

p'gts_range_add_value :: FunPtr (Ptr C'GtsRange -> C'gdouble -> IO ())

p'gts_range_update :: FunPtr (Ptr C'GtsRange -> IO ())

GLib class pointer for the GTS point object class

c'gts_point_class :: IO (Ptr C'GtsPointClass)

p'gts_point_class :: FunPtr (IO (Ptr C'GtsPointClass))

Create a new GTS point in 3d space

c'gts_point_new :: Ptr C'GtsPointClass -> C'gdouble -> C'gdouble -> C'gdouble -> IO (Ptr C'GtsPoint)

p'gts_point_new :: FunPtr (Ptr C'GtsPointClass -> C'gdouble -> C'gdouble -> C'gdouble -> IO (Ptr C'GtsPoint))

Set the value of a GTS point in 3d space

c'gts_point_set :: Ptr C'GtsPoint -> C'gdouble -> C'gdouble -> C'gdouble -> IO ()

p'gts_point_set :: FunPtr (Ptr C'GtsPoint -> C'gdouble -> C'gdouble -> C'gdouble -> IO ())

True iff the point is within or on the boundary of the box defined by the two other points

c'gts_point_is_in_rectangle :: Ptr C'GtsPoint -> Ptr C'GtsPoint -> Ptr C'GtsPoint -> IO C'gboolean

c'gts_vertex_class :: IO (Ptr C'GtsVertexClass)

GLib class pointer for the GTS vertex class (vertex derives from point)

p'gts_vertex_class :: FunPtr (IO (Ptr C'GtsVertexClass))

Create a new GTS vertex in 3d space

c'gts_vertex_new :: Ptr C'GtsVertexClass -> C'gdouble -> C'gdouble -> C'gdouble -> IO (Ptr C'GtsVertex)

p'gts_vertex_new :: FunPtr (Ptr C'GtsVertexClass -> C'gdouble -> C'gdouble -> C'gdouble -> IO (Ptr C'GtsVertex))

True if this vertex is not part of a GTS segment

c'gts_vertex_is_unattached :: Ptr C'GtsVertex -> IO C'gboolean

p'gts_vertex_is_unattached :: FunPtr (Ptr C'GtsVertex -> IO C'gboolean)

Return the number of connected triangles sharing the vertex, if second parameter is true then sever the connection

c'gts_vertex_is_contact :: Ptr C'GtsVertex -> C'gboolean -> IO C'guint

p'gts_vertex_is_contact :: FunPtr (Ptr C'GtsVertex -> C'gboolean -> IO C'guint)

Null unless two vertices are the endpoints of the same segment, in which case return the segment

c'gts_vertices_are_connected :: Ptr C'GtsVertex -> Ptr C'GtsVertex -> IO (Ptr C'GtsSegment)

p'gts_vertices_are_connected :: FunPtr (Ptr C'GtsVertex -> Ptr C'GtsVertex -> IO (Ptr C'GtsSegment))

Replace a vertex with another vertex and update all objects using it

c'gts_vertex_replace :: Ptr C'GtsVertex -> Ptr C'GtsVertex -> IO ()

p'gts_vertex_replace :: FunPtr (Ptr C'GtsVertex -> Ptr C'GtsVertex -> IO ())

Adds to list all the GtsVertex connected to v by a GtsSegment and not already in list. If surface is not NULL only the vertices connected to v by an edge belonging to surface are considered.

c'gts_vertex_neighbors :: Ptr C'GtsVertex -> Ptr C'GSList -> Ptr C'GtsSurface -> IO (Ptr C'GSList)

p'gts_vertex_neighbors :: FunPtr (Ptr C'GtsVertex -> Ptr C'GSList -> Ptr C'GtsSurface -> IO (Ptr C'GSList))

Adds all the GtsTriangle which share v as a vertex and do not already belong to list.

c'gts_vertex_triangles :: Ptr C'GtsVertex -> Ptr C'GSList -> IO (Ptr C'GSList)

p'gts_vertex_triangles :: FunPtr (Ptr C'GtsVertex -> Ptr C'GSList -> IO (Ptr C'GSList))

Adds all the GtsFace belonging to surface (if not NULL) which share v as a vertex and do not already belong to list.

c'gts_vertex_faces :: Ptr C'GtsVertex -> Ptr C'GtsSurface -> Ptr C'GSList -> IO (Ptr C'GSList)

p'gts_vertex_faces :: FunPtr (Ptr C'GtsVertex -> Ptr C'GtsSurface -> Ptr C'GSList -> IO (Ptr C'GSList))

A list of GtsEdge describing in counterclockwise order the boundary of the fan of summit v, the faces of the fan belonging to surface

c'gts_vertex_fan_oriented :: Ptr C'GtsVertex -> Ptr C'GtsSurface -> IO (Ptr C'GSList)

p'gts_vertex_fan_oriented :: FunPtr (Ptr C'GtsVertex -> Ptr C'GtsSurface -> IO (Ptr C'GSList))

TRUE if v is strictly contained in the diametral circle of e, FALSE otherwise

c'gts_vertex_encroaches_edge :: Ptr C'GtsVertex -> Ptr C'GtsEdge -> IO C'gboolean

p'gts_vertex_encroaches_edge :: FunPtr (Ptr C'GtsVertex -> Ptr C'GtsEdge -> IO C'gboolean)

For each vertex v in vertices look if there are any vertex of vertices contained in a box centered on v of size 2*epsilon. If there are and if check is not NULL and returns TRUE, replace them with v (using gts_vertex_replace()), destroy them and remove them from list. This is done efficiently using Kd-Trees.

c'gts_vertices_merge :: Ptr C'GSList -> C'gdouble -> C'GtsVertexMergeFunc -> IO (Ptr C'GSList)

p'gts_vertices_merge :: FunPtr (Ptr C'GSList -> C'gdouble -> C'GtsVertexMergeFunc -> IO (Ptr C'GSList))

data C'GtsVertexNormal

Constructors

C'GtsVertexNormal

Fields

c'GtsVertexNormal'n :: C'GtsVector

Instances

Eq C'GtsVertexNormal

Show C'GtsVertexNormal

Storable C'GtsVertexNormal

c'gts_vertex_normal_class :: IO (Ptr C'GtsVertexClass)

p'gts_vertex_normal_class :: FunPtr (IO (Ptr C'GtsVertexClass))

data C'GtsColorVertex

Constructors

C'GtsColorVertex

Fields

c'GtsColorVertex'c :: C'GtsColor

Instances

Eq C'GtsColorVertex

Show C'GtsColorVertex

Storable C'GtsColorVertex

c'gts_color_vertex_class :: IO (Ptr C'GtsVertexClass)

p'gts_color_vertex_class :: FunPtr (IO (Ptr C'GtsVertexClass))

data C'GtsSurface

Constructors

C'GtsSurface

Fields

c'GtsSurface'keep_faces :: C'gboolean

Instances

Eq C'GtsSurface

Show C'GtsSurface

Storable C'GtsSurface

data C'GtsSurfaceClass

Constructors

C'GtsSurfaceClass

Instances

Eq C'GtsSurfaceClass

Show C'GtsSurfaceClass

Storable C'GtsSurfaceClass

data C'GtsEdgeClass

Constructors

C'GtsEdgeClass

Instances

Eq C'GtsEdgeClass

Show C'GtsEdgeClass

Storable C'GtsEdgeClass

data C'GtsEdge

Constructors

C'GtsEdge

Fields

c'GtsEdge'triangles :: Ptr C'GSList

c'GtsEdge'segment :: Ptr C'GtsSegment

Instances

Eq C'GtsEdge

Show C'GtsEdge

Storable C'GtsEdge

data C'GtsFaceClass

Constructors

C'GtsFaceClass

Instances

Eq C'GtsFaceClass

Show C'GtsFaceClass

Storable C'GtsFaceClass

data C'GtsFace

Constructors

C'GtsFace

Instances

Eq C'GtsFace

Show C'GtsFace

Storable C'GtsFace

data C'GtsSurfaceStats

Constructors

C'GtsSurfaceStats

Instances

Eq C'GtsSurfaceStats

Show C'GtsSurfaceStats

Storable C'GtsSurfaceStats

data C'GtsSurfaceQualityStats

Constructors

C'GtsSurfaceQualityStats

Instances

Eq C'GtsSurfaceQualityStats

Show C'GtsSurfaceQualityStats

Storable C'GtsSurfaceQualityStats

c'gts_face_class :: IO (Ptr C'GtsFaceClass)

c'gts_edge_class :: IO (Ptr C'GtsEdgeClass)

c'gts_surface_class :: IO (Ptr C'GtsSurfaceClass)

p'gts_face_class :: FunPtr (IO (Ptr C'GtsFaceClass))

p'gts_edge_class :: FunPtr (IO (Ptr C'GtsEdgeClass))

p'gts_surface_class :: FunPtr (IO (Ptr C'GtsSurfaceClass))

Create a new empty surface which uses the specified types of sub-object

c'gts_surface_new :: Ptr C'GtsSurfaceClass -> Ptr C'GtsFaceClass -> Ptr C'GtsEdgeClass -> Ptr C'GtsVertexClass -> IO (Ptr C'GtsSurface)

p'gts_surface_new :: FunPtr (Ptr C'GtsSurfaceClass -> Ptr C'GtsFaceClass -> Ptr C'GtsEdgeClass -> Ptr C'GtsVertexClass -> IO (Ptr C'GtsSurface))

Add a face to a surface

c'gts_surface_add_face :: Ptr C'GtsSurface -> Ptr C'GtsFace -> IO ()

p'gts_surface_add_face :: FunPtr (Ptr C'GtsSurface -> Ptr C'GtsFace -> IO ())

Read a surface from a GTS formatted file

c'gts_surface_read :: Ptr C'GtsSurface -> Ptr C'GtsFile -> IO C'guint

p'gts_surface_read :: FunPtr (Ptr C'GtsSurface -> Ptr C'GtsFile -> IO C'guint)

Remove a face from a surface

c'gts_surface_remove_face :: Ptr C'GtsSurface -> Ptr C'GtsFace -> IO ()

p'gts_surface_remove_face :: FunPtr (Ptr C'GtsSurface -> Ptr C'GtsFace -> IO ())

Get the surface area of all triangles in the surface

c'gts_surface_area :: Ptr C'GtsSurface -> IO C'gdouble

p'gts_surface_area :: FunPtr (Ptr C'GtsSurface -> IO C'gdouble)

Get some statistics on the surface

c'gts_surface_stats :: Ptr C'GtsSurface -> Ptr C'GtsSurfaceStats -> IO ()

p'gts_surface_stats :: FunPtr (Ptr C'GtsSurface -> Ptr C'GtsSurfaceStats -> IO ())

Get some statistics on the quality of the triangles making up the surface

c'gts_surface_quality_stats :: Ptr C'GtsSurface -> Ptr C'GtsSurfaceQualityStats -> IO ()

p'gts_surface_quality_stats :: FunPtr (Ptr C'GtsSurface -> Ptr C'GtsSurfaceQualityStats -> IO ())

Invoke a function for each vertex in the surface

c'gts_surface_foreach_vertex :: Ptr C'GtsSurface -> C'GtsFunc -> C'gpointer -> IO ()

p'gts_surface_foreach_vertex :: FunPtr (Ptr C'GtsSurface -> C'GtsFunc -> C'gpointer -> IO ())

Invoke a function for each edge in the surface

c'gts_surface_foreach_edge :: Ptr C'GtsSurface -> C'GtsFunc -> C'gpointer -> IO ()

p'gts_surface_foreach_edge :: FunPtr (Ptr C'GtsSurface -> C'GtsFunc -> C'gpointer -> IO ())

Invoke a function for each face in the surface

c'gts_surface_foreach_face :: Ptr C'GtsSurface -> C'GtsFunc -> C'gpointer -> IO ()

p'gts_surface_foreach_face :: FunPtr (Ptr C'GtsSurface -> C'GtsFunc -> C'gpointer -> IO ())

Invoke a function for each face in the surface and remove the face afterwards

c'gts_surface_foreach_face_remove :: Ptr C'GtsSurface -> C'GtsFunc -> C'gpointer -> IO C'guint

p'gts_surface_foreach_face_remove :: FunPtr (Ptr C'GtsSurface -> C'GtsFunc -> C'gpointer -> IO C'guint)

Generate a surface which is a tessalated model of a sphere

c'gts_surface_generate_sphere :: Ptr C'GtsSurface -> C'guint -> IO (Ptr C'GtsSurface)

p'gts_surface_generate_sphere :: FunPtr (Ptr C'GtsSurface -> C'guint -> IO (Ptr C'GtsSurface))

Add a copy of all the faces, edges and vertices of s2 to s1.

c'gts_surface_copy :: Ptr C'GtsSurface -> Ptr C'GtsSurface -> IO (Ptr C'GtsSurface)

p'gts_surface_copy :: FunPtr (Ptr C'GtsSurface -> Ptr C'GtsSurface -> IO (Ptr C'GtsSurface))

Adds all the faces of with which do not already belong to s to s.

c'gts_surface_merge :: Ptr C'GtsSurface -> Ptr C'GtsSurface -> IO ()

p'gts_surface_merge :: FunPtr (Ptr C'GtsSurface -> Ptr C'GtsSurface -> IO ())

True iff the surface describes a manifold

c'gts_surface_is_manifold :: Ptr C'GtsSurface -> IO C'gboolean

p'gts_surface_is_manifold :: FunPtr (Ptr C'GtsSurface -> IO C'gboolean)

True iff the surface is closed

c'gts_surface_is_closed :: Ptr C'GtsSurface -> IO C'gboolean

p'gts_surface_is_closed :: FunPtr (Ptr C'GtsSurface -> IO C'gboolean)

True iff all the faces of the surface have a compatible orientation

c'gts_surface_is_orientable :: Ptr C'GtsSurface -> IO C'gboolean

p'gts_surface_is_orientable :: FunPtr (Ptr C'GtsSurface -> IO C'gboolean)

Return the volume of the domain bounded by the surface, only valid if the surface is closed and orientable

c'gts_surface_volume :: Ptr C'GtsSurface -> IO C'gdouble

p'gts_surface_volume :: FunPtr (Ptr C'GtsSurface -> IO C'gdouble)

Return the center of mass of the domain bounded by the surface s, only valid if the surface is closed and orientable

c'gts_surface_center_of_mass :: Ptr C'GtsSurface -> Ptr C'GtsVector -> IO C'gdouble

p'gts_surface_center_of_mass :: FunPtr (Ptr C'GtsSurface -> Ptr C'GtsVector -> IO C'gdouble)

Return the center of area of the surface (all faces should be co-planar)

c'gts_surface_center_of_area :: Ptr C'GtsSurface -> Ptr C'GtsVector -> IO C'gdouble

c'gts_surface_vertex_number :: Ptr C'GtsSurface -> IO C'guint

p'gts_surface_center_of_area :: FunPtr (Ptr C'GtsSurface -> Ptr C'GtsVector -> IO C'gdouble)

c'gts_surface_edge_number :: Ptr C'GtsSurface -> IO C'guint

c'gts_surface_face_number :: Ptr C'GtsSurface -> IO C'guint

p'gts_surface_vertex_number :: FunPtr (Ptr C'GtsSurface -> IO C'guint)

p'gts_surface_edge_number :: FunPtr (Ptr C'GtsSurface -> IO C'guint)

c'gts_surface_boundary :: Ptr C'GtsSurface -> IO (Ptr C'GSList)

p'gts_surface_face_number :: FunPtr (Ptr C'GtsSurface -> IO C'guint)

c'gts_surface_split :: Ptr C'GtsSurface -> IO (Ptr C'GSList)

c'gts_surface_write :: Ptr C'GtsSurface -> Ptr CFile -> IO ()

p'gts_surface_boundary :: FunPtr (Ptr C'GtsSurface -> IO (Ptr C'GSList))

p'gts_surface_split :: FunPtr (Ptr C'GtsSurface -> IO (Ptr C'GSList))

p'gts_surface_write :: FunPtr (Ptr C'GtsSurface -> Ptr CFile -> IO ())

data C'GtsSurfaceInterClass

Constructors

C'GtsSurfaceInterClass

Instances

Eq C'GtsSurfaceInterClass

Show C'GtsSurfaceInterClass

Storable C'GtsSurfaceInterClass

data C'GtsSurfaceInter

Constructors

C'GtsSurfaceInter

Fields

c'GtsSurfaceInter's1 :: Ptr C'GtsSurface

c'GtsSurfaceInter's2 :: Ptr C'GtsSurface

c'GtsSurfaceInter'edges :: Ptr C'GSList

Instances

Eq C'GtsSurfaceInter

Show C'GtsSurfaceInter

Storable C'GtsSurfaceInter

data C'GNode

Constructors

C'GNode

Instances

Eq C'GNode

Show C'GNode

Storable C'GNode

Create a new GTS Face from the 3 edges

c'gts_face_new :: Ptr C'GtsFaceClass -> Ptr C'GtsEdge -> Ptr C'GtsEdge -> Ptr C'GtsEdge -> IO (Ptr C'GtsFace)

p'gts_face_new :: FunPtr (Ptr C'GtsFaceClass -> Ptr C'GtsEdge -> Ptr C'GtsEdge -> Ptr C'GtsEdge -> IO (Ptr C'GtsFace))

Get the class for a surface intersection

c'gts_surface_inter_class :: IO (Ptr C'GtsSurfaceInterClass)

p'gts_surface_inter_class :: FunPtr (IO (Ptr C'GtsSurfaceInterClass))

Create a new surface intersection from the two surfaces and the precomputed face bounding box trees

c'gts_surface_inter_new :: Ptr C'GtsSurfaceInterClass -> Ptr C'GtsSurface -> Ptr C'GtsSurface -> Ptr C'GNode -> Ptr C'GNode -> C'gboolean -> C'gboolean -> IO (Ptr C'GtsSurfaceInter)

p'gts_surface_inter_new :: FunPtr (Ptr C'GtsSurfaceInterClass -> Ptr C'GtsSurface -> Ptr C'GtsSurface -> Ptr C'GNode -> Ptr C'GNode -> C'gboolean -> C'gboolean -> IO (Ptr C'GtsSurfaceInter))

True iff the edges in the intersection form a closed curve

c'gts_surface_inter_check :: Ptr C'GtsSurfaceInter -> Ptr C'gboolean -> IO C'gboolean

p'gts_surface_inter_check :: FunPtr (Ptr C'GtsSurfaceInter -> Ptr C'gboolean -> IO C'gboolean)

Adds to surface the part of the surface described by si and op.

c'gts_surface_inter_boolean :: Ptr C'GtsSurfaceInter -> Ptr C'GtsSurface -> C'guint -> IO ()

p'gts_surface_inter_boolean :: FunPtr (Ptr C'GtsSurfaceInter -> Ptr C'GtsSurface -> C'guint -> IO ())

A new GtsSurface containing the faces of s which are self-intersecting or NULL if no faces of s are self-intersecting.

c'gts_surface_is_self_intersecting :: Ptr C'GtsSurface -> IO (Ptr C'GtsSurface)

p'gts_surface_is_self_intersecting :: FunPtr (Ptr C'GtsSurface -> IO (Ptr C'GtsSurface))

A list of GtsEdge defining the curve intersection of the two surfaces.

c'gts_surface_intersection :: Ptr C'GtsSurface -> Ptr C'GtsSurface -> Ptr C'GNode -> Ptr C'GNode -> IO (Ptr C'GSList)

c'gts_bb_tree_new :: Ptr C'GSList -> IO (Ptr C'GNode)

p'gts_surface_intersection :: FunPtr (Ptr C'GtsSurface -> Ptr C'GtsSurface -> Ptr C'GNode -> Ptr C'GNode -> IO (Ptr C'GSList))

c'gts_bb_tree_surface :: Ptr C'GtsSurface -> IO (Ptr C'GNode)

p'gts_bb_tree_new :: FunPtr (Ptr C'GSList -> IO (Ptr C'GNode))

c'gts_bb_tree_destroy :: Ptr C'GNode -> C'gboolean -> IO ()

p'gts_bb_tree_surface :: FunPtr (Ptr C'GtsSurface -> IO (Ptr C'GNode))

p'gts_bb_tree_destroy :: FunPtr (Ptr C'GNode -> C'gboolean -> IO ())

TRUE if the ray starting at p and ending at (+infty, p-> y, p-> z) intersects with bb, FALSE otherwise.

c'gts_bb_tree_stabbed :: Ptr C'GNode -> Ptr C'GtsPoint -> IO (Ptr C'GSList)

p'gts_bb_tree_stabbed :: FunPtr (Ptr C'GNode -> Ptr C'GtsPoint -> IO (Ptr C'GSList))

Destroy a GTS object and free the associated memory. This is the generic version, see the typed helper functions

c'gts_object_destroy :: Ptr C'GtsObject -> IO ()

p'gts_object_destroy :: FunPtr (Ptr C'GtsObject -> IO ())

type C'GtsEncroachFunc = FunPtr (Ptr C'GtsVertex -> Ptr C'GtsEdge -> Ptr C'GtsSurface -> C'gpointer -> IO C'gboolean)

type C'GtsKeyFunc = FunPtr (C'gpointer -> C'gpointer -> IO C'gdouble)

mk'GtsEncroachFunc :: (Ptr C'GtsVertex -> Ptr C'GtsEdge -> Ptr C'GtsSurface -> C'gpointer -> IO C'gboolean) -> IO C'GtsEncroachFunc

mk'GtsKeyFunc :: (C'gpointer -> C'gpointer -> IO C'gdouble) -> IO C'GtsKeyFunc

c'gts_constraint_class :: IO (Ptr C'GtsEdgeClass)

mK'GtsEncroachFunc :: C'GtsEncroachFunc -> Ptr C'GtsVertex -> Ptr C'GtsEdge -> Ptr C'GtsSurface -> C'gpointer -> IO C'gboolean

mK'GtsKeyFunc :: C'GtsKeyFunc -> C'gpointer -> C'gpointer -> IO C'gdouble

c'gts_point_locate :: Ptr C'GtsPoint -> Ptr C'GtsSurface -> Ptr C'GtsFace -> IO (Ptr C'GtsFace)

p'gts_constraint_class :: FunPtr (IO (Ptr C'GtsEdgeClass))

p'gts_point_locate :: FunPtr (Ptr C'GtsPoint -> Ptr C'GtsSurface -> Ptr C'GtsFace -> IO (Ptr C'GtsFace))

Create a new edge from a pair of vertices

c'gts_edge_new :: Ptr C'GtsEdgeClass -> Ptr C'GtsVertex -> Ptr C'GtsVertex -> IO (Ptr C'GtsEdge)

p'gts_edge_new :: FunPtr (Ptr C'GtsEdgeClass -> Ptr C'GtsVertex -> Ptr C'GtsVertex -> IO (Ptr C'GtsEdge))

Replaces e with with. For each triangle which uses e as an edge, e is replaced with with. The with-> triangles list is updated appropriately and the e-> triangles list is freed and set to NULL

c'gts_edge_replace :: Ptr C'GtsEdge -> Ptr C'GtsEdge -> IO ()

p'gts_edge_replace :: FunPtr (Ptr C'GtsEdge -> Ptr C'GtsEdge -> IO ())

Performs an edge swap on the two triangles sharing e and belonging to s.

c'gts_edge_swap :: Ptr C'GtsEdge -> Ptr C'GtsSurface -> IO ()

p'gts_edge_swap :: FunPtr (Ptr C'GtsEdge -> Ptr C'GtsSurface -> IO ())

c'gts_segment_triangle_intersection :: Ptr C'GtsSegment -> Ptr C'GtsTriangle -> C'gboolean -> IO (Ptr C'GtsPoint)

p'gts_segment_triangle_intersection :: FunPtr (Ptr C'GtsSegment -> Ptr C'GtsTriangle -> C'gboolean -> IO (Ptr C'GtsPoint))

Tests if the planar projection (x, y) of p is inside or outside the circumcircle of the planar projection of t. This function is geometrically robust.

c'gts_point_in_triangle_circle :: Ptr C'GtsPoint -> Ptr C'GtsTriangle -> IO C'gdouble

p'gts_point_in_triangle_circle :: FunPtr (Ptr C'GtsPoint -> Ptr C'GtsTriangle -> IO C'gdouble)

Checks for orientation of the projection of three points on the (x,y) plane. The result is also an approximation of twice the signed area of the triangle defined by the three points. This function uses adaptive floating point arithmetic and is consequently geometrically robust.

c'gts_point_orientation :: Ptr C'GtsPoint -> Ptr C'GtsPoint -> Ptr C'GtsPoint -> IO C'gdouble

p'gts_point_orientation :: FunPtr (Ptr C'GtsPoint -> Ptr C'GtsPoint -> Ptr C'GtsPoint -> IO C'gdouble)

TRUE if p is inside the surface defined by tree, FALSE otherwise.

c'gts_point_is_inside_surface :: Ptr C'GtsPoint -> Ptr C'GNode -> C'gboolean -> IO C'gboolean

p'gts_point_is_inside_surface :: FunPtr (Ptr C'GtsPoint -> Ptr C'GNode -> C'gboolean -> IO C'gboolean)

Tests if the planar projection (x, y) of p is inside or outside the circle defined by the planar projection of p1, p2 and p3.

c'gts_point_in_circle :: Ptr C'GtsPoint -> Ptr C'GtsPoint -> Ptr C'GtsPoint -> Ptr C'GtsPoint -> IO C'gdouble

p'gts_point_in_circle :: FunPtr (Ptr C'GtsPoint -> Ptr C'GtsPoint -> Ptr C'GtsPoint -> Ptr C'GtsPoint -> IO C'gdouble)

Checks if p4 lies above, below or on the plane passing through the points p1, p2 and p3. Below is defined so that p1, p2 and p3 appear in counterclockwise order when viewed from above the plane. The returned value is an approximation of six times the signed volume of the tetrahedron defined by the four points. This function uses adaptive floating point arithmetic and is consequently geometrically robust.

c'gts_point_orientation_3d :: Ptr C'GtsPoint -> Ptr C'GtsPoint -> Ptr C'GtsPoint -> Ptr C'GtsPoint -> Ptr C'GtsPoint -> IO C'gdouble

p'gts_point_orientation_3d :: FunPtr (Ptr C'GtsPoint -> Ptr C'GtsPoint -> Ptr C'GtsPoint -> Ptr C'GtsPoint -> Ptr C'GtsPoint -> IO C'gdouble)

data C'GtsBBoxClass

Constructors

C'GtsBBoxClass

Instances

Eq C'GtsBBoxClass

Show C'GtsBBoxClass

Storable C'GtsBBoxClass

c'gts_bbox_class :: IO (Ptr C'GtsBBoxClass)

p'gts_bbox_class :: FunPtr (IO (Ptr C'GtsBBoxClass))

data C'GtsBBox

Constructors

C'GtsBBox

Fields

c'GtsBBox'x1 :: C'gdouble

c'GtsBBox'y1 :: C'gdouble

c'GtsBBox'z1 :: C'gdouble

c'GtsBBox'x2 :: C'gdouble

c'GtsBBox'y2 :: C'gdouble

c'GtsBBox'z2 :: C'gdouble

c'GtsBBox'bounded :: C'gpointer

Instances

Eq C'GtsBBox

Show C'GtsBBox

Storable C'GtsBBox

A list of triangle strips containing all the triangles of s. A triangle strip is itself a list of successive triangles having one edge in common.

c'gts_surface_strip :: Ptr C'GtsSurface -> IO (Ptr C'GSList)

p'gts_surface_strip :: FunPtr (Ptr C'GtsSurface -> IO (Ptr C'GSList))

Using the gts_bb_tree_surface_distance() and gts_bb_tree_surface_boundary_distance() functions fills face_range and boundary_range with the min, max and average Euclidean (minimum) distances between the faces of s1 and the faces of s2 and between the boundary edges of s1 and s2.

c'gts_surface_distance :: Ptr C'GtsSurface -> Ptr C'GtsSurface -> C'gdouble -> Ptr C'GtsRange -> Ptr C'GtsRange -> IO ()

p'gts_surface_distance :: FunPtr (Ptr C'GtsSurface -> Ptr C'GtsSurface -> C'gdouble -> Ptr C'GtsRange -> Ptr C'GtsRange -> IO ())

A new GtsBBox bounding box of surface.

c'gts_bbox_surface :: Ptr C'GtsBBoxClass -> Ptr C'GtsSurface -> IO (Ptr C'GtsBBox)

p'gts_bbox_surface :: FunPtr (Ptr C'GtsBBoxClass -> Ptr C'GtsSurface -> IO (Ptr C'GtsBBox))

TRUE if the bounding boxes bb1 and bb2 are overlapping (including just touching), FALSE otherwise.

c'gts_bboxes_are_overlapping :: Ptr C'GtsBBox -> Ptr C'GtsBBox -> IO C'gboolean

p'gts_bboxes_are_overlapping :: FunPtr (Ptr C'GtsBBox -> Ptr C'GtsBBox -> IO C'gboolean)

Add a constraint edge to a Delaunay surface

c'gts_delaunay_add_constraint :: Ptr C'GtsSurface -> Ptr C'GtsEdge -> IO (Ptr C'GSList)

p'gts_delaunay_add_constraint :: FunPtr (Ptr C'GtsSurface -> Ptr C'GtsEdge -> IO (Ptr C'GSList))

NULL if the planar projection of surface is a Delaunay triangulation (unconstrained), a GtsFace violating the Delaunay property otherwise.

c'gts_delaunay_check :: Ptr C'GtsSurface -> IO (Ptr C'GtsFace)

p'gts_delaunay_check :: FunPtr (Ptr C'GtsSurface -> IO (Ptr C'GtsFace))

Removes all the edges of the boundary of surface which are not constraints.

c'gts_delaunay_remove_hull :: Ptr C'GtsSurface -> IO ()

p'gts_delaunay_remove_hull :: FunPtr (Ptr C'GtsSurface -> IO ())

Recursively split constraints of surface which are encroached by vertices of surface (see Shewchuk 96 for details). The split constraints are destroyed and replaced by a set of new constraints of the same class. If gts_vertex_encroaches_edge() is used for encroaches, the resulting surface will be Delaunay conforming. If steiner_max is positive or nul, the recursive splitting procedure will stop when this maximum number of Steiner points is reached. In that case the resulting surface will not necessarily be Delaunay conforming.

c'gts_delaunay_conform :: Ptr C'GtsSurface -> C'gint -> C'GtsEncroachFunc -> C'gpointer -> IO C'guint

p'gts_delaunay_conform :: FunPtr (Ptr C'GtsSurface -> C'gint -> C'GtsEncroachFunc -> C'gpointer -> IO C'guint)

An implementation of the refinement algorithm described in Ruppert (1995) and Shewchuk (1996).

c'gts_delaunay_refine :: Ptr C'GtsSurface -> C'gint -> C'GtsEncroachFunc -> C'gpointer -> C'GtsKeyFunc -> C'gpointer -> IO C'guint

p'gts_delaunay_refine :: FunPtr (Ptr C'GtsSurface -> C'gint -> C'GtsEncroachFunc -> C'gpointer -> C'GtsKeyFunc -> C'gpointer -> IO C'guint)

Add one vertex to a Delaunay triangulation preserving the Delaunay property

c'gts_delaunay_add_vertex :: Ptr C'GtsSurface -> Ptr C'GtsVertex -> Ptr C'GtsFace -> IO (Ptr C'GtsVertex)

p'gts_delaunay_add_vertex :: FunPtr (Ptr C'GtsSurface -> Ptr C'GtsVertex -> Ptr C'GtsFace -> IO (Ptr C'GtsVertex))

Add one vertex to a face of a Delaunay triangulation preserving the Delaunay property

c'gts_delaunay_add_vertex_to_face :: Ptr C'GtsSurface -> Ptr C'GtsVertex -> Ptr C'GtsFace -> IO (Ptr C'GtsVertex)

p'gts_delaunay_add_vertex_to_face :: FunPtr (Ptr C'GtsSurface -> Ptr C'GtsVertex -> Ptr C'GtsFace -> IO (Ptr C'GtsVertex))

Removes v from the Delaunay triangulation defined by surface and restores the Delaunay property. Vertex v must not be used by any constrained edge otherwise the triangulation is not guaranteed to be Delaunay.

c'gts_delaunay_remove_vertex :: Ptr C'GtsSurface -> Ptr C'GtsVertex -> IO ()

p'gts_delaunay_remove_vertex :: FunPtr (Ptr C'GtsSurface -> Ptr C'GtsVertex -> IO ())

c'gts_surface_destroy :: Ptr C'GtsSurface -> IO ()

c'gts_triangle_destroy :: Ptr C'GtsTriangle -> IO ()

c'gts_vertex_destroy :: Ptr C'GtsVertex -> IO ()

p'gts_surface_destroy :: FunPtr (Ptr C'GtsSurface -> IO ())

p'gts_triangle_destroy :: FunPtr (Ptr C'GtsTriangle -> IO ())

data C'GtsSurfaceTraverse

Constructors

C'GtsSurfaceTraverse

p'gts_vertex_destroy :: FunPtr (Ptr C'GtsVertex -> IO ())

c'gts_surface_traverse_new :: Ptr C'GtsSurface -> Ptr C'GtsFace -> IO (Ptr C'GtsSurfaceTraverse)

c'gts_surface_traverse_next :: Ptr C'GtsSurfaceTraverse -> Ptr C'guint -> IO (Ptr C'GtsFace)

c'gts_surface_traverse_destroy :: Ptr C'GtsSurfaceTraverse -> IO ()

p'gts_surface_traverse_new :: FunPtr (Ptr C'GtsSurface -> Ptr C'GtsFace -> IO (Ptr C'GtsSurfaceTraverse))

p'gts_surface_traverse_next :: FunPtr (Ptr C'GtsSurfaceTraverse -> Ptr C'guint -> IO (Ptr C'GtsFace))

type C'GtsRefineFunc = FunPtr (Ptr C'GtsEdge -> Ptr C'GtsVertexClass -> C'gpointer -> IO (Ptr C'GtsVertex))

p'gts_surface_traverse_destroy :: FunPtr (Ptr C'GtsSurfaceTraverse -> IO ())

type C'GtsStopFunc = FunPtr (C'gdouble -> C'guint -> C'gpointer -> IO C'gboolean)

mk'GtsRefineFunc :: (Ptr C'GtsEdge -> Ptr C'GtsVertexClass -> C'gpointer -> IO (Ptr C'GtsVertex)) -> IO C'GtsRefineFunc

mk'GtsStopFunc :: (C'gdouble -> C'guint -> C'gpointer -> IO C'gboolean) -> IO C'GtsStopFunc

c'gts_surface_tessellate :: Ptr C'GtsSurface -> C'GtsRefineFunc -> C'gpointer -> IO ()

mK'GtsRefineFunc :: C'GtsRefineFunc -> Ptr C'GtsEdge -> Ptr C'GtsVertexClass -> C'gpointer -> IO (Ptr C'GtsVertex)

mK'GtsStopFunc :: C'GtsStopFunc -> C'gdouble -> C'guint -> C'gpointer -> IO C'gboolean

c'gts_surface_refine :: Ptr C'GtsSurface -> C'GtsKeyFunc -> C'gpointer -> C'GtsRefineFunc -> C'gpointer -> C'GtsStopFunc -> C'gpointer -> IO ()

p'gts_surface_tessellate :: FunPtr (Ptr C'GtsSurface -> C'GtsRefineFunc -> C'gpointer -> IO ())

c'gts_edge_face_number :: Ptr C'GtsEdge -> Ptr C'GtsSurface -> IO C'guint

p'gts_surface_refine :: FunPtr (Ptr C'GtsSurface -> C'GtsKeyFunc -> C'gpointer -> C'GtsRefineFunc -> C'gpointer -> C'GtsStopFunc -> C'gpointer -> IO ())

c'gts_edge_manifold_faces :: Ptr C'GtsEdge -> Ptr C'GtsSurface -> Ptr (Ptr C'GtsFace) -> Ptr (Ptr C'GtsFace) -> C'gboolean

c'gts_edge_belongs_to_tetrahedron :: Ptr C'GtsEdge -> C'gboolean

p'gts_edge_face_number :: FunPtr (Ptr C'GtsEdge -> Ptr C'GtsSurface -> IO C'guint)

p'gts_edge_manifold_faces :: FunPtr (Ptr C'GtsEdge -> Ptr C'GtsSurface -> Ptr (Ptr C'GtsFace) -> Ptr (Ptr C'GtsFace) -> C'gboolean)

p'gts_edge_belongs_to_tetrahedron :: FunPtr (Ptr C'GtsEdge -> C'gboolean)

c'gts_edges_from_vertices :: Ptr C'GSList -> Ptr C'GtsSurface -> IO (Ptr C'GSList)

c'gts_edges_merge :: Ptr C'GList -> IO (Ptr C'GList)

p'gts_edges_from_vertices :: FunPtr (Ptr C'GSList -> Ptr C'GtsSurface -> IO (Ptr C'GSList))

c'gts_edge_is_contact :: Ptr C'GtsEdge -> IO C'guint

p'gts_edges_merge :: FunPtr (Ptr C'GList -> IO (Ptr C'GList))

c'gts_edge_is_boundary :: Ptr C'GtsEdge -> Ptr C'GtsSurface -> IO (Ptr C'GtsFace)

c'gts_edge_has_any_parent_surface :: Ptr C'GtsEdge -> IO (Ptr C'GtsFace)

p'gts_edge_is_contact :: FunPtr (Ptr C'GtsEdge -> IO C'guint)

c'gts_edge_has_parent_surface :: Ptr C'GtsEdge -> Ptr C'GtsSurface -> IO (Ptr C'GtsFace)

p'gts_edge_is_boundary :: FunPtr (Ptr C'GtsEdge -> Ptr C'GtsSurface -> IO (Ptr C'GtsFace))

c'gts_edge_is_duplicate :: Ptr C'GtsEdge -> IO (Ptr C'GtsEdge)

p'gts_edge_has_any_parent_surface :: FunPtr (Ptr C'GtsEdge -> IO (Ptr C'GtsFace))

p'gts_edge_has_parent_surface :: FunPtr (Ptr C'GtsEdge -> Ptr C'GtsSurface -> IO (Ptr C'GtsFace))

c'gts_edge_is_unattached :: Ptr C'GtsEdge -> IO C'gboolean

p'gts_edge_is_duplicate :: FunPtr (Ptr C'GtsEdge -> IO (Ptr C'GtsEdge))

c'gts_face_has_parent_surface :: Ptr C'GtsFace -> Ptr C'GtsSurface -> IO C'gboolean

c'gts_triangle_revert_func :: C'gpointer -> C'gpointer -> IO C'gint

p'gts_face_has_parent_surface :: FunPtr (Ptr C'GtsFace -> Ptr C'GtsSurface -> IO C'gboolean)

p'gts_triangle_revert_func :: FunPtr (C'gpointer -> C'gpointer -> IO C'gint)

c'gts_finalize :: IO ()

Shutdown GTS and free all memory NOTE: after calling this method no other GTS functions may be called

c'gts_object_reset_reserved :: Ptr C'GtsObject -> IO ()

p'gts_finalize :: FunPtr (IO ())

c'gts_object_attributes :: Ptr C'GtsObject -> Ptr C'GtsObject -> IO ()

p'gts_object_reset_reserved :: FunPtr (Ptr C'GtsObject -> IO ())

c'gts_object_clone :: Ptr C'GtsObject -> IO (Ptr C'GtsObject)

p'gts_object_attributes :: FunPtr (Ptr C'GtsObject -> Ptr C'GtsObject -> IO ())

p'gts_object_clone :: FunPtr (Ptr C'GtsObject -> IO (Ptr C'GtsObject))