# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from smesh import Mesh_Algorithm, AssureGeomPublished
+##
+# @package BLSURFPluginDC
+# Python API for the BLSURF meshing plug-in module.
+
+from smesh_algorithm import Mesh_Algorithm
+from smesh import AssureGeomPublished
# Topology treatment way of BLSURF
FromCAD, PreProcess, PreProcessPlus, PreCAD = 0,1,2,3
noBLSURFPlugin = 1
pass
+#----------------------------
+# Mesh algo type identifiers
+#----------------------------
-
-# a constant to call Mesh.Triangle(BLSURF,geom=0)
+## Algorithm type: BLSurf triangle 2D algorithm, see BLSURF_Algorithm
BLSURF = "BLSURF"
-## BLSURF 2D algorithm. It is created by calling Mesh.Triangle(BLSURF,geom=0)
+#----------------------
+# Algorithms
+#----------------------
+
+## BLSurf 2D algorithm.
+#
+# It can be created by calling smesh.Mesh.Triangle(smesh.BLSURF,geom=0)
#
class BLSURF_Algorithm(Mesh_Algorithm):
+ ## name of the dynamic method in smesh.Mesh class
+ # @internal
meshMethod = "Triangle"
+ ## type of algorithm used with helper function in smesh.Mesh class
+ # @internal
algoType = BLSURF
+ ## doc string of the method
+ # @internal
+ docHelper = "Creates triangle 2D algorithm for faces"
_angleMeshS = 8
_gradation = 1.1
## Private constructor.
+ # @param mesh parent mesh object algorithm is assigned to
+ # @param geom geometry (shape/sub-shape) algorithm is assigned to;
+ # if it is @c 0 (default), the algorithm is assigned to the main shape
def __init__(self, mesh, geom=0):
Mesh_Algorithm.__init__(self)
if noBLSURFPlugin:
self.Create(mesh, geom, BLSURF, "libBLSURFEngine.so")
self.params=None
#self.SetPhysicalMesh() - PAL19680
+ pass
## Sets a way to define size of mesh elements to generate.
# @param thePhysicalMesh is: DefaultSize, BLSURF_Custom or SizeMap.
def SetPhysicalMesh(self, thePhysicalMesh=DefaultSize):
self.Parameters().SetPhysicalMesh(thePhysicalMesh)
+ pass
## Sets size of mesh elements to generate.
+ # @param theVal value of mesh element size
def SetPhySize(self, theVal):
self.Parameters().SetPhySize(theVal)
+ pass
## Sets lower boundary of mesh element size (PhySize).
+ # @param theVal value of mesh element minimal size
def SetPhyMin(self, theVal=-1):
self.Parameters().SetPhyMin(theVal)
+ pass
## Sets upper boundary of mesh element size (PhySize).
+ # @param theVal value of mesh element maximal size
def SetPhyMax(self, theVal=-1):
self.Parameters().SetPhyMax(theVal)
+ pass
## Sets a way to define maximum angular deflection of mesh from CAD model.
# @param theGeometricMesh is: 0 (None) or 1 (Custom)
def SetGeometricMesh(self, theGeometricMesh=0):
if self.Parameters().GetPhysicalMesh() == 0: theGeometricMesh = 1
self.Parameters().SetGeometricMesh(theGeometricMesh)
+ pass
## Sets angular deflection (in degrees) of a mesh face from CAD surface.
+ # @param theVal value of angular deflection for mesh face
def SetAngleMeshS(self, theVal=_angleMeshS):
if self.Parameters().GetGeometricMesh() == 0: theVal = self._angleMeshS
self.Parameters().SetAngleMeshS(theVal)
+ pass
## Sets angular deflection (in degrees) of a mesh edge from CAD curve.
+ # @param theVal value of angular deflection for mesh edge
def SetAngleMeshC(self, theVal=_angleMeshS):
if self.Parameters().GetGeometricMesh() == 0: theVal = self._angleMeshS
self.Parameters().SetAngleMeshC(theVal)
+ pass
## Sets lower boundary of mesh element size computed to respect angular deflection.
+ # @param theVal value of mesh element minimal size
def SetGeoMin(self, theVal=-1):
self.Parameters().SetGeoMin(theVal)
+ pass
## Sets upper boundary of mesh element size computed to respect angular deflection.
+ # @param theVal value of mesh element maximal size
def SetGeoMax(self, theVal=-1):
self.Parameters().SetGeoMax(theVal)
+ pass
## Sets maximal allowed ratio between the lengths of two adjacent edges.
+ # @param theVal value of maximal length ratio
def SetGradation(self, theVal=_gradation):
if self.Parameters().GetGeometricMesh() == 0: theVal = self._gradation
self.Parameters().SetGradation(theVal)
+ pass
## Sets topology usage way.
- # @param way defines how mesh conformity is assured <ul>
- # <li>FromCAD - mesh conformity is assured by conformity of a shape</li>
- # <li>PreProcess or PreProcessPlus - by pre-processing a CAD model</li>
- # <li>PreCAD - by pre-processing with PreCAD a CAD model</li></ul>
+ # @param way defines how mesh conformity is assured
+ # - FromCAD - mesh conformity is assured by conformity of a shape
+ # - PreProcess or PreProcessPlus - by pre-processing a CAD model
+ # - PreCAD - by pre-processing with PreCAD a CAD model
def SetTopology(self, way):
self.Parameters().SetTopology(way)
+ pass
## To respect geometrical edges or not.
+ # @param toIgnoreEdges "ignore edges" flag value
def SetDecimesh(self, toIgnoreEdges=False):
self.Parameters().SetDecimesh(toIgnoreEdges)
+ pass
## Sets verbosity level in the range 0 to 100.
+ # @param level verbosity level
def SetVerbosity(self, level):
self.Parameters().SetVerbosity(level)
+ pass
## To optimize merges edges.
+ # @param toMergeEdges "merge edges" flag value
def SetPreCADMergeEdges(self, toMergeEdges=False):
self.Parameters().SetPreCADMergeEdges(toMergeEdges)
+ pass
## To remove nano edges.
+ # @param toRemoveNanoEdges "remove nano edges" flag value
def SetPreCADRemoveNanoEdges(self, toRemoveNanoEdges=False):
self.Parameters().SetPreCADRemoveNanoEdges(toRemoveNanoEdges)
+ pass
## To compute topology from scratch
+ # @param toDiscardInput "discard input" flag value
def SetPreCADDiscardInput(self, toDiscardInput=False):
self.Parameters().SetPreCADDiscardInput(toDiscardInput)
+ pass
## Sets the length below which an edge is considered as nano
# for the topology processing.
+ # @param epsNano nano edge length threshold value
def SetPreCADEpsNano(self, epsNano):
self.Parameters().SetPreCADEpsNano(epsNano)
+ pass
## Sets advanced option value.
+ # @param optionName advanced option name
+ # @param level advanced option value
def SetOptionValue(self, optionName, level):
self.Parameters().SetOptionValue(optionName,level)
+ pass
## Sets advanced PreCAD option value.
- # Keyword arguments:
- # optionName: name of the option
- # optionValue: value of the option
+ # @param optionName name of the option
+ # @param optionValue value of the option
def SetPreCADOptionValue(self, optionName, optionValue):
self.Parameters().SetPreCADOptionValue(optionName,optionValue)
+ pass
## Sets GMF file for export at computation
+ # @param fileName GMF file name
def SetGMFFile(self, fileName):
self.Parameters().SetGMFFile(fileName)
+ pass
- ## Enforced vertices (BLSURF)
+ #-----------------------------------------
+ # Enforced vertices (BLSURF)
+ #-----------------------------------------
## To get all the enforced vertices
def GetAllEnforcedVertices(self):
return self.Parameters().SetEnforcedVertex(theFace, x, y, z)
else:
return self.Parameters().SetEnforcedVertexWithGroup(theFace, x, y, z, groupName)
+ pass
else:
if groupName == "":
return self.Parameters().SetEnforcedVertexNamed(theFace, x, y, z, vertexName)
else:
return self.Parameters().SetEnforcedVertexNamedWithGroup(theFace, x, y, z, vertexName, groupName)
+ pass
+ pass
## To set an enforced vertex on a face (or group, compound) given a GEOM vertex, group or compound.
# @param theFace : GEOM face (or group, compound) on which to define an enforced vertex
return self.Parameters().SetEnforcedVertexGeom(theFace, theVertex)
else:
return self.Parameters().SetEnforcedVertexGeomWithGroup(theFace, theVertex,groupName)
+ pass
## To remove an enforced vertex on a given GEOM face (or group, compound) given the coordinates.
# @param theFace : GEOM face (or group, compound) on which to remove the enforced vertex
def GetInternalEnforcedVertexAllFacesGroup(self):
return self.Parameters().GetInternalEnforcedVertexAllFacesGroup()
- ## Attractors
+ #-----------------------------------------
+ # Attractors
+ #-----------------------------------------
## Sets an attractor on the chosen face. The mesh size will decrease exponentially with the distance from theAttractor, following the rule h(d) = theEndSize - (theEndSize - theStartSize) * exp [ - ( d / theInfluenceDistance ) ^ 2 ]
# @param theFace : face on which the attractor will be defined
AssureGeomPublished( self.mesh, theFace )
AssureGeomPublished( self.mesh, theAttractor )
self.Parameters().SetAttractorGeom(theFace, theAttractor, theStartSize, theEndSize, theInfluenceDistance, theConstantSizeDistance)
+ pass
## Unsets an attractor on the chosen face.
# @param theFace : face on which the attractor has to be removed
def UnsetAttractorGeom(self, theFace):
AssureGeomPublished( self.mesh, theFace )
self.Parameters().SetAttractorGeom(theFace)
+ pass
- ## Size maps (BLSURF)
+ #-----------------------------------------
+ # Size maps (BLSURF)
+ #-----------------------------------------
## To set a size map on a face, edge or vertex (or group, compound) given Python function.
# If theObject is a face, the function can be: def f(u,v): return u+v
def SetSizeMap(self, theObject, theSizeMap):
AssureGeomPublished( self.mesh, theObject )
self.Parameters().SetSizeMap(theObject, theSizeMap)
+ pass
## To remove a size map defined on a face, edge or vertex (or group, compound)
# @param theObject : GEOM face, edge or vertex (or group, compound) on which to define a size map
def UnsetSizeMap(self, theObject):
AssureGeomPublished( self.mesh, theObject )
self.Parameters().UnsetSizeMap(theObject)
+ pass
## To remove all the size maps
def ClearSizeMaps(self):
self.Parameters().ClearSizeMaps()
+ pass
## Sets QuadAllowed flag.
+ # @param toAllow "allow quadrangles" flag value
def SetQuadAllowed(self, toAllow=True):
self.Parameters().SetQuadAllowed(toAllow)
+ pass
## Defines hypothesis having several parameters
- #
+ # @return hypothesis object
def Parameters(self):
if not self.params:
self.params = self.Hypothesis("BLSURF_Parameters", [],
"libBLSURFEngine.so", UseExisting=0)
+ pass
return self.params
+
+ pass # end of BLSURF_Algorithm class
bool * use_precad
)
{
+ // rnc : Bug 1457
+ // Clear map so that it is not stored in the algorithm with old enforced vertices in it
+ EnfVertexCoords2EnfVertexList.clear();
+
int _topology = BLSURFPlugin_Hypothesis::GetDefaultTopology();
int _physicalMesh = BLSURFPlugin_Hypothesis::GetDefaultPhysicalMesh();
double _phySize = BLSURFPlugin_Hypothesis::GetDefaultPhySize();
TopExp_Explorer exp (GeomShape, TopAbs_FACE);
for (; exp.More(); exp.Next()){
MESSAGE("Iterating shapes. Shape type is " << exp.Current().ShapeType());
- TopExp_Explorer exp_face (exp.Current(), TopAbs_VERTEX);
+ TopExp_Explorer exp_face (exp.Current(), TopAbs_VERTEX, TopAbs_EDGE);
for (; exp_face.More(); exp_face.Next())
{
// Get coords of vertex
enfVertex->faceEntries.clear();
enfVertex->geomEntry = "";
enfVertex->grpName = grpName;
+ enfVertex->vertex = TopoDS::Vertex( exp_face.Current() );
_createEnforcedVertexOnFace( TopoDS::Face(exp.Current()), aPnt, enfVertex);
HasSizeMapOnFace = true;
}
helper.SetIsQuadratic( haveQudraticSubMesh );
bool needMerge = false;
set< SMESH_subMesh* > edgeSubmeshes;
+ set< SMESH_subMesh* >& mergeSubmeshes = edgeSubmeshes;
/* Now fill the CAD object with data from your CAD
* environement. This is the most complex part of a successfull
gp_Pnt P(xyzCoords[0],xyzCoords[1],xyzCoords[2]);
BRepClass_FaceClassifier scl(f,P,1e-7);
// scl.Perform() is bugged. The function was rewritten
-// scl.Perform();
- BRepClass_FaceClassifierPerform(&scl,f,P,1e-7);
+ // BRepClass_FaceClassifierPerform(&scl,f,P,1e-7);
+ // OCC 6.5.2: scl.Perform() is not bugged anymore
+ scl.Perform(f, P, 1e-7);
TopAbs_State result = scl.State();
MESSAGE("Position of point on face: "<<result);
if ( result == TopAbs_OUT )
ienf++;
MESSAGE("Add cad point on (u,v)=(" << uvCoords[0] << "," << uvCoords[1] << ") with id = " << ienf);
cad_point_t* point_p = cad_point_new(fce, ienf, uvCoords);
- cad_point_set_tag(point_p, ienf);
+ int tag = 0;
+ std::map< BLSURFPlugin_Hypothesis::TEnfVertexCoords, BLSURFPlugin_Hypothesis::TEnfVertexList >::const_iterator enfCoordsIt = EnfVertexCoords2EnfVertexList.find(xyzCoords);
+ if (enfCoordsIt != EnfVertexCoords2EnfVertexList.end() &&
+ !enfCoordsIt->second.empty() )
+ {
+ TopoDS_Vertex v = (*enfCoordsIt->second.begin())->vertex;
+ if ( v.IsNull() ) v = (*enfCoordsIt->second.rbegin())->vertex;
+ if ( !v.IsNull() ) {
+ tag = pmap.Add( v );
+ mergeSubmeshes.insert( aMesh.GetSubMesh( v ));
+ //if ( tag != pmap.Extent() )
+ needMerge = true;
+ }
+ }
+ if ( tag == 0 ) tag = ienf;
+ cad_point_set_tag(point_p, tag);
}
}
FaceId2EnforcedVertexCoords.erase(faceKey);
};
}
- // SetIsAlwaysComputed( true ) to sub-meshes of degenerated EDGEs
+ // SetIsAlwaysComputed( true ) to sub-meshes of EDGEs w/o mesh
TopLoc_Location loc; double f,l;
for (int i = 1; i <= emap.Extent(); i++)
- if ( BRep_Tool::Curve(TopoDS::Edge( emap( i )), loc, f,l).IsNull() )
- if ( SMESH_subMesh* sm = aMesh.GetSubMeshContaining( emap( i )))
- sm->SetIsAlwaysComputed( true );
+ if ( SMESH_subMesh* sm = aMesh.GetSubMeshContaining( emap( i )))
+ sm->SetIsAlwaysComputed( true );
for (int i = 1; i <= pmap.Extent(); i++)
if ( SMESH_subMesh* sm = aMesh.GetSubMeshContaining( pmap( i )))
if ( !sm->IsMeshComputed() )
if ( needMerge )
{
- set< SMESH_subMesh* >::iterator smIt = edgeSubmeshes.begin();
- for ( ; smIt != edgeSubmeshes.end(); ++smIt )
+ set< SMESH_subMesh* >::iterator smIt = mergeSubmeshes.begin();
+ for ( ; smIt != mergeSubmeshes.end(); ++smIt )
{
SMESH_subMesh* sm = *smIt;
SMESH_subMeshIteratorPtr subsmIt = sm->getDependsOnIterator( /*includeSelf=*/true,
//_angleMeshS = hyp->GetAngleMeshS();
_angleMeshC = _hypothesis->GetAngleMeshC();
_quadAllowed = _hypothesis->GetQuadAllowed();
+ } else {
+ //0020968: EDF1545 SMESH: Problem in the creation of a mesh group on geometry
+ // GetDefaultPhySize() sometimes leads to computation failure
+ _phySize = aMesh.GetShapeDiagonalSize() / _gen->GetBoundaryBoxSegmentation();
+ MESSAGE("BLSURFPlugin_BLSURF::SetParameters using defaults");
}
bool IsQuadratic = false;
