tess.h

Go to the documentation of this file.

#ifndef _TESS_H
#define _TESS_H
 
#include "util/util_geom_ptr_dtk.hpp"
#include "util/util_mesh_dtk.hpp"
#include "util/error_dtk.hpp"
#include "util/util_topology_ptr_dtk.hpp"
#include "def/define.h"
#include "util/dtk_maindoc.hpp"
#include "util/util_stl_dtk.hpp"
 
//! \defgroup tess_main_func Tesselation main functions
//! \brief All the basics functions you need to tesselate any Dtk brep data structures.
//! To better control the tesselation process, see section \ref tess_option.
//! @{
 
//! \brief Init the tesselation library
//! \param[in] inWorkingDirectory : Directory for temporary file used for tesselation
//! \param[in] inTolerance(mm) : Maximum accepted chordal error between the CAD surface and the tesselated mesh
//! \return 0 if OK \n -4 if no licence found
int tess_InitTesselation(Dtk_string inWorkingDirectory,double inTolerance);
 
//! \brief Return current status of tesselation started
Dtk_ErrorStatus TesselationIsStarted();
 
//! \brief Init the tesselation library with parameters suited for most visualisation purposes
//! Linear tolerance is deactivated, and angular tolerance set to 10 degrees
//! \warning This function disable the linear tolerance, see tess_set_linearTolerance(). It is suited for visualisation purpose only. If you need a more precise tesselation control using linear tolerance, call tess_disableTolLinear(DTK_FALSE) to re-enable it.
//! \return 0 if OK \n -4 if no licence found
int tess_InitTesselation();
 
//! \brief Free the data used by tesselation library
void tess_EndTesselation();
 
//! \brief Tesselate a body. Generates one mesh per shell in the body.
//! \param[in] inBodyToWrite : Body to be tessellate
//! \param[out] outMeshes : Result meshes, one `Dtk_MeshPtr` per shell
//! \param[out] outIsSolid : Info on each mesh topology. 0 if open, 1 if closed
//! \param[in] inTessWireframe : Enable the tesselation of wireframes contained in the body's shell. See Dtk_Shell::GetNumWireSet()
//! \param[in] inApplyRenderInfos : Enable the application of render infos from body to mesh
Dtk_ErrorStatus tess_BodyToMeshes( const Dtk_BodyPtr& inBodyToWrite,
                                             Dtk_tab<Dtk_MeshPtr>& outMeshes,
                                             Dtk_tab<Dtk_Int32>& outIsSolid,
                                             Dtk_bool inTessWireframe = DTK_FALSE,
                                             Dtk_bool inApplyRenderInfos = DTK_FALSE );
 
//! \brief Tesselate a shell
//! \param[in] inShell : Shell to be tesselate
//! \param[out] outMesh : Result mesh
//! \param[out] outIsSolid : Info on mesh topology. 0 if open, 1 if closed
Dtk_ErrorStatus tess_ShellToMesh(const Dtk_ShellPtr &inShell, Dtk_MeshPtr &outMesh, Dtk_Int32 *outIsSolid);
 
//! \brief Tesselate an array of Faces
//! \param[in] inTabFace : Faces to be tesselate
//! \param[out] outMesh : Result mesh
//! \param[out] outIsSolid : Info on mesh topology. 0 if open, 1 if closed
Dtk_ErrorStatus tess_FacesArrayToMesh(Dtk_tab<Dtk_FacePtr> &inTabFace, Dtk_MeshPtr &outMesh, Dtk_Int32 *outIsSolid);
 
//! \brief Tesselate a single face
//! \param[in] inFace : Face to be tesselate
//! \param[out] outMesh : Result mesh
//DTK_TOREMOVE_START
#ifdef AF51BDA7E49648f8AB95949F4CA52EF8
Dtk_ErrorStatus tess_FaceToMesh(Dtk_FacePtr &inFace, Dtk_MeshPtr &outMesh, Dtk_bool inOrientation = DTK_TRUE );
#else
//DTK_TOREMOVE_END
Dtk_ErrorStatus tess_FaceToMesh(Dtk_FacePtr &inFace, Dtk_MeshPtr &outMesh);
//DTK_TOREMOVE_START
#endif
//DTK_TOREMOVE_END
 
//! \brief Get the boundaries (outer and inner) of a mesh face as polylines.
//! Each shell yields a Dtk_mesh, each face of the shell yields a Dtk_mesh_face in the Dtk_mesh, and each edge of the face yields a Dtk_Polyline that you can get with this function.
//! To get the body indice of the corresponding edge, use polyline->get_info()->FindAttribute("TOPO_ID_EDGE",dtk_val) where dtk_val is an integer value containing the TopoId of the edge.
//! The first polyline is the outer boundary, the others are inner boundaries (holes).
//!
//! \note This function requires that the option tess_ComputeBoundariesFromMesh() is enabled (default behaviour).
//! 
//! \note Function Dtk_mesh_face::get_polyline_indices() provide point indices of the mesh face boundaries, but there are not ordered as continuous polylines.
//! tess_getBoundariesFromMeshFace extracts the boundaries as ordered polylines.
//! 
//! \param[in] : mesh  
//! \param[in] : inFace  = face to be processed
//! \param[out] : outBoundaries = result function
//! \b Sample:
//! \code
//!  Dtk_MeshPtr mesh;
//!  Dtk_Size_t nbFace =mesh->get_nb_mesh_face();
//!  for ( int iFace = 0; iFace < nbFace; iFace++ )
//!  {
//!       Dtk_mesh_face * meshFace = mesh->get_mesh_face(iFace);
//!       Dtk_tab<Dtk_tab<Dtk_PolylinePtr>> boundaries;
//!       tess_getBoundariesFromMeshFace(mesh, meshFace, boundaries);
//!       const Dtk_Size_t nbloop = boundaries.size();
//!       for ( Dtk_Size_t iLoop = 0; iLoop < nbloop; iLoop++)
//!       {
//!            Dtk_tab<Dtk_PolylinePtr> loop = boundaries[iLoop];
//!            for ( Dtk_Size_t iEdge = 0; iEdge < loop.size(); iEdge++ )
//!            {
//!                 Dtk_PolylinePtr polyline = loop[iEdge];
//!                 Dtk_Val edgeIdInOriginalBody;
//!                 polyline->get_info()->FindAttribute("TOPO_ID_EDGE",edgeIdInOriginalBody);
//!            }
//!       }
//!  }
//! \endcode
void tess_getBoundariesFromMeshFace( const Dtk_MeshPtr& mesh,
                                              const Dtk_mesh_face* inFace,
                                              Dtk_tab<Dtk_tab<Dtk_PolylinePtr>>& outBoundaries);
 
//! @}
 
//! \defgroup tess_option Tesselation options
//! \brief Options to better control the tesselation process.
//! Main functions are in section \ref tess_main_func.
//! @{
 
//! \brief Set linear tolerance (mm). Maximum chordal error accepted between the CAD surface and the tesselated mesh. Smaller value produces finer mesh, greater value produces coarser mesh.
//! For visualization the constraint is purely visual, so an exact distance per model is unnecessary. In this case, using only an angular tolerance is sufficient.
//! For engineering workflows (CFD, FEM, etc.), stricter geometric control is required, and a linear tolerance must be specified. A common guideline is to set it to a proportion of the model bbox diagonal.
//! Note that angular tolerance is still relevant when linear tolerance is set, to avoids loosing details in areas with small details, like high curvature zones.
//! \warning This tolerance is a distance in mm, not a ratio, therefore it is relative to the model size. If you need a single value that works for any model (common for visualisation), use the angular tolerance.
//! \warning If set to 0.0, the linear tolerance is disabled. To re-enable it, set a valid linear tolerance and call tess_disableTolLinear(DTK_FALSE).
//! \image html discretisation.png
void tess_set_linear(double tol);
//! \brief Get the current linear tolerance. See tess_set_linear().
double tess_get_linear();
//! \brief Set activation of linear tolerance
void tess_disableTolLinear(Dtk_bool bval);
//! \brief Return linear tolerance activation. DTK_TRUE if linear tolerance is disabled.
Dtk_bool tess_disableTolLinear();
 
//! \brief Set angular tolerance (radian). Default value: 10°. Maximum angle between a triangle and the CAD surface.
//! This tolerance is independent of the model size, therefore a single value can be used for any model. It is well suited for visualisation purposes.
//! \image html tess_angulartol.png
void tess_set_angular(double angle);
//! \brief Get the current angular tolerance. See tess_set_angular().
double tess_get_angular();
//! \brief Set activation of angular tolerance
void tess_disableTolAngular(Dtk_bool bval);
//! \brief Return angular tolerance activation. DTK_TRUE if angular tolerance is disabled.
Dtk_bool tess_disableTolAngular();
 
//! \brief Set a maximum ratio between longest and shortest edge of each triangle. With 1.0 only equilateral triangles are generated. With 2.0, the longest edge can be at most twice the shortest edge, etc.
//! Example with ratio= 1.0  
//! \image html tess_ratio1.png
//! Example with ratio= 1000.0 (no constraint)
//! \image html tess_ratio10000.png
void tess_set_Ratio(double tol);
//! \brief Get the current maximum ratio between longest and shortest edge of each triangle. See tess_set_Ratio().
double tess_get_Ratio();
 
//! \brief Set the maximum size of a triangle edge. Default value: inf (mm)
//! \param[in] tol(mm) : maximum size of a triangle edge
void tess_set_MaxSize(double tol);
//! \brief Get the current maximum size of a triangle edge. See tess_set_MaxSize().
double tess_get_MaxSize();
 
//! \brief Set linear tolerance for Wireframe tessellation. Default value is 0.001 (mm). Smaller value produces finer wireframes, greater value produces coarser wireframes.
void tess_set_Wireframe_Discretisation(double tol);
//! \brief Get the current linear tolerance for Wireframe tessellation. See tess_set_Wireframe_Discretisation().
double tess_get_Wireframe_Discretisation();
 
//! \brief Set a vertex map optimisation that reduces the mesh memory footprint (the geometry stay the same). Enabled by default.
//! If enabled, two vertices of the same face that have the same coordinates will be stored only once, and shared by index.
//! For example if you tesselate a cube ( 6 faces ):
//!       - If enabled: vertex array size = 36\n
//!       - If disabled: vertex array size = 24\n
//! \warning Not compatible with Dtk_mesh::compute_round_normals(). You must disable this optimization to use it.
void tess_set_optimize_mesh(int ival);
//! \brief Get the current state of the vertex map optimisation. See tess_set_optimize_mesh().
int tess_get_optimize_mesh();
 
//! \brief Set boundaries computation from mesh option. Default value is enabled (1). See tess_getBoundariesFromMeshFace().
void tess_ComputeBoundariesFromMesh(int value);
//! \brief Get boundaries computation from mesh option. Returns 1 if enabled, 0 if disabled.
int tess_ComputeBoundariesFromMesh();
 
//! \brief Set normales computation from surface option. Enabled by default. If enabled, the normals of each vertex are computed from the CAD surface (smooth, more precise), otherwise they are computed from the triangles.
void tess_ComputeNormalesFromSurface(int value);
//! \brief Get normales computation option. Returns 1 if enabled, 0 if disabled.
int tess_ComputeNormalesFromSurface();
 
//! \brief Set boundaries computation option. Default value is enabled (1). See tess_getBoundariesFromMeshFace().
void tess_AddNaturalBoundariesForUnBounded(int value);
//! \brief Get boundaries computation option. Returns 1 if enabled, 0 if disabled.
int tess_AddNaturalBoundariesForUnBounded();
 
//! \brief Set face duplication option. Default value is enabled (1).
void set_tesselationSuppressDuplicateFace(Dtk_bool inBval);
//! \brief Get face duplication option. Returns 1 if enabled, 0 if disabled.
Dtk_bool get_tesselationSuppressDuplicateFace();
 
//DTK_TOREMOVE_START
#ifdef AF51BDA7E49648f8AB95949F4CA52EF8
void tess_set_ErCorde(double tol);
void tess_set_Discretisation(double tol);
#endif
//DTK_TOREMOVE_END
 
//! \brief Set automatic surface spring check option. If enabled, all periodic surface will be tesselated more accurately using set_TesselateSurfaceMethod(1).
//! Manual activation of set_TesselateSurfaceMethod(1) is not necessary anymore because of this option.
void CheckAutoSurfaceIsSpring(Dtk_bool inBval);
//! \brief Get automatic surface spring check option. Returns 1 if enabled, 0 if disabled.
Dtk_bool CheckAutoSurfaceIsSpring();
 
//! \brief Set usage of edge tolerance to guide the tesselation. Default value is disabled (0).
void CheckUseEdgeTolerance(Dtk_bool inBval);
//! \brief Get usage of edge tolerance to guide the tesselation. Returns 1 if enabled, 0 if disabled.
Dtk_bool CheckUseEdgeTolerance();
 
//! \brief Set additional verification of face/boundaries before tesselation. Default false (0).
void Dtk_SetMailleFacesVerif(int bval);
//! \brief Get status of additional verification of face/boundaries before tesselation. Returns 1 if enabled, 0 if disabled.
int Dtk_GetMailleFacesVerif();
 
//! @}
 
class FaceBoundariesToPolylines
{
private :
     Dtk_tab<Dtk_PolylinePtr> outerpln;
     Dtk_tab<Dtk_tab<Dtk_PolylinePtr> > innerpln;
     Dtk_ErrorStatus status;
 
public :
     FaceBoundariesToPolylines();
     ~FaceBoundariesToPolylines();
     Dtk_ErrorStatus Create( Dtk_FacePtr &inFace,const double inTolBound);
     void Delete();
     Dtk_ErrorStatus Get_outer(Dtk_tab<Dtk_PolylinePtr> &outpln);
     Dtk_Size_t Get_Nbinner() { return(innerpln.size()) ;};
     Dtk_ErrorStatus Get_inner(Dtk_tab<Dtk_PolylinePtr> &outpln,Dtk_Size_t number);
     Dtk_ErrorStatus CheckStatus() { return (status); };
};
 
struct Dtk_OrientedFaceStr
{
     Dtk_FacePtr _face;
     Dtk_bool _orientation;
};
 
 
 
//////////////////////////////////////////////////////////////////////////////
// Deprecated
 
Dtk_ErrorStatus tess_FacesArrayToMesh(Dtk_tab<Dtk_OrientedFaceStr> &inTabFace, Dtk_MeshPtr &outMesh, Dtk_Int32 *outIsSolid);
Dtk_ErrorStatus tess_FaceToMesh(Dtk_OrientedFaceStr &inTabFace, Dtk_MeshPtr &outMesh);
 
void get_tesselation_activateSplitMode(int &outmode, double &outratio);
void set_tesselation_activateSplitMode(const int inmode, const double inratio);
void set_activationSplitModeFromConfig();
void reinit_SplitMode();
Dtk_ErrorStatus tess_TesselateFeature_to_dtk_mesh(Dtk_FeaturePtr &feat, Dtk_MeshPtr &outMesh);
int init_stl_write(Dtk_string sfic);
int write_mesh_solid(const Dtk_MeshPtr &tm);
int end_stl_fic(int *ient);
 
SetAsDeprecated("2026.1", "Use tess_InitTesselation() instead.")
//! \deprecated Use tess_InitTesselation() instead
extern int tess_InitLocalTess();
 
 
SetAsDeprecated("2026.1", "Use tess_FaceToMesh or tess_FacesArrayToMesh instead.")
//! \deprecated Use tess_FaceToMesh or tess_FacesArrayToMesh instead
extern Dtk_ErrorStatus tess_AddFace(Dtk_FacePtr &inFace);
 
 
SetAsDeprecated("2026.1", "Use tess_FaceToMesh or tess_FacesArrayToMesh instead.")
//! \deprecated Use tess_AddFace instead
extern Dtk_ErrorStatus tess_AddFace(Dtk_OrientedFaceStr &inFace);
 
SetAsDeprecated("2026.1", "Use tess_FacesArrayToMesh instead.")
//! \deprecated Use tess_FacesArrayToMesh instead
extern int tess_TesselateMemo(Dtk_MeshPtr &outMesh, int *outIsSolid);
 
SetAsDeprecated("2026.1", "Manual activation not needed/supported anymore, see CheckAutoSurfaceIsSpring(). If set_TesselateSurfaceMethod(0), remove this call. If set_TesselateSurfaceMethod(1), replace it by CheckAutoSurfaceIsSpring(DTK_TRUE), or lower the linear and/or angular tol to keep exactly the same results.")
//! \deprecated Manual activation not needed/supported anymore see CheckAutoSurfaceIsSpring()
void set_TesselateSurfaceMethod(int ival);
 
SetAsDeprecated("2026.1", "Manual activation not supported anymore.")
//! \deprecated Manual activation not supported anymore
int get_TesselateSurfaceMethod();
 
SetAsDeprecated( "2026.1", "Use tess_getBoundariesFromMeshFace( const Dtk_MeshPtr&, const Dtk_mesh_face *, Dtk_tab<Dtk_tab<Dtk_PolylinePtr>> &) instead" )
//! \deprecated Use tess_getBoundariesFromMeshFace instead
void tess_getBoundariesFromMeshFace(const Dtk_MeshPtr &mesh, const Dtk_mesh_face  *inFace, Dtk_tab<Dtk_tab<Dtk_MeshPolylinePtr> > &outBoundaries);
 
#endif