mirror of
https://github.com/NGSolve/netgen.git
synced 2024-12-27 14:20:34 +05:00
b694b4667a
move fieldlines code to meshing dir move visualization function pointers to meshing directory DLL_HEADER -> NGGUI_API in visualization lib move soldata.hpp to meshing update occ, no freetype necessary anymore
698 lines
24 KiB
C++
698 lines
24 KiB
C++
#ifndef NGLIB
|
|
#define NGLIB
|
|
|
|
/**************************************************************************/
|
|
/* File: nglib.h */
|
|
/* Author: Joachim Schoeberl */
|
|
/* Date: 7. May. 2000 */
|
|
/**************************************************************************/
|
|
|
|
#include <stddef.h>
|
|
|
|
/*!
|
|
\file nglib.h
|
|
\brief Library interface to the netgen meshing kernel
|
|
\author Joachim Schoeberl
|
|
\date 7. May 2000
|
|
|
|
This header file provides access to the core functionality of the Netgen
|
|
Mesher via a library interface, without an interactive User Interface.
|
|
|
|
The intention of providing these set of functions is to allow system
|
|
developers to integrate Netgen into top-level code, to act as the low
|
|
level mesh generation / optimisation kernel.
|
|
*/
|
|
|
|
// Philippose - 14.02.2009
|
|
// Modifications for creating a DLL in Windows
|
|
#ifdef WIN32
|
|
#ifdef nglib_EXPORTS
|
|
#define NGLIB_API __declspec(dllexport)
|
|
#else
|
|
#define NGLIB_API __declspec(dllimport)
|
|
#endif
|
|
#else
|
|
#define NGLIB_API __attribute__((visibility("default")))
|
|
#endif
|
|
|
|
|
|
// ** Constants used within Netgen *********************
|
|
/// Maximum allowed number of nodes per volume element
|
|
#define NG_VOLUME_ELEMENT_MAXPOINTS 10
|
|
|
|
/// Maximum allowed number of nodes per surface element
|
|
#define NG_SURFACE_ELEMENT_MAXPOINTS 8
|
|
|
|
|
|
|
|
// *** Data-types for accessing Netgen functionality ***
|
|
/// Data type for NETGEN mesh
|
|
typedef void * Ng_Mesh;
|
|
|
|
/// Data type for NETGEN CSG geometry
|
|
typedef void * Ng_CSG_Geometry;
|
|
|
|
/// Data type for NETGEN 2D geometry
|
|
typedef void * Ng_Geometry_2D;
|
|
|
|
/// Data type for NETGEN STL geometry
|
|
typedef void * Ng_STL_Geometry;
|
|
|
|
|
|
|
|
// *** Special Enum types used within Netgen ***********
|
|
/// Currently implemented surface element types
|
|
enum Ng_Surface_Element_Type
|
|
{ NG_TRIG = 1, NG_QUAD = 2, NG_TRIG6 = 3, NG_QUAD6 = 4, NG_QUAD8 = 5 };
|
|
|
|
/// Currently implemented volume element types
|
|
enum Ng_Volume_Element_Type
|
|
{ NG_TET = 1, NG_PYRAMID = 2, NG_PRISM = 3, NG_TET10 = 4 };
|
|
|
|
/// Values returned by Netgen functions
|
|
enum Ng_Result
|
|
{
|
|
NG_ERROR = -1,
|
|
NG_OK = 0,
|
|
NG_SURFACE_INPUT_ERROR = 1,
|
|
NG_VOLUME_FAILURE = 2,
|
|
NG_STL_INPUT_ERROR = 3,
|
|
NG_SURFACE_FAILURE = 4,
|
|
NG_FILE_NOT_FOUND = 5
|
|
};
|
|
|
|
|
|
|
|
// *** Classes required for use within Netgen **********
|
|
/// Netgen Meshing Parameters class
|
|
class Ng_Meshing_Parameters
|
|
{
|
|
public:
|
|
int uselocalh; //!< Switch to enable / disable usage of local mesh size modifiers
|
|
|
|
double maxh; //!< Maximum global mesh size allowed
|
|
double minh; //!< Minimum global mesh size allowed
|
|
|
|
double fineness; //!< Mesh density: 0...1 (0 => coarse; 1 => fine)
|
|
double grading; //!< Mesh grading: 0...1 (0 => uniform mesh; 1 => aggressive local grading)
|
|
|
|
double elementsperedge; //!< Number of elements to generate per edge of the geometry
|
|
double elementspercurve; //!< Elements to generate per curvature radius
|
|
|
|
int closeedgeenable; //!< Enable / Disable mesh refinement at close edges
|
|
double closeedgefact; //!< Factor to use for refinement at close edges (larger => finer)
|
|
|
|
int minedgelenenable; //!< Enable / Disable user defined minimum edge length for edge subdivision
|
|
double minedgelen; //!< Minimum edge length to use while subdividing the edges (default = 1e-4)
|
|
|
|
int second_order; //!< Generate second-order surface and volume elements
|
|
int quad_dominated; //!< Creates a Quad-dominated mesh
|
|
|
|
char * meshsize_filename; //!< Optional external mesh size file
|
|
|
|
int optsurfmeshenable; //!< Enable / Disable automatic surface mesh optimization
|
|
int optvolmeshenable; //!< Enable / Disable automatic volume mesh optimization
|
|
|
|
int optsteps_3d; //!< Number of optimize steps to use for 3-D mesh optimization
|
|
int optsteps_2d; //!< Number of optimize steps to use for 2-D mesh optimization
|
|
|
|
// Philippose - 13/09/2010
|
|
// Added a couple more parameters into the meshing parameters list
|
|
// from Netgen into Nglib
|
|
int invert_tets; //!< Invert all the volume elements
|
|
int invert_trigs; //!< Invert all the surface triangle elements
|
|
|
|
int check_overlap; //!< Check for overlapping surfaces during Surface meshing
|
|
int check_overlapping_boundary; //!< Check for overlapping surface elements before volume meshing
|
|
|
|
|
|
/*!
|
|
Default constructor for the Mesh Parameters class
|
|
|
|
Note: This constructor initialises the variables in the
|
|
class with the following default values
|
|
- #uselocalh: 1
|
|
- #maxh: 1000.0
|
|
- #fineness: 0.5
|
|
- #grading: 0.3
|
|
- #elementsperedge: 2.0
|
|
- #elementspercurve: 2.0
|
|
- #closeedgeenable: 0
|
|
- #closeedgefact: 2.0
|
|
- #secondorder: 0
|
|
- #meshsize_filename: null
|
|
- #quad_dominated: 0
|
|
- #optsurfmeshenable: 1
|
|
- #optvolmeshenable: 1
|
|
- #optsteps_2d: 3
|
|
- #optsteps_3d: 3
|
|
- #invert_tets: 0
|
|
- #invert_trigs:0
|
|
- #check_overlap: 1
|
|
- #check_overlapping_boundary: 1
|
|
*/
|
|
NGLIB_API Ng_Meshing_Parameters();
|
|
|
|
|
|
|
|
/*!
|
|
Reset the meshing parameters to their defaults
|
|
|
|
This member function resets all the meshing parameters
|
|
of the object to the default values
|
|
*/
|
|
NGLIB_API void Reset_Parameters();
|
|
|
|
|
|
|
|
/*!
|
|
Transfer local meshing parameters to internal meshing parameters
|
|
|
|
This member function transfers all the meshing parameters
|
|
defined in the local meshing parameters structure of nglib into
|
|
the internal meshing parameters structure used by the Netgen core
|
|
*/
|
|
NGLIB_API void Transfer_Parameters();
|
|
};
|
|
|
|
|
|
|
|
|
|
// *** Functions Exported by this Library *************
|
|
|
|
// ------------------------------------------------------------------
|
|
// Netgen library initialisation / destruction functions
|
|
|
|
/*! \brief Initialise the Netgen library and prepare for use
|
|
|
|
This function needs to be called by the third-party
|
|
program before beginning to use the other Netgen
|
|
specific functions.
|
|
*/
|
|
NGLIB_API void Ng_Init ();
|
|
|
|
|
|
/*! \brief Exit the Netgen meshing kernel in a clean manner
|
|
|
|
Use this function to exit the meshing sub-system in
|
|
a clean and orderly manner.
|
|
*/
|
|
NGLIB_API void Ng_Exit ();
|
|
|
|
|
|
/*! \brief Create a new (and empty) Netgen Mesh Structure
|
|
|
|
This function creates a new Netgen Mesh, initialises
|
|
it, and returns a pointer to the created mesh structure.
|
|
|
|
Use the returned pointer for subsequent operations
|
|
which involve mesh operations.
|
|
|
|
\return Ng_Mesh Pointer to a Netgen Mesh type #Ng_Mesh
|
|
*/
|
|
NGLIB_API Ng_Mesh * Ng_NewMesh ();
|
|
|
|
|
|
/*! \brief Delete an existing Netgen Mesh Structure
|
|
|
|
Use this function to delete an existing Netgen mesh
|
|
structure and release the used memory.
|
|
|
|
\param mesh Pointer to an existing Netgen Mesh structure
|
|
of type #Ng_Mesh
|
|
*/
|
|
NGLIB_API void Ng_DeleteMesh (Ng_Mesh * mesh);
|
|
|
|
|
|
/*! \brief Save a Netgen Mesh to disk
|
|
|
|
This function allows a generated mesh structure to be saved
|
|
to disk.
|
|
|
|
A Mesh saved using this function, will be written to disk
|
|
in the Netgen VOL file format.
|
|
|
|
\param mesh Pointer to an existing Netgen Mesh structure
|
|
of type #Ng_Mesh
|
|
\param filename Pointer to a character array containing the
|
|
name of the file to which the mesh should
|
|
be saved
|
|
*/
|
|
NGLIB_API void Ng_SaveMesh(Ng_Mesh * mesh, const char* filename);
|
|
|
|
|
|
/*! \brief Load a Netgen VOL Mesh from disk into memory
|
|
|
|
A Netgen mesh saved in the internal VOL format can be loaded
|
|
into a Netgen Mesh structure using this function.
|
|
|
|
\param filename Pointer to a character array containing the
|
|
name of the file to load
|
|
\return Ng_Mesh Pointer to a Netgen Mesh type #Ng_Mesh containing
|
|
the mesh loaded from disk
|
|
*/
|
|
NGLIB_API Ng_Mesh * Ng_LoadMesh(const char* filename);
|
|
|
|
|
|
/*! \brief Merge a Netgen VOL Mesh from disk into an existing mesh in memory
|
|
|
|
A Netgen mesh saved in the internal VOL format can be merged
|
|
into an existing Netgen Mesh structure using this function.
|
|
|
|
\param mesh Name of the Mesh structure already existent in memory
|
|
\param filename Pointer to a character array containing the
|
|
name of the file to load
|
|
\return Ng_Result Status of the merge operation
|
|
*/
|
|
NGLIB_API Ng_Result Ng_MergeMesh(Ng_Mesh * mesh, const char* filename);
|
|
|
|
|
|
/*! \brief Merge one Netgen Mesh into another Netgen Mesh in the case
|
|
when both are already in memory
|
|
|
|
(NOTE: FUNCTION STILL WORK IN PROGRESS!!!)
|
|
|
|
This function can be used to merge two Netgen meshes already present
|
|
in memory.
|
|
|
|
\param mesh1 Parent Mesh structure into which the second mesh
|
|
will be merged
|
|
\param mesh2 Child mesh structure which will get merged into
|
|
the parent mesh
|
|
\return Ng_Result Status of the merge operation
|
|
*/
|
|
NGLIB_API Ng_Result Ng_MergeMesh(Ng_Mesh * mesh1, Ng_Mesh * mesh2);
|
|
// ------------------------------------------------------------------
|
|
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
// Basic Meshing functions for manually adding points, surface elements
|
|
// and volume elements to a Netgen Mesh structure
|
|
|
|
/*! \brief Add a point to a given Netgen Mesh Structure
|
|
|
|
This function allows points to be directly added to a Netgen
|
|
mesh structure by providing the co-ordinates.
|
|
|
|
Each call to the function allows only one point to be added.
|
|
|
|
\param mesh Pointer to an existing Netgen Mesh structure of
|
|
type #Ng_Mesh
|
|
\param x Pointer to an array of type double containing the co-ordinates
|
|
of the point to be added in the form: \n
|
|
- x[0] = X co-ordinate
|
|
- x[1] = Y co-ordinate
|
|
- x[2] = Z co-ordinate
|
|
*/
|
|
NGLIB_API void Ng_AddPoint (Ng_Mesh * mesh, double * x);
|
|
|
|
|
|
/*! \brief Add a surface element to a given Netgen Mesh Structure
|
|
|
|
This function allows the top-level code to directly add individual
|
|
Surface Elements to a Netgen Mesh Structure by providing the type of
|
|
element to be added and the indices of the points which constitute the
|
|
element.
|
|
|
|
<i>Note:</i>
|
|
- The points referred to by the surface elements must have been
|
|
added prior to calling this function.
|
|
- Currently only triangular elements are supported, and the Surface Element
|
|
Type argument is not used.
|
|
|
|
\param mesh Pointer to an existing Netgen Mesh structure of
|
|
type #Ng_Mesh
|
|
\param et Surface Element type provided via the enumerated type
|
|
#Ng_Surface_Element_Type
|
|
\param pi Pointer to an array of integers containing the indices of the
|
|
points which constitute the surface element being added
|
|
*/
|
|
NGLIB_API void Ng_AddSurfaceElement (Ng_Mesh * mesh, Ng_Surface_Element_Type et, int * pi);
|
|
|
|
|
|
/*! \brief Add a volume element to a given Netgen Mesh Structure
|
|
|
|
This function allows the top-level code to directly add individual
|
|
Volume Elements to a Netgen Mesh Structure by providing the type of
|
|
element to be added and the indices of the points which constitute the
|
|
element.
|
|
|
|
<i>Note:</i>
|
|
- The points referred to by the volume elements must have been
|
|
added prior to calling this function.
|
|
- Currently only tetrahedral elements are supported, and the Volume Element
|
|
Type argument is not used.
|
|
|
|
\param mesh Pointer to an existing Netgen Mesh structure of
|
|
type #Ng_Mesh
|
|
\param et Volume Element type provided via the enumerated type
|
|
#Ng_Volume_Element_Type
|
|
\param pi Pointer to an array of integers containing the indices of the
|
|
points which constitute the volume element being added
|
|
|
|
*/
|
|
NGLIB_API void Ng_AddVolumeElement (Ng_Mesh * mesh, Ng_Volume_Element_Type et, int * pi);
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
// Local Mesh Size restriction / limiting utilities
|
|
|
|
/*! \brief Apply a global restriction on mesh element size
|
|
|
|
This utility allows the user to apply a global mesh element
|
|
size limitation.
|
|
|
|
During mesh creation, in the absence of an explicit local
|
|
size restriction around the neighbourhood of a point within
|
|
the meshing domain, this global size restriction will be
|
|
utilised.
|
|
|
|
<b>Note</b>: This function only limits the <b>Maximum</b>
|
|
size of an element within the mesh.
|
|
|
|
\param mesh Pointer to an existing Netgen Mesh structure of
|
|
type #Ng_Mesh
|
|
\param h Variable of type <i>double</i>, specifying the maximum
|
|
allowable mesh size
|
|
*/
|
|
NGLIB_API void Ng_RestrictMeshSizeGlobal (Ng_Mesh * mesh, double h);
|
|
|
|
|
|
/*! \brief Locally restrict the mesh element size at the given point
|
|
|
|
Unlike the function #Ng_RestrictMeshSizeGlobal, this function
|
|
allows the user to locally restrict the maximum allowable mesh
|
|
size at a given point.
|
|
|
|
The point is specified via its three cartesian co-ordinates.
|
|
|
|
<b>Note</b>: This function only limits the <b>Maximum</b> size
|
|
of the elements around the specified point.
|
|
|
|
\param mesh Pointer to an existing Netgen Mesh structure of
|
|
type #Ng_Mesh
|
|
\param p Pointer to an Array of type <i>double</i>, containing
|
|
the three co-ordinates of the point in the form: \n
|
|
- p[0] = X co-ordinate
|
|
- p[1] = Y co-ordinate
|
|
- p[2] = Z co-ordinate
|
|
\param h Variable of type <i>double</i>, specifying the maximum
|
|
allowable mesh size at that point
|
|
*/
|
|
NGLIB_API void Ng_RestrictMeshSizePoint (Ng_Mesh * mesh, double * p, double h);
|
|
|
|
|
|
/*! \brief Locally restrict the mesh element size within a specified box
|
|
|
|
Similar to the function #Ng_RestrictMeshSizePoint, this function
|
|
allows the size of elements within a mesh to be locally limited.
|
|
|
|
However, rather than limit the mesh size at a single point, this
|
|
utility restricts the local mesh size within a 3D Box region, specified
|
|
via the co-ordinates of the two diagonally opposite points of a cuboid.
|
|
|
|
<b>Note</b>: This function only limits the <b>Maximum</b> size
|
|
of the elements within the specified region.
|
|
|
|
\param mesh Pointer to an existing Netgen Mesh structure of
|
|
type #Ng_Mesh
|
|
\param pmin Pointer to an Array of type <i>double</i>, containing
|
|
the three co-ordinates of the first point of the cuboid: \n
|
|
- pmin[0] = X co-ordinate
|
|
- pmin[1] = Y co-ordinate
|
|
- pmin[2] = Z co-ordinate
|
|
\param pmax Pointer to an Array of type <i>double</i>, containing
|
|
the three co-ordinates of the opposite point of the
|
|
cuboid: \n
|
|
- pmax[0] = X co-ordinate
|
|
- pmax[1] = Y co-ordinate
|
|
- pmax[2] = Z co-ordinate
|
|
\param h Variable of type <i>double</i>, specifying the maximum
|
|
allowable mesh size at that point
|
|
*/
|
|
NGLIB_API void Ng_RestrictMeshSizeBox (Ng_Mesh * mesh, double * pmin, double * pmax, double h);
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
// 3D Mesh Generation functions
|
|
|
|
/*! \brief Create a 3D Volume Mesh given a Surface Mesh
|
|
|
|
After creating a surface mesh, this function can be utilised
|
|
to automatically generate the corresponding 3D Volume Mesh.
|
|
|
|
Mesh generation parameters (such as grading, maximum element size,
|
|
etc.) are specified via the meshing parameters class which also
|
|
needs to be passed to this function.
|
|
|
|
<b>Note</b>: Currently, Netgen generates pure tetrahedral volume
|
|
meshes.
|
|
|
|
\param mesh Pointer to an existing Netgen Mesh structure of
|
|
type #Ng_Mesh
|
|
\param mp Pointer to a copy of the Meshing Parameters class
|
|
(#Ng_Meshing_Parameters), filled up with the
|
|
required values
|
|
|
|
\return Ng_Result Status of the Mesh Generation routine. More
|
|
details regarding the return value can be
|
|
found in the description of #Ng_Result
|
|
*/
|
|
NGLIB_API Ng_Result Ng_GenerateVolumeMesh (Ng_Mesh * mesh, Ng_Meshing_Parameters * mp);
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
// Basic Mesh information functions
|
|
|
|
/*! \brief Returns the Number of Points present in the specified Mesh
|
|
|
|
Given an already existent Netgen Mesh Structure, this function
|
|
returns the number of points currently present within the Mesh.
|
|
|
|
\param mesh Pointer to an existing Netgen Mesh structure of
|
|
type #Ng_Mesh
|
|
\return
|
|
Integer Data-type with the number of points in the Mesh
|
|
*/
|
|
NGLIB_API int Ng_GetNP (Ng_Mesh * mesh);
|
|
|
|
|
|
/*! \brief Returns the Number of Surface Elements present in the specified Mesh
|
|
|
|
Given an already existent Netgen Mesh Structure, this function
|
|
returns the number of surface elements currently present within
|
|
the Mesh.
|
|
|
|
\param mesh Pointer to an existing Netgen Mesh structure of
|
|
type #Ng_Mesh
|
|
\return
|
|
Integer Data-type with the number of surface elements in the Mesh
|
|
*/
|
|
NGLIB_API int Ng_GetNSE (Ng_Mesh * mesh);
|
|
|
|
|
|
/*! \brief Returns the Number of Volume Elements present in the specified Mesh
|
|
|
|
Given an already existent Netgen Mesh Structure, this function
|
|
returns the number of volume elements currently present within
|
|
the Mesh.
|
|
|
|
\param mesh Pointer to an existing Netgen Mesh structure of
|
|
type #Ng_Mesh
|
|
\return
|
|
Integer Data-type with the number of volume elements in the Mesh
|
|
*/
|
|
NGLIB_API int Ng_GetNE (Ng_Mesh * mesh);
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
// Mesh Topology functions
|
|
// Use these functions to extract points, surface / volume elements,
|
|
// perform topological searches, etc..etc...
|
|
|
|
// Return the Point Coordinates of a specified Point
|
|
// The x, y and z co-ordinates are returned in the array pointer as
|
|
// x[0] = x ; x[1] = y ; x[2] = z
|
|
NGLIB_API void Ng_GetPoint (Ng_Mesh * mesh, int num, double * x);
|
|
|
|
|
|
|
|
// return surface and volume element in pi
|
|
NGLIB_API Ng_Surface_Element_Type
|
|
Ng_GetSurfaceElement (Ng_Mesh * mesh, int num, int * pi);
|
|
|
|
NGLIB_API Ng_Volume_Element_Type
|
|
Ng_GetVolumeElement (Ng_Mesh * mesh, int num, int * pi);
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
// **********************************************************
|
|
// ** 2D Meshing **
|
|
// **********************************************************
|
|
|
|
|
|
// feeds points and boundary to mesh
|
|
|
|
NGLIB_API void Ng_AddPoint_2D (Ng_Mesh * mesh, double * x);
|
|
NGLIB_API void Ng_AddBoundarySeg_2D (Ng_Mesh * mesh, int pi1, int pi2);
|
|
|
|
// ask for number of points, elements and boundary segments
|
|
NGLIB_API int Ng_GetNP_2D (Ng_Mesh * mesh);
|
|
NGLIB_API int Ng_GetNE_2D (Ng_Mesh * mesh);
|
|
NGLIB_API int Ng_GetNSeg_2D (Ng_Mesh * mesh);
|
|
|
|
// return point coordinates
|
|
NGLIB_API void Ng_GetPoint_2D (Ng_Mesh * mesh, int num, double * x);
|
|
|
|
// return 2d elements
|
|
NGLIB_API Ng_Surface_Element_Type
|
|
Ng_GetElement_2D (Ng_Mesh * mesh, int num, int * pi, int * matnum = NULL);
|
|
|
|
// return 2d boundary segment
|
|
NGLIB_API void Ng_GetSegment_2D (Ng_Mesh * mesh, int num, int * pi, int * matnum = NULL);
|
|
|
|
|
|
// load 2d netgen spline geometry
|
|
NGLIB_API Ng_Geometry_2D * Ng_LoadGeometry_2D (const char * filename);
|
|
|
|
// generate 2d mesh, mesh is allocated by function
|
|
NGLIB_API Ng_Result Ng_GenerateMesh_2D (Ng_Geometry_2D * geom,
|
|
Ng_Mesh ** mesh,
|
|
Ng_Meshing_Parameters * mp);
|
|
|
|
NGLIB_API void Ng_HP_Refinement (Ng_Geometry_2D * geom,
|
|
Ng_Mesh * mesh,
|
|
int levels);
|
|
|
|
|
|
|
|
|
|
|
|
// **********************************************************
|
|
// ** STL Meshing **
|
|
// **********************************************************
|
|
|
|
|
|
// loads geometry from STL file
|
|
NGLIB_API Ng_STL_Geometry * Ng_STL_LoadGeometry (const char * filename, int binary = 0);
|
|
|
|
|
|
// generate new STL Geometry
|
|
NGLIB_API Ng_STL_Geometry * Ng_STL_NewGeometry ();
|
|
|
|
|
|
// fills STL Geometry
|
|
// positive orientation
|
|
// normal vector may be null-pointer
|
|
NGLIB_API void Ng_STL_AddTriangle (Ng_STL_Geometry * geom,
|
|
double * p1, double * p2, double * p3,
|
|
double * nv = NULL);
|
|
|
|
// add (optional) edges :
|
|
NGLIB_API void Ng_STL_AddEdge (Ng_STL_Geometry * geom,
|
|
double * p1, double * p2);
|
|
|
|
// after adding triangles (and edges) initialize
|
|
NGLIB_API Ng_Result Ng_STL_InitSTLGeometry (Ng_STL_Geometry * geom);
|
|
|
|
// automatically generates edges:
|
|
NGLIB_API Ng_Result Ng_STL_MakeEdges (Ng_STL_Geometry * geom,
|
|
Ng_Mesh* mesh,
|
|
Ng_Meshing_Parameters * mp);
|
|
|
|
|
|
// generates mesh, empty mesh must be already created.
|
|
NGLIB_API Ng_Result Ng_STL_GenerateSurfaceMesh (Ng_STL_Geometry * geom,
|
|
Ng_Mesh * mesh,
|
|
Ng_Meshing_Parameters * mp);
|
|
|
|
|
|
#ifdef ACIS
|
|
|
|
// **********************************************************
|
|
// ** ACIS Meshing **
|
|
// **********************************************************
|
|
|
|
/// Data type for NETGEN STL geomty
|
|
typedef void * Ng_ACIS_Geometry;
|
|
|
|
// loads geometry from STL file
|
|
NGLIB_API Ng_ACIS_Geometry * Ng_ACIS_LoadGeometry (const char * filename);
|
|
|
|
// generates mesh, empty mesh must be already created.
|
|
NGLIB_API Ng_Result Ng_ACIS_GenerateSurfaceMesh (Ng_ACIS_Geometry * geom,
|
|
Ng_Mesh * mesh,
|
|
Ng_Meshing_Parameters * mp);
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// **********************************************************
|
|
// ** Mesh refinement algorithms **
|
|
// **********************************************************
|
|
|
|
// uniform mesh refinement
|
|
NGLIB_API void Ng_Uniform_Refinement (Ng_Mesh * mesh);
|
|
|
|
|
|
// uniform mesh refinement with geometry adaption:
|
|
|
|
NGLIB_API void Ng_2D_Uniform_Refinement (Ng_Geometry_2D * geom,
|
|
Ng_Mesh * mesh);
|
|
|
|
NGLIB_API void Ng_STL_Uniform_Refinement (Ng_STL_Geometry * geom,
|
|
Ng_Mesh * mesh);
|
|
|
|
NGLIB_API void Ng_CSG_Uniform_Refinement (Ng_CSG_Geometry * geom,
|
|
Ng_Mesh * mesh);
|
|
|
|
|
|
|
|
|
|
// **********************************************************
|
|
// ** Second Order mesh algorithms **
|
|
// **********************************************************
|
|
|
|
// convert mesh to second order
|
|
NGLIB_API void Ng_Generate_SecondOrder (Ng_Mesh * mesh);
|
|
|
|
|
|
// convert mesh to second order with geometry adaption:
|
|
|
|
NGLIB_API void Ng_2D_Generate_SecondOrder (Ng_Geometry_2D * geom,
|
|
Ng_Mesh * mesh);
|
|
|
|
NGLIB_API void Ng_STL_Generate_SecondOrder (Ng_STL_Geometry * geom,
|
|
Ng_Mesh * mesh);
|
|
|
|
NGLIB_API void Ng_CSG_Generate_SecondOrder (Ng_CSG_Geometry * geom,
|
|
Ng_Mesh * mesh);
|
|
|
|
|
|
#ifdef OCCGEOMETRY
|
|
#include "nglib_occ.h"
|
|
#endif // OCCGEOMETRY
|
|
//
|
|
#endif // NGLIB
|