nglib.h

Go to the documentation of this file.

#ifndef NGLIB
#define NGLIB

/**************************************************************************/
/* File:   nglib.h                                                        */
/* Author: Joachim Schoeberl                                              */
/* Date:   7. May. 2000                                                   */
/**************************************************************************/

// Philippose - 14.02.2009
// Modifications for creating a DLL in Windows
#ifdef WIN32
   #ifdef NGLIB_EXPORTS || nglib_EXPORTS
      #define DLL_HEADER   __declspec(dllexport)
   #else
      #define DLL_HEADER   __declspec(dllimport)
   #endif
#else
   #define DLL_HEADER 
#endif



// ** Constants used within Netgen *********************
#define NG_VOLUME_ELEMENT_MAXPOINTS 10

#define NG_SURFACE_ELEMENT_MAXPOINTS 8



// *** Data-types for accessing Netgen functionality ***
typedef void * Ng_Mesh;

typedef void * Ng_CSG_Geometry;

typedef void * Ng_Geometry_2D;

typedef void * Ng_STL_Geometry;

#ifdef OCCGEOMETRY

typedef void * Ng_OCC_Geometry;
typedef void * Ng_OCC_TopTools_IndexedMapOfShape;
#endif


// *** Special Enum types used within Netgen ***********
enum Ng_Surface_Element_Type 
   { NG_TRIG = 1, NG_QUAD = 2, NG_TRIG6 = 3, NG_QUAD6 = 4, NG_QUAD8 = 5 };

enum Ng_Volume_Element_Type 
   { NG_TET = 1, NG_PYRAMID = 2, NG_PRISM = 3, NG_TET10 = 4 };

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 **********
class Ng_Meshing_Parameters 
{
public:

  int blockfill;
  float filldist;

   int uselocalh;                      

   double maxh;                        
   double minh;                        

   double fineness;                    
   double grading;                     

   double elementsperedge;             
   double elementspercurve;            

   int closeedgeenable;                
   double closeedgefact;               

   int second_order;                   
   int quad_dominated;                 

   char * meshsize_filename;           

   int optsurfmeshenable;              
   int optvolmeshenable;               

   int optsteps_3d;                     
   int optsteps_2d;                     

   // Philippose - 13/09/2010
   // Added a couple more parameters into the meshing parameters list 
   // from Netgen into Nglib
   int invert_tets;                    
   int invert_trigs;                   

   int check_overlap;                  
   int check_overlapping_boundary;     


   DLL_HEADER Ng_Meshing_Parameters();



   DLL_HEADER void Reset_Parameters();



   DLL_HEADER void Transfer_Parameters();
};




// *** Functions Exported by this Library *************

// ------------------------------------------------------------------
// Netgen library initialisation / destruction functions

DLL_HEADER void Ng_Init ();


DLL_HEADER void Ng_Exit ();
  

DLL_HEADER  Ng_Mesh * Ng_NewMesh ();


DLL_HEADER void Ng_DeleteMesh (Ng_Mesh * mesh);


DLL_HEADER void Ng_SaveMesh(Ng_Mesh * mesh, const char* filename);


DLL_HEADER Ng_Mesh * Ng_LoadMesh(const char* filename);

DLL_HEADER Ng_Mesh * Ng_SetProperties(Ng_Mesh * m, int surfnr, int bcnr, int domin, int domout);


DLL_HEADER Ng_Result Ng_MergeMesh(Ng_Mesh * mesh, const char* filename);


DLL_HEADER 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

DLL_HEADER void Ng_AddPoint (Ng_Mesh * mesh, double * x);


DLL_HEADER void Ng_AddSurfaceElement (Ng_Mesh * mesh, Ng_Surface_Element_Type et, int * pi);


DLL_HEADER void Ng_AddVolumeElement (Ng_Mesh * mesh, Ng_Volume_Element_Type et, int * pi);
  
// ------------------------------------------------------------------



// ------------------------------------------------------------------
// Local Mesh Size restriction / limiting utilities

DLL_HEADER void Ng_RestrictMeshSizeGlobal (Ng_Mesh * mesh, double h);


DLL_HEADER void Ng_RestrictMeshSizePoint (Ng_Mesh * mesh, double * p, double h);


DLL_HEADER void Ng_RestrictMeshSizeBox (Ng_Mesh * mesh, double * pmin, double * pmax, double h);

// ------------------------------------------------------------------



// ------------------------------------------------------------------
// 3D Mesh Generation functions

DLL_HEADER Ng_Result Ng_GenerateVolumeMesh (Ng_Mesh * mesh, Ng_Meshing_Parameters * mp);

// ------------------------------------------------------------------



// ------------------------------------------------------------------
// Basic Mesh information functions

DLL_HEADER int Ng_GetNP (Ng_Mesh * mesh);


DLL_HEADER int Ng_GetNSE (Ng_Mesh * mesh);


DLL_HEADER 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
DLL_HEADER void Ng_GetPoint (Ng_Mesh * mesh, int num, double * x);



// return surface and volume element in pi
DLL_HEADER Ng_Surface_Element_Type 
Ng_GetSurfaceElement (Ng_Mesh * mesh, int num, int * pi);

DLL_HEADER Ng_Volume_Element_Type
Ng_GetVolumeElement (Ng_Mesh * mesh, int num, int * pi);

// ------------------------------------------------------------------




// **********************************************************
// **   2D Meshing                                         **
// **********************************************************


// feeds points and boundary to mesh

DLL_HEADER void Ng_AddPoint_2D (Ng_Mesh * mesh, double * x);
DLL_HEADER void Ng_AddBoundarySeg_2D (Ng_Mesh * mesh, int pi1, int pi2);
  
// ask for number of points, elements and boundary segments
DLL_HEADER int Ng_GetNP_2D (Ng_Mesh * mesh);
DLL_HEADER int Ng_GetNE_2D (Ng_Mesh * mesh);
DLL_HEADER int Ng_GetNSeg_2D (Ng_Mesh * mesh);
  
//  return point coordinates
DLL_HEADER void Ng_GetPoint_2D (Ng_Mesh * mesh, int num, double * x);

// return 2d elements
DLL_HEADER Ng_Surface_Element_Type 
Ng_GetElement_2D (Ng_Mesh * mesh, int num, int * pi, int * matnum = NULL);

// return 2d boundary segment
DLL_HEADER void Ng_GetSegment_2D (Ng_Mesh * mesh, int num, int * pi, int * matnum = NULL);


// load 2d netgen spline geometry
DLL_HEADER Ng_Geometry_2D * Ng_LoadGeometry_2D (const char * filename);

// generate 2d mesh, mesh is allocated by function
DLL_HEADER Ng_Result Ng_GenerateMesh_2D (Ng_Geometry_2D * geom,
                                         Ng_Mesh ** mesh,
                                         Ng_Meshing_Parameters * mp);
  
DLL_HEADER void Ng_HP_Refinement (Ng_Geometry_2D * geom,
                                  Ng_Mesh * mesh,
                                  int levels);
  




// **********************************************************
// **   STL Meshing                                        **
// **********************************************************


// loads geometry from STL file
DLL_HEADER Ng_STL_Geometry * Ng_STL_LoadGeometry (const char * filename, int binary = 0);


// generate new STL Geometry
DLL_HEADER Ng_STL_Geometry * Ng_STL_NewGeometry ();
  

// fills STL Geometry
// positive orientation
// normal vector may be null-pointer
DLL_HEADER void Ng_STL_AddTriangle (Ng_STL_Geometry * geom, 
                         double * p1, double * p2, double * p3, 
                         double * nv = NULL);

// add (optional) edges :
DLL_HEADER void Ng_STL_AddEdge (Ng_STL_Geometry * geom, 
                     double * p1, double * p2);

// after adding triangles (and edges) initialize
DLL_HEADER Ng_Result Ng_STL_InitSTLGeometry (Ng_STL_Geometry * geom);

// automatically generates edges:
DLL_HEADER Ng_Result Ng_STL_MakeEdges (Ng_STL_Geometry * geom,
                            Ng_Mesh* mesh,
                            Ng_Meshing_Parameters * mp);


// generates mesh, empty mesh must be already created.
DLL_HEADER Ng_Result Ng_STL_GenerateSurfaceMesh (Ng_STL_Geometry * geom,
                                                 Ng_Mesh * mesh,
                                                 Ng_Meshing_Parameters * mp);


#ifdef ACIS

// **********************************************************
// **   ACIS Meshing                                       **
// **********************************************************

typedef void * Ng_ACIS_Geometry;

// loads geometry from STL file
DLL_HEADER Ng_ACIS_Geometry * Ng_ACIS_LoadGeometry (const char * filename);
  
// generates mesh, empty mesh must be already created.
DLL_HEADER Ng_Result Ng_ACIS_GenerateSurfaceMesh (Ng_ACIS_Geometry * geom,
                                                  Ng_Mesh * mesh,
                                                  Ng_Meshing_Parameters * mp);


#endif



#ifdef OCCGEOMETRY

// **********************************************************
// **   OpenCascade Geometry / Meshing Utilities           **
// **********************************************************

// Create new OCC Geometry Object
DLL_HEADER Ng_OCC_Geometry * Ng_OCC_NewGeometry ();

// Delete an OCC Geometry Object
DLL_HEADER Ng_Result Ng_OCC_DeleteGeometry (Ng_OCC_Geometry * geom);

// Loads geometry from STEP file
DLL_HEADER Ng_OCC_Geometry * Ng_OCC_Load_STEP (const char * filename);

// Loads geometry from IGES file
DLL_HEADER Ng_OCC_Geometry * Ng_OCC_Load_IGES (const char * filename);

// Loads geometry from BREP file
DLL_HEADER Ng_OCC_Geometry * Ng_OCC_Load_BREP (const char * filename);

// Set the local mesh size based on geometry / topology
DLL_HEADER Ng_Result Ng_OCC_SetLocalMeshSize (Ng_OCC_Geometry * geom,
                                              Ng_Mesh * mesh,
                                              Ng_Meshing_Parameters * mp);

// Mesh the edges and add Face descriptors to prepare for surface meshing
DLL_HEADER Ng_Result Ng_OCC_GenerateEdgeMesh (Ng_OCC_Geometry * geom,
                                              Ng_Mesh * mesh,
                                              Ng_Meshing_Parameters * mp);

// Mesh the surfaces of an OCC geometry
DLL_HEADER Ng_Result Ng_OCC_GenerateSurfaceMesh (Ng_OCC_Geometry * geom,
                                                 Ng_Mesh * mesh,
                                                 Ng_Meshing_Parameters * mp); 

// Get the face map of an already loaded OCC geometry
DLL_HEADER Ng_Result Ng_OCC_GetFMap(Ng_OCC_Geometry * geom, 
                                    Ng_OCC_TopTools_IndexedMapOfShape * FMap);

#endif // OCCGEOMETRY



// **********************************************************
// **   Mesh refinement algorithms                         **
// **********************************************************

// uniform mesh refinement
DLL_HEADER void Ng_Uniform_Refinement (Ng_Mesh * mesh);


// uniform mesh refinement with geometry adaption:

DLL_HEADER void Ng_2D_Uniform_Refinement (Ng_Geometry_2D * geom,
                                          Ng_Mesh * mesh);

DLL_HEADER void Ng_STL_Uniform_Refinement (Ng_STL_Geometry * geom,
                                           Ng_Mesh * mesh);

DLL_HEADER void Ng_CSG_Uniform_Refinement (Ng_CSG_Geometry * geom,
                                           Ng_Mesh * mesh);

#ifdef OCCGEOMETRY
DLL_HEADER void Ng_OCC_Uniform_Refinement (Ng_OCC_Geometry * geom,
                                           Ng_Mesh * mesh);
#endif



// **********************************************************
// **   Second Order mesh algorithms                       **
// **********************************************************

// convert mesh to second order
DLL_HEADER void Ng_Generate_SecondOrder (Ng_Mesh * mesh);


// convert mesh to second order with geometry adaption:

DLL_HEADER void Ng_2D_Generate_SecondOrder (Ng_Geometry_2D * geom,
                                          Ng_Mesh * mesh);

DLL_HEADER void Ng_STL_Generate_SecondOrder (Ng_STL_Geometry * geom,
                                           Ng_Mesh * mesh);

DLL_HEADER void Ng_CSG_Generate_SecondOrder (Ng_CSG_Geometry * geom,
                                           Ng_Mesh * mesh);

#ifdef OCCGEOMETRY
DLL_HEADER void Ng_OCC_Generate_SecondOrder (Ng_OCC_Geometry * geom,
                                           Ng_Mesh * mesh);
#endif


#endif // NGLIB