ForkMaster/netgen
1
0
Fork 0
mirror of https://github.com/NGSolve/netgen.git synced 2024-12-25 05:20:34 +05:00
Code Issues Packages Projects Releases Wiki Activity
e51918df35
netgen/nglib/nglib.h
Matthias Hochsteger b694b4667a rework build system, separate gui and non-gui code 
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
2022-05-05 14:39:31 +02:00

698 lines
24 KiB
C++
Raw Blame History

#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
Reference in New Issue View Git Blame Copy Permalink