#include "SMESH_Gen.hxx"
#include "SMESH_Hypothesis.hxx"
#include "SMESH_Group.hxx"
+#include "SMESH_HypoFilter.hxx"
#include "SMESHDS_Group.hxx"
#include "SMESHDS_Script.hxx"
+#include "SMESHDS_GroupOnGeom.hxx"
#include "SMDS_MeshVolume.hxx"
#include "utilities.h"
#include <TopTools_ListOfShape.hxx>
#include <TopTools_Array1OfShape.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
+#include <TopTools_MapOfShape.hxx>
#include <memory>
*/
//=============================================================================
-void SMESH_Mesh::ShapeToMesh(const TopoDS_Shape & aShape){
+void SMESH_Mesh::ShapeToMesh(const TopoDS_Shape & aShape)
+{
if(MYDEBUG) MESSAGE("SMESH_Mesh::ShapeToMesh");
- if (_isShapeToMesh)
- throw
- SALOME_Exception(LOCALIZED
- ("a shape to mesh as already been defined"));
+
+ if ( !_myMeshDS->ShapeToMesh().IsNull() && aShape.IsNull() )
+ {
+ // removal of a shape to mesh, delete objects referring to sub-shapes:
+ // - sub-meshes
+ map <int, SMESH_subMesh *>::iterator i_sm = _mapSubMesh.begin();
+ for ( ; i_sm != _mapSubMesh.end(); ++i_sm )
+ delete i_sm->second;
+ _mapSubMesh.clear();
+ // - groups on geometry
+ map <int, SMESH_Group *>::iterator i_gr = _mapGroup.begin();
+ while ( i_gr != _mapGroup.end() ) {
+ if ( dynamic_cast<SMESHDS_GroupOnGeom*>( i_gr->second->GetGroupDS() )) {
+ _myMeshDS->RemoveGroup( i_gr->second->GetGroupDS() );
+ delete i_gr->second;
+ _mapGroup.erase( i_gr++ );
+ }
+ else
+ i_gr++;
+ }
+ _mapPropagationChains.Clear();
+ }
+ else
+ {
+ if (_isShapeToMesh)
+ throw SALOME_Exception(LOCALIZED ("a shape to mesh has already been defined"));
+ }
_isShapeToMesh = true;
_myMeshDS->ShapeToMesh(aShape);
-
+
+ // fill _mapAncestors
+ _mapAncestors.Clear();
+ int desType, ancType;
+ for ( desType = TopAbs_EDGE; desType > TopAbs_COMPOUND; desType-- )
+ for ( ancType = desType - 1; ancType >= TopAbs_COMPOUND; ancType-- )
+ TopExp::MapShapesAndAncestors ( aShape,
+ (TopAbs_ShapeEnum) desType,
+ (TopAbs_ShapeEnum) ancType,
+ _mapAncestors );
+
// NRI : 24/02/03
//EAP: 1/9/04 TopExp::MapShapes(aShape, _subShapes); USE the same map of _myMeshDS
}
{
if(MYDEBUG) MESSAGE("UNVToMesh - theFileName = "<<theFileName);
if(_isShapeToMesh)
- throw SALOME_Exception(LOCALIZED("a shape to mesh as already been defined"));
+ throw SALOME_Exception(LOCALIZED("a shape to mesh has already been defined"));
_isShapeToMesh = true;
DriverUNV_R_SMDS_Mesh myReader;
myReader.SetMesh(_myMeshDS);
{
if(MYDEBUG) MESSAGE("MEDToMesh - theFileName = "<<theFileName<<", mesh name = "<<theMeshName);
if(_isShapeToMesh)
- throw SALOME_Exception(LOCALIZED("a shape to mesh as already been defined"));
+ throw SALOME_Exception(LOCALIZED("a shape to mesh has already been defined"));
_isShapeToMesh = true;
DriverMED_R_SMESHDS_Mesh myReader;
myReader.SetMesh(_myMeshDS);
{
if(MYDEBUG) MESSAGE("UNVToMesh - theFileName = "<<theFileName);
if(_isShapeToMesh)
- throw SALOME_Exception(LOCALIZED("a shape to mesh as already been defined"));
+ throw SALOME_Exception(LOCALIZED("a shape to mesh has already been defined"));
_isShapeToMesh = true;
DriverSTL_R_SMDS_Mesh myReader;
myReader.SetMesh(_myMeshDS);
return _myMeshDS->GetHypothesis(aSubShape);
}
+//=======================================================================
+//function : GetHypothesis
+//purpose :
+//=======================================================================
+
+const SMESH_Hypothesis * SMESH_Mesh::GetHypothesis(const TopoDS_Shape & aSubShape,
+ const SMESH_HypoFilter& aFilter,
+ const bool andAncestors) const
+{
+ {
+ const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(aSubShape);
+ list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
+ for ( ; hyp != hypList.end(); hyp++ ) {
+ const SMESH_Hypothesis * h = static_cast<const SMESH_Hypothesis*>( *hyp );
+ if ( aFilter.IsOk( h, aSubShape))
+ return h;
+ }
+ }
+ if ( andAncestors )
+ {
+ TopTools_ListIteratorOfListOfShape it( GetAncestors( aSubShape ));
+ for (; it.More(); it.Next() )
+ {
+ const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(it.Value());
+ list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
+ for ( ; hyp != hypList.end(); hyp++ ) {
+ const SMESH_Hypothesis * h = static_cast<const SMESH_Hypothesis*>( *hyp );
+ if (aFilter.IsOk( h, it.Value() ))
+ return h;
+ }
+ }
+ }
+ return 0;
+}
+
+//=======================================================================
+//function : GetHypotheses
+//purpose :
+//=======================================================================
+
+bool SMESH_Mesh::GetHypotheses(const TopoDS_Shape & aSubShape,
+ const SMESH_HypoFilter& aFilter,
+ list <const SMESHDS_Hypothesis * >& aHypList,
+ const bool andAncestors) const
+{
+ int nbHyp = 0;
+ {
+ const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(aSubShape);
+ list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
+ for ( ; hyp != hypList.end(); hyp++ )
+ if ( aFilter.IsOk (static_cast<const SMESH_Hypothesis*>( *hyp ), aSubShape)) {
+ aHypList.push_back( *hyp );
+ nbHyp++;
+ }
+ }
+ // get hypos from shape of one type only: if any hypo is found on edge, do
+ // not look up on faces
+ if ( !nbHyp && andAncestors )
+ {
+ TopTools_MapOfShape map;
+ TopTools_ListIteratorOfListOfShape it( GetAncestors( aSubShape ));
+ int shapeType = it.More() ? it.Value().ShapeType() : TopAbs_SHAPE;
+ for (; it.More(); it.Next() )
+ {
+ if ( nbHyp && shapeType != it.Value().ShapeType() )
+ break;
+ shapeType = it.Value().ShapeType();
+ if ( !map.Add( it.Value() ))
+ continue;
+ const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(it.Value());
+ list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
+ for ( ; hyp != hypList.end(); hyp++ )
+ if (aFilter.IsOk( static_cast<const SMESH_Hypothesis*>( *hyp ), it.Value() )) {
+ aHypList.push_back( *hyp );
+ nbHyp++;
+ }
+ }
+ }
+ return nbHyp;
+}
+
//=============================================================================
/*!
*
bool SMESH_Mesh::IsUsedHypothesis(SMESHDS_Hypothesis * anHyp,
const TopoDS_Shape & aSubShape)
{
+ SMESH_Hypothesis* hyp = static_cast<SMESH_Hypothesis*>(anHyp);
// check if anHyp is applicable to aSubShape
SMESH_subMesh * subMesh = GetSubMeshContaining( aSubShape );
- if (!subMesh ||
- !subMesh->IsApplicableHypotesis(static_cast<SMESH_Hypothesis*>(anHyp)))
+ if ( !subMesh || !subMesh->IsApplicableHypotesis( hyp ))
return false;
SMESH_Algo *algo = _gen->GetAlgo(*this, aSubShape);
// look trough hypotheses used by algo
const list <const SMESHDS_Hypothesis * >&usedHyps =
algo->GetUsedHypothesis(*this, aSubShape);
- list <const SMESHDS_Hypothesis * >::const_iterator itl;
- for (itl = usedHyps.begin(); itl != usedHyps.end(); itl++)
- if (anHyp == (*itl))
- return true;
+ return ( find( usedHyps.begin(), usedHyps.end(), anHyp ) != usedHyps.end() );
}
- else
- {
- // look through all assigned hypotheses
- {
- const list <const SMESHDS_Hypothesis * >&usedHyps =
- _myMeshDS->GetHypothesis( aSubShape );
- list <const SMESHDS_Hypothesis * >::const_iterator itl;
- for (itl = usedHyps.begin(); itl != usedHyps.end(); itl++)
- if (anHyp == (*itl))
- return true;
- }
- // on ancestors
- TopTools_ListIteratorOfListOfShape it( GetAncestors( aSubShape ));
- for (; it.More(); it.Next())
- {
- const list <const SMESHDS_Hypothesis * >&usedHyps =
- _myMeshDS->GetHypothesis( aSubShape );
- list <const SMESHDS_Hypothesis * >::const_iterator itl;
- for (itl = usedHyps.begin(); itl != usedHyps.end(); itl++)
- if (anHyp == (*itl))
- return true;
- }
- }
-
- return false;
+ // look through all assigned hypotheses
+ SMESH_HypoFilter filter( SMESH_HypoFilter::Is( hyp ));
+ return GetHypothesis( aSubShape, filter, true );
}
*/
//=============================================================================
-void SMESH_Mesh::ExportMED(const char *file, const char* theMeshName, bool theAutoGroups) throw(SALOME_Exception)
+void SMESH_Mesh::ExportMED(const char *file,
+ const char* theMeshName,
+ bool theAutoGroups,
+ int theVersion)
+ throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
DriverMED_W_SMESHDS_Mesh myWriter;
- myWriter.SetFile ( file );
+ myWriter.SetFile ( file, MED::EVersion(theVersion) );
myWriter.SetMesh ( _myMeshDS );
if ( !theMeshName )
myWriter.SetMeshId ( _idDoc );
{
if(MYDEBUG) MESSAGE("SMESH_Mesh::IsNotConformAllowed");
- const list<const SMESHDS_Hypothesis*>& listHyp =
- _myMeshDS->GetHypothesis( _myMeshDS->ShapeToMesh() );
- list<const SMESHDS_Hypothesis*>::const_iterator it=listHyp.begin();
- while (it!=listHyp.end())
- {
- const SMESHDS_Hypothesis *aHyp = *it;
- string hypName = aHyp->GetName();
- if ( hypName == "NotConformAllowed" )
- return true;
- it++;
- }
- return false;
+ SMESH_HypoFilter filter( SMESH_HypoFilter::HasName( "NotConformAllowed" ));
+ return GetHypothesis( _myMeshDS->ShapeToMesh(), filter, false );
}
//=======================================================================
if (_mapGroup.find(theGroupID) == _mapGroup.end())
return;
GetMeshDS()->RemoveGroup( _mapGroup[theGroupID]->GetGroupDS() );
- _mapGroup.erase (theGroupID);
delete _mapGroup[theGroupID];
+ _mapGroup.erase (theGroupID);
}
//=============================================================================
/*!
* IsLocal1DHypothesis
- * Check, if there is 1D hypothesis assigned directly on <theEdge>
+ * Returns a local 1D hypothesis used for theEdge
*/
//=============================================================================
-bool SMESH_Mesh::IsLocal1DHypothesis (const TopoDS_Shape& theEdge)
+const SMESH_Hypothesis* SMESH_Mesh::IsLocal1DHypothesis (const TopoDS_Shape& theEdge)
{
- const SMESHDS_Mesh* meshDS = GetMeshDS();
- const list<const SMESHDS_Hypothesis*>& listHyp = meshDS->GetHypothesis(theEdge);
- list<const SMESHDS_Hypothesis*>::const_iterator it = listHyp.begin();
-
- for (; it != listHyp.end(); it++) {
- const SMESH_Hypothesis * aHyp = static_cast<const SMESH_Hypothesis*>(*it);
- if (aHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO &&
- aHyp->GetDim() == 1) { // 1D Hypothesis found
- return true;
- }
- }
- return false;
+ SMESH_HypoFilter filter( SMESH_HypoFilter::HasDim( 1 ));
+ filter.AndNot( SMESH_HypoFilter::IsAlgo() );
+ filter.AndNot( SMESH_HypoFilter::IsGlobal( GetMeshDS()->ShapeToMesh() ));
+
+ return GetHypothesis( theEdge, filter, true );
}
//=============================================================================
return false;
}
+//=============================================================================
+/*!
+ * IsReversedInChain
+ */
+//=============================================================================
+
+bool SMESH_Mesh::IsReversedInChain (const TopoDS_Shape& theEdge,
+ const TopoDS_Shape& theMainEdge)
+{
+ if ( !theMainEdge.IsNull() && !theEdge.IsNull() &&
+ _mapPropagationChains.Contains( theMainEdge ))
+ {
+ const TopTools_IndexedMapOfShape& aChain =
+ _mapPropagationChains.FindFromKey( theMainEdge );
+ int index = aChain.FindIndex( theEdge );
+ if ( index )
+ return aChain(index).Orientation() == TopAbs_REVERSED;
+ }
+ return false;
+}
//=============================================================================
/*!
// Remove the chain from the map
int i = _mapPropagationChains.FindIndex(theMainEdge);
- TopoDS_Vertex anEmptyShape;
- BRep_Builder BB;
- BB.MakeVertex(anEmptyShape, gp_Pnt(0,0,0), 0.1);
- TopTools_IndexedMapOfShape anEmptyMap;
- _mapPropagationChains.Substitute(i, anEmptyShape, anEmptyMap);
+ if ( i == _mapPropagationChains.Extent() )
+ _mapPropagationChains.RemoveLast();
+ else {
+ TopoDS_Vertex anEmptyShape;
+ BRep_Builder BB;
+ BB.MakeVertex(anEmptyShape, gp_Pnt(0,0,0), 0.1);
+ TopTools_IndexedMapOfShape anEmptyMap;
+ _mapPropagationChains.Substitute(i, anEmptyShape, anEmptyMap);
+ }
return true;
}
}
// Check presence of 1D hypothesis to be propagated
- if (!IsLocal1DHypothesis(theMainEdge)) {
+ const SMESH_Hypothesis* aMainHyp = IsLocal1DHypothesis(theMainEdge);
+ if (!aMainHyp) {
MESSAGE("Warning: There is no 1D hypothesis to propagate. Please, assign.");
return true;
}
// List of edges, added to chain on the previous cycle pass
TopTools_ListOfShape listPrevEdges;
- listPrevEdges.Append(theMainEdge);
+ listPrevEdges.Append(theMainEdge.Oriented( TopAbs_FORWARD ));
// 5____4____3____4____5____6
// | | | | | |
if (!_mapAncestors.Contains(anEdges(nb))) {
MESSAGE("WIRE EXPLORER HAVE GIVEN AN INVALID EDGE !!!");
break;
- } else {
- int ind = _mapAncestors.FindIndex(anEdges(nb));
- anEdges(nb) = _mapAncestors.FindKey(ind);
}
if (anEdges(nb).IsSame(anE)) found = nb;
}
if (opp > 4) opp -= 4;
anOppE = anEdges(opp);
- if (!aChain.Contains(anOppE)) {
- if (!IsLocal1DHypothesis(anOppE)) {
- TopoDS_Shape aMainEdgeForOppEdge;
- if (IsPropagatedHypothesis(anOppE, aMainEdgeForOppEdge)) {
+ // add anOppE to aChain if ...
+ if (!aChain.Contains(anOppE)) { // ... anOppE is not in aChain
+ if (!IsLocal1DHypothesis(anOppE)) { // ... no other 1d hyp on anOppE
+ TopoDS_Shape aMainEdgeForOppEdge; // ... no other hyp is propagated to anOppE
+ if (!IsPropagatedHypothesis(anOppE, aMainEdgeForOppEdge))
+ {
+ // Add found edge to the chain oriented so that to
+ // have it co-directed with a forward MainEdge
+ TopAbs_Orientation ori = anE.Orientation();
+ if ( anEdges(opp).Orientation() == anEdges(found).Orientation() )
+ ori = TopAbs::Reverse( ori );
+ anOppE.Orientation( ori );
+ aChain.Add(anOppE);
+ listCurEdges.Append(anOppE);
+ }
+ else {
// Collision!
MESSAGE("Error: Collision between propagated hypotheses");
CleanMeshOnPropagationChain(theMainEdge);
aChain.Clear();
- return false;
- } else {
- // Add found edge to the chain
- aChain.Add(anOppE);
- listCurEdges.Append(anOppE);
+ return ( aMainHyp == IsLocal1DHypothesis(aMainEdgeForOppEdge) );
}
}
}
// that lower dimention shapes come first.
//=======================================================================
-const TopTools_ListOfShape& SMESH_Mesh::GetAncestors(const TopoDS_Shape& theS)
+const TopTools_ListOfShape& SMESH_Mesh::GetAncestors(const TopoDS_Shape& theS) const
{
- if ( _mapAncestors.IsEmpty() )
- {
- // fill _mapAncestors
- int desType, ancType;
- for ( desType = TopAbs_EDGE; desType > TopAbs_COMPOUND; desType-- )
- for ( ancType = desType - 1; ancType >= TopAbs_COMPOUND; ancType-- )
- TopExp::MapShapesAndAncestors (_myMeshDS->ShapeToMesh(),
- (TopAbs_ShapeEnum) desType,
- (TopAbs_ShapeEnum) ancType,
- _mapAncestors );
- }
-
if ( _mapAncestors.Contains( theS ) )
return _mapAncestors.FindFromKey( theS );
