src/SMESH/SMESH_Mesh.cxx

   1 //  SMESH SMESH : implementaion of SMESH idl descriptions
   2 //
   3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
  21 //
  22 //
  23 //
  24 //  File   : SMESH_Mesh.cxx
  25 //  Author : Paul RASCLE, EDF
  26 //  Module : SMESH
  27 //  $Header$
  28
  29 #include "SMESH_Mesh.hxx"
  30 #include "SMESH_subMesh.hxx"
  31 #include "SMESH_Gen.hxx"
  32 #include "SMESH_Hypothesis.hxx"
  33 #include "SMESH_Group.hxx"
  34 #include "SMESH_HypoFilter.hxx"
  35 #include "SMESHDS_Group.hxx"
  36 #include "SMESHDS_Script.hxx"
  37 #include "SMESHDS_GroupOnGeom.hxx"
  38 #include "SMDS_MeshVolume.hxx"
  39
  40 #include "utilities.h"
  41
  42 #include "DriverMED_W_SMESHDS_Mesh.h"
  43 #include "DriverDAT_W_SMDS_Mesh.h"
  44 #include "DriverUNV_W_SMDS_Mesh.h"
  45 #include "DriverSTL_W_SMDS_Mesh.h"
  46
  47 #include "DriverMED_R_SMESHDS_Mesh.h"
  48 #include "DriverUNV_R_SMDS_Mesh.h"
  49 #include "DriverSTL_R_SMDS_Mesh.h"
  50
  51 #include <BRepTools_WireExplorer.hxx>
  52 #include <BRep_Builder.hxx>
  53 #include <gp_Pnt.hxx>
  54
  55 #include <TCollection_AsciiString.hxx>
  56 #include <TopExp.hxx>
  57 #include <TopTools_ListOfShape.hxx>
  58 #include <TopTools_Array1OfShape.hxx>
  59 #include <TopTools_ListIteratorOfListOfShape.hxx>
  60 #include <TopTools_MapOfShape.hxx>
  61
  62 #include <memory>
  63
  64 #include "Utils_ExceptHandlers.hxx"
  65
  66 #ifdef _DEBUG_
  67 static int MYDEBUG = 0;
  68 #else
  69 static int MYDEBUG = 0;
  70 #endif
  71
  72
  73 //=============================================================================
  74 /*!
  75  *
  76  */
  77 //=============================================================================
  78
  79 SMESH_Mesh::SMESH_Mesh(int localId, int studyId, SMESH_Gen * gen, SMESHDS_Document * myDocument)
  80 : _groupId( 0 )
  81 {
  82   INFOS("SMESH_Mesh::SMESH_Mesh(int localId)");
  83         _id = localId;
  84         _studyId = studyId;
  85         _gen = gen;
  86         _myDocument = myDocument;
  87         _idDoc = _myDocument->NewMesh();
  88         _myMeshDS = _myDocument->GetMesh(_idDoc);
  89         _isShapeToMesh = false;
  90 }
  91
  92 //=============================================================================
  93 /*!
  94  *
  95  */
  96 //=============================================================================
  97
  98 SMESH_Mesh::~SMESH_Mesh()
  99 {
 100   INFOS("SMESH_Mesh::~SMESH_Mesh");
 101
 102   // delete groups
 103   map < int, SMESH_Group * >::iterator itg;
 104   for (itg = _mapGroup.begin(); itg != _mapGroup.end(); itg++) {
 105     SMESH_Group *aGroup = (*itg).second;
 106     delete aGroup;
 107   }
 108 }
 109
 110 //=============================================================================
 111 /*!
 112  *
 113  */
 114 //=============================================================================
 115
 116 void SMESH_Mesh::ShapeToMesh(const TopoDS_Shape & aShape)
 117 {
 118   if(MYDEBUG) MESSAGE("SMESH_Mesh::ShapeToMesh");
 119
 120   if ( !_myMeshDS->ShapeToMesh().IsNull() && aShape.IsNull() )
 121   {
 122     // removal of a shape to mesh, delete objects referring to sub-shapes:
 123     // - sub-meshes
 124     map <int, SMESH_subMesh *>::iterator i_sm = _mapSubMesh.begin();
 125     for ( ; i_sm != _mapSubMesh.end(); ++i_sm )
 126       delete i_sm->second;
 127     _mapSubMesh.clear();
 128     //  - groups on geometry
 129     map <int, SMESH_Group *>::iterator i_gr = _mapGroup.begin();
 130     while ( i_gr != _mapGroup.end() ) {
 131       if ( dynamic_cast<SMESHDS_GroupOnGeom*>( i_gr->second->GetGroupDS() )) {
 132         _myMeshDS->RemoveGroup( i_gr->second->GetGroupDS() );
 133         delete i_gr->second;
 134         _mapGroup.erase( i_gr++ );
 135       }
 136       else
 137         i_gr++;
 138     }
 139     _mapPropagationChains.Clear();
 140   }
 141   else
 142   {
 143     if (_isShapeToMesh)
 144       throw SALOME_Exception(LOCALIZED ("a shape to mesh has already been defined"));
 145   }
 146   _isShapeToMesh = true;
 147   _myMeshDS->ShapeToMesh(aShape);
 148
 149   // fill _mapAncestors
 150   _mapAncestors.Clear();
 151   int desType, ancType;
 152   for ( desType = TopAbs_EDGE; desType > TopAbs_COMPOUND; desType-- )
 153     for ( ancType = desType - 1; ancType >= TopAbs_COMPOUND; ancType-- )
 154       TopExp::MapShapesAndAncestors ( aShape,
 155                                      (TopAbs_ShapeEnum) desType,
 156                                      (TopAbs_ShapeEnum) ancType,
 157                                      _mapAncestors );
 158
 159   // NRI : 24/02/03
 160   //EAP: 1/9/04 TopExp::MapShapes(aShape, _subShapes); USE the same map of _myMeshDS
 161 }
 162
 163 //=======================================================================
 164 //function : UNVToMesh
 165 //purpose  :
 166 //=======================================================================
 167
 168 int SMESH_Mesh::UNVToMesh(const char* theFileName)
 169 {
 170   if(MYDEBUG) MESSAGE("UNVToMesh - theFileName = "<<theFileName);
 171   if(_isShapeToMesh)
 172     throw SALOME_Exception(LOCALIZED("a shape to mesh has already been defined"));
 173   _isShapeToMesh = true;
 174   DriverUNV_R_SMDS_Mesh myReader;
 175   myReader.SetMesh(_myMeshDS);
 176   myReader.SetFile(theFileName);
 177   myReader.SetMeshId(-1);
 178   myReader.Perform();
 179   if(MYDEBUG){
 180     MESSAGE("MEDToMesh - _myMeshDS->NbNodes() = "<<_myMeshDS->NbNodes());
 181     MESSAGE("MEDToMesh - _myMeshDS->NbEdges() = "<<_myMeshDS->NbEdges());
 182     MESSAGE("MEDToMesh - _myMeshDS->NbFaces() = "<<_myMeshDS->NbFaces());
 183     MESSAGE("MEDToMesh - _myMeshDS->NbVolumes() = "<<_myMeshDS->NbVolumes());
 184   }
 185   return 1;
 186 }
 187
 188 //=======================================================================
 189 //function : MEDToMesh
 190 //purpose  :
 191 //=======================================================================
 192
 193 int SMESH_Mesh::MEDToMesh(const char* theFileName, const char* theMeshName)
 194 {
 195   if(MYDEBUG) MESSAGE("MEDToMesh - theFileName = "<<theFileName<<", mesh name = "<<theMeshName);
 196   if(_isShapeToMesh)
 197     throw SALOME_Exception(LOCALIZED("a shape to mesh has already been defined"));
 198   _isShapeToMesh = true;
 199   DriverMED_R_SMESHDS_Mesh myReader;
 200   myReader.SetMesh(_myMeshDS);
 201   myReader.SetMeshId(-1);
 202   myReader.SetFile(theFileName);
 203   myReader.SetMeshName(theMeshName);
 204   Driver_Mesh::Status status = myReader.Perform();
 205   if(MYDEBUG){
 206     MESSAGE("MEDToMesh - _myMeshDS->NbNodes() = "<<_myMeshDS->NbNodes());
 207     MESSAGE("MEDToMesh - _myMeshDS->NbEdges() = "<<_myMeshDS->NbEdges());
 208     MESSAGE("MEDToMesh - _myMeshDS->NbFaces() = "<<_myMeshDS->NbFaces());
 209     MESSAGE("MEDToMesh - _myMeshDS->NbVolumes() = "<<_myMeshDS->NbVolumes());
 210   }
 211
 212   // Reading groups (sub-meshes are out of scope of MED import functionality)
 213   list<string> aGroupNames = myReader.GetGroupNames();
 214   if(MYDEBUG) MESSAGE("MEDToMesh - Nb groups = "<<aGroupNames.size());
 215   int anId;
 216   for ( list<string>::iterator it = aGroupNames.begin(); it != aGroupNames.end(); it++ ) {
 217     SMESH_Group* aGroup = AddGroup( SMDSAbs_All, it->c_str(), anId );
 218     if ( aGroup ) {
 219       if(MYDEBUG) MESSAGE("MEDToMesh - group added: "<<it->c_str());
 220       SMESHDS_Group* aGroupDS = dynamic_cast<SMESHDS_Group*>( aGroup->GetGroupDS() );
 221       if ( aGroupDS ) {
 222         aGroupDS->SetStoreName( it->c_str() );
 223         myReader.GetGroup( aGroupDS );
 224       }
 225     }
 226   }
 227   return (int) status;
 228 }
 229
 230 //=======================================================================
 231 //function : STLToMesh
 232 //purpose  :
 233 //=======================================================================
 234
 235 int SMESH_Mesh::STLToMesh(const char* theFileName)
 236 {
 237   if(MYDEBUG) MESSAGE("UNVToMesh - theFileName = "<<theFileName);
 238   if(_isShapeToMesh)
 239     throw SALOME_Exception(LOCALIZED("a shape to mesh has already been defined"));
 240   _isShapeToMesh = true;
 241   DriverSTL_R_SMDS_Mesh myReader;
 242   myReader.SetMesh(_myMeshDS);
 243   myReader.SetFile(theFileName);
 244   myReader.SetMeshId(-1);
 245   myReader.Perform();
 246   if(MYDEBUG){
 247     MESSAGE("MEDToMesh - _myMeshDS->NbNodes() = "<<_myMeshDS->NbNodes());
 248     MESSAGE("MEDToMesh - _myMeshDS->NbEdges() = "<<_myMeshDS->NbEdges());
 249     MESSAGE("MEDToMesh - _myMeshDS->NbFaces() = "<<_myMeshDS->NbFaces());
 250     MESSAGE("MEDToMesh - _myMeshDS->NbVolumes() = "<<_myMeshDS->NbVolumes());
 251   }
 252   return 1;
 253 }
 254
 255 //=============================================================================
 256 /*!
 257  *
 258  */
 259 //=============================================================================
 260
 261 SMESH_Hypothesis::Hypothesis_Status
 262   SMESH_Mesh::AddHypothesis(const TopoDS_Shape & aSubShape,
 263                             int                  anHypId  ) throw(SALOME_Exception)
 264 {
 265   Unexpect aCatch(SalomeException);
 266   if(MYDEBUG) MESSAGE("SMESH_Mesh::AddHypothesis");
 267
 268   SMESH_subMesh *subMesh = GetSubMesh(aSubShape);
 269   SMESHDS_SubMesh *subMeshDS = subMesh->GetSubMeshDS();
 270   if ( subMeshDS && subMeshDS->IsComplexSubmesh() )
 271   {
 272     // return the worst but not fatal state of all group memebers
 273     SMESH_Hypothesis::Hypothesis_Status aBestRet, aWorstNotFatal, ret;
 274     aBestRet = SMESH_Hypothesis::HYP_BAD_DIM;
 275     aWorstNotFatal = SMESH_Hypothesis::HYP_OK;
 276     for ( TopoDS_Iterator itS ( aSubShape ); itS.More(); itS.Next())
 277     {
 278       ret = AddHypothesis( itS.Value(), anHypId );
 279       if ( !SMESH_Hypothesis::IsStatusFatal( ret ) && ret > aWorstNotFatal )
 280         aWorstNotFatal = ret;
 281       if ( ret < aBestRet )
 282         aBestRet = ret;
 283     }
 284     if ( SMESH_Hypothesis::IsStatusFatal( aBestRet ))
 285       return aBestRet;
 286     return aWorstNotFatal;
 287   }
 288
 289   StudyContextStruct *sc = _gen->GetStudyContext(_studyId);
 290   if (sc->mapHypothesis.find(anHypId) == sc->mapHypothesis.end())
 291   {
 292     if(MYDEBUG) MESSAGE("Hypothesis ID does not give an hypothesis");
 293     if(MYDEBUG) {
 294       SCRUTE(_studyId);
 295       SCRUTE(anHypId);
 296     }
 297     throw SALOME_Exception(LOCALIZED("hypothesis does not exist"));
 298   }
 299
 300   SMESH_Hypothesis *anHyp = sc->mapHypothesis[anHypId];
 301   MESSAGE( "SMESH_Mesh::AddHypothesis " << anHyp->GetName() );
 302
 303   bool isGlobalHyp = IsMainShape( aSubShape );
 304
 305   // NotConformAllowed can be only global
 306   if ( !isGlobalHyp )
 307   {
 308     string hypName = anHyp->GetName();
 309     if ( hypName == "NotConformAllowed" )
 310     {
 311       if(MYDEBUG) MESSAGE( "Hypotesis <NotConformAllowed> can be only global" );
 312       return SMESH_Hypothesis::HYP_INCOMPATIBLE;
 313     }
 314   }
 315
 316   // shape
 317
 318   int event;
 319   if (anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO)
 320     event = SMESH_subMesh::ADD_HYP;
 321   else
 322     event = SMESH_subMesh::ADD_ALGO;
 323   SMESH_Hypothesis::Hypothesis_Status ret = subMesh->AlgoStateEngine(event, anHyp);
 324
 325   // subShapes
 326   if (!SMESH_Hypothesis::IsStatusFatal(ret) &&
 327       !subMesh->IsApplicableHypotesis( anHyp )) // is added on father
 328   {
 329     if (anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO)
 330       event = SMESH_subMesh::ADD_FATHER_HYP;
 331     else
 332       event = SMESH_subMesh::ADD_FATHER_ALGO;
 333     SMESH_Hypothesis::Hypothesis_Status ret2 =
 334       subMesh->SubMeshesAlgoStateEngine(event, anHyp);
 335     if (ret2 > ret)
 336       ret = ret2;
 337
 338     // check concurent hypotheses on ansestors
 339     if (ret < SMESH_Hypothesis::HYP_CONCURENT && !isGlobalHyp )
 340     {
 341       const map < int, SMESH_subMesh * >& smMap = subMesh->DependsOn();
 342       map < int, SMESH_subMesh * >::const_iterator smIt = smMap.begin();
 343       for ( ; smIt != smMap.end(); smIt++ ) {
 344         if ( smIt->second->IsApplicableHypotesis( anHyp )) {
 345           ret2 = smIt->second->CheckConcurentHypothesis( anHyp->GetType() );
 346           if (ret2 > ret) {
 347             ret = ret2;
 348             break;
 349           }
 350         }
 351       }
 352     }
 353   }
 354
 355   if(MYDEBUG) subMesh->DumpAlgoState(true);
 356   SCRUTE(ret);
 357   return ret;
 358 }
 359
 360 //=============================================================================
 361 /*!
 362  *
 363  */
 364 //=============================================================================
 365
 366 SMESH_Hypothesis::Hypothesis_Status
 367   SMESH_Mesh::RemoveHypothesis(const TopoDS_Shape & aSubShape,
 368                                int anHypId)throw(SALOME_Exception)
 369 {
 370   Unexpect aCatch(SalomeException);
 371   if(MYDEBUG) MESSAGE("SMESH_Mesh::RemoveHypothesis");
 372
 373   SMESH_subMesh *subMesh = GetSubMesh(aSubShape);
 374   SMESHDS_SubMesh *subMeshDS = subMesh->GetSubMeshDS();
 375   if ( subMeshDS && subMeshDS->IsComplexSubmesh() )
 376   {
 377     // return the worst but not fatal state of all group memebers
 378     SMESH_Hypothesis::Hypothesis_Status aBestRet, aWorstNotFatal, ret;
 379     aBestRet = SMESH_Hypothesis::HYP_BAD_DIM;
 380     aWorstNotFatal = SMESH_Hypothesis::HYP_OK;
 381     for ( TopoDS_Iterator itS ( aSubShape ); itS.More(); itS.Next())
 382     {
 383       ret = RemoveHypothesis( itS.Value(), anHypId );
 384       if ( !SMESH_Hypothesis::IsStatusFatal( ret ) && ret > aWorstNotFatal )
 385         aWorstNotFatal = ret;
 386       if ( ret < aBestRet )
 387         aBestRet = ret;
 388     }
 389     if ( SMESH_Hypothesis::IsStatusFatal( aBestRet ))
 390       return aBestRet;
 391     return aWorstNotFatal;
 392   }
 393
 394   StudyContextStruct *sc = _gen->GetStudyContext(_studyId);
 395   if (sc->mapHypothesis.find(anHypId) == sc->mapHypothesis.end())
 396     throw SALOME_Exception(LOCALIZED("hypothesis does not exist"));
 397
 398   SMESH_Hypothesis *anHyp = sc->mapHypothesis[anHypId];
 399   int hypType = anHyp->GetType();
 400   if(MYDEBUG) SCRUTE(hypType);
 401   int event;
 402
 403   // shape
 404
 405   if (anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO)
 406     event = SMESH_subMesh::REMOVE_HYP;
 407   else
 408     event = SMESH_subMesh::REMOVE_ALGO;
 409   SMESH_Hypothesis::Hypothesis_Status ret = subMesh->AlgoStateEngine(event, anHyp);
 410
 411   // there may appear concurrent hyps that were covered by the removed hyp
 412   if (ret < SMESH_Hypothesis::HYP_CONCURENT &&
 413       subMesh->IsApplicableHypotesis( anHyp ) &&
 414       subMesh->CheckConcurentHypothesis( anHyp->GetType() ) != SMESH_Hypothesis::HYP_OK)
 415     ret = SMESH_Hypothesis::HYP_CONCURENT;
 416
 417   // subShapes
 418   if (!SMESH_Hypothesis::IsStatusFatal(ret) &&
 419       !subMesh->IsApplicableHypotesis( anHyp )) // is removed from father
 420   {
 421     if (anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO)
 422       event = SMESH_subMesh::REMOVE_FATHER_HYP;
 423     else
 424       event = SMESH_subMesh::REMOVE_FATHER_ALGO;
 425     SMESH_Hypothesis::Hypothesis_Status ret2 =
 426       subMesh->SubMeshesAlgoStateEngine(event, anHyp);
 427     if (ret2 > ret) // more severe
 428       ret = ret2;
 429
 430     // check concurent hypotheses on ansestors
 431     if (ret < SMESH_Hypothesis::HYP_CONCURENT && !IsMainShape( aSubShape ) )
 432     {
 433       const map < int, SMESH_subMesh * >& smMap = subMesh->DependsOn();
 434       map < int, SMESH_subMesh * >::const_iterator smIt = smMap.begin();
 435       for ( ; smIt != smMap.end(); smIt++ ) {
 436         if ( smIt->second->IsApplicableHypotesis( anHyp )) {
 437           ret2 = smIt->second->CheckConcurentHypothesis( anHyp->GetType() );
 438           if (ret2 > ret) {
 439             ret = ret2;
 440             break;
 441           }
 442         }
 443       }
 444     }
 445   }
 446
 447   if(MYDEBUG) subMesh->DumpAlgoState(true);
 448   if(MYDEBUG) SCRUTE(ret);
 449   return ret;
 450 }
 451
 452 //=============================================================================
 453 /*!
 454  *
 455  */
 456 //=============================================================================
 457
 458 SMESHDS_Mesh * SMESH_Mesh::GetMeshDS()
 459 {
 460   return _myMeshDS;
 461 }
 462
 463 //=============================================================================
 464 /*!
 465  *
 466  */
 467 //=============================================================================
 468
 469 const list<const SMESHDS_Hypothesis*>&
 470 SMESH_Mesh::GetHypothesisList(const TopoDS_Shape & aSubShape) const
 471   throw(SALOME_Exception)
 472 {
 473   Unexpect aCatch(SalomeException);
 474   return _myMeshDS->GetHypothesis(aSubShape);
 475 }
 476
 477 //=======================================================================
 478 //function : GetHypothesis
 479 //purpose  :
 480 //=======================================================================
 481
 482 const SMESH_Hypothesis * SMESH_Mesh::GetHypothesis(const TopoDS_Shape &    aSubShape,
 483                                                    const SMESH_HypoFilter& aFilter,
 484                                                    const bool              andAncestors) const
 485 {
 486   {
 487     const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(aSubShape);
 488     list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
 489     for ( ; hyp != hypList.end(); hyp++ ) {
 490       const SMESH_Hypothesis * h = static_cast<const SMESH_Hypothesis*>( *hyp );
 491       if ( aFilter.IsOk( h, aSubShape))
 492         return h;
 493     }
 494   }
 495   if ( andAncestors )
 496   {
 497     TopTools_ListIteratorOfListOfShape it( GetAncestors( aSubShape ));
 498     for (; it.More(); it.Next() )
 499     {
 500       const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(it.Value());
 501       list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
 502       for ( ; hyp != hypList.end(); hyp++ ) {
 503         const SMESH_Hypothesis * h = static_cast<const SMESH_Hypothesis*>( *hyp );
 504         if (aFilter.IsOk( h, it.Value() ))
 505           return h;
 506       }
 507     }
 508   }
 509   return 0;
 510 }
 511
 512 //=======================================================================
 513 //function : GetHypotheses
 514 //purpose  :
 515 //=======================================================================
 516
 517 bool SMESH_Mesh::GetHypotheses(const TopoDS_Shape &                aSubShape,
 518                                const SMESH_HypoFilter&             aFilter,
 519                                list <const SMESHDS_Hypothesis * >& aHypList,
 520                                const bool                          andAncestors) const
 521 {
 522   int nbHyp = 0;
 523   {
 524     const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(aSubShape);
 525     list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
 526     for ( ; hyp != hypList.end(); hyp++ )
 527       if ( aFilter.IsOk (static_cast<const SMESH_Hypothesis*>( *hyp ), aSubShape)) {
 528         aHypList.push_back( *hyp );
 529         nbHyp++;
 530       }
 531   }
 532   // get hypos from shape of one type only: if any hypo is found on edge, do
 533   // not look up on faces
 534   if ( !nbHyp && andAncestors )
 535   {
 536     TopTools_MapOfShape map;
 537     TopTools_ListIteratorOfListOfShape it( GetAncestors( aSubShape ));
 538     int shapeType = it.More() ? it.Value().ShapeType() : TopAbs_SHAPE;
 539     for (; it.More(); it.Next() )
 540     {
 541       if ( nbHyp && shapeType != it.Value().ShapeType() )
 542         break;
 543       shapeType = it.Value().ShapeType();
 544       if ( !map.Add( it.Value() ))
 545         continue;
 546       const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(it.Value());
 547       list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
 548       for ( ; hyp != hypList.end(); hyp++ )
 549         if (aFilter.IsOk( static_cast<const SMESH_Hypothesis*>( *hyp ), it.Value() )) {
 550         aHypList.push_back( *hyp );
 551         nbHyp++;
 552       }
 553     }
 554   }
 555   return nbHyp;
 556 }
 557
 558 //=============================================================================
 559 /*!
 560  *
 561  */
 562 //=============================================================================
 563
 564 const list<SMESHDS_Command*> & SMESH_Mesh::GetLog() throw(SALOME_Exception)
 565 {
 566   Unexpect aCatch(SalomeException);
 567   if(MYDEBUG) MESSAGE("SMESH_Mesh::GetLog");
 568   return _myMeshDS->GetScript()->GetCommands();
 569 }
 570
 571 //=============================================================================
 572 /*!
 573  *
 574  */
 575 //=============================================================================
 576 void SMESH_Mesh::ClearLog() throw(SALOME_Exception)
 577 {
 578   Unexpect aCatch(SalomeException);
 579   if(MYDEBUG) MESSAGE("SMESH_Mesh::ClearLog");
 580   _myMeshDS->GetScript()->Clear();
 581 }
 582
 583 //=============================================================================
 584 /*!
 585  *
 586  */
 587 //=============================================================================
 588
 589 int SMESH_Mesh::GetId()
 590 {
 591   if(MYDEBUG) MESSAGE("SMESH_Mesh::GetId");
 592   return _id;
 593 }
 594
 595 //=============================================================================
 596 /*!
 597  *
 598  */
 599 //=============================================================================
 600
 601 SMESH_Gen *SMESH_Mesh::GetGen()
 602 {
 603   return _gen;
 604 }
 605
 606 //=============================================================================
 607 /*!
 608  * Get or Create the SMESH_subMesh object implementation
 609  */
 610 //=============================================================================
 611
 612 SMESH_subMesh *SMESH_Mesh::GetSubMesh(const TopoDS_Shape & aSubShape)
 613 throw(SALOME_Exception)
 614 {
 615   Unexpect aCatch(SalomeException);
 616   SMESH_subMesh *aSubMesh;
 617   int index = _myMeshDS->ShapeToIndex(aSubShape);
 618
 619   // for submeshes on GEOM Group
 620   if ( !index && aSubShape.ShapeType() == TopAbs_COMPOUND ) {
 621     TopoDS_Iterator it( aSubShape );
 622     if ( it.More() )
 623       index = _myMeshDS->AddCompoundSubmesh( aSubShape, it.Value().ShapeType() );
 624   }
 625
 626   if (_mapSubMesh.find(index) != _mapSubMesh.end())
 627     {
 628       aSubMesh = _mapSubMesh[index];
 629     }
 630   else
 631     {
 632       aSubMesh = new SMESH_subMesh(index, this, _myMeshDS, aSubShape);
 633       _mapSubMesh[index] = aSubMesh;
 634     }
 635   return aSubMesh;
 636 }
 637
 638 //=============================================================================
 639 /*!
 640  * Get the SMESH_subMesh object implementation. Dont create it, return null
 641  * if it does not exist.
 642  */
 643 //=============================================================================
 644
 645 SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const TopoDS_Shape & aSubShape)
 646 throw(SALOME_Exception)
 647 {
 648   Unexpect aCatch(SalomeException);
 649   bool isFound = false;
 650   SMESH_subMesh *aSubMesh = NULL;
 651
 652   int index = _myMeshDS->ShapeToIndex(aSubShape);
 653   if (_mapSubMesh.find(index) != _mapSubMesh.end())
 654     {
 655       aSubMesh = _mapSubMesh[index];
 656       isFound = true;
 657     }
 658   if (!isFound)
 659     aSubMesh = NULL;
 660   return aSubMesh;
 661 }
 662
 663 //=======================================================================
 664 //function : IsUsedHypothesis
 665 //purpose  : Return True if anHyp is used to mesh aSubShape
 666 //=======================================================================
 667
 668 bool SMESH_Mesh::IsUsedHypothesis(SMESHDS_Hypothesis * anHyp,
 669                                   const TopoDS_Shape & aSubShape)
 670 {
 671   SMESH_Hypothesis* hyp = static_cast<SMESH_Hypothesis*>(anHyp);
 672   // check if anHyp is applicable to aSubShape
 673   SMESH_subMesh * subMesh = GetSubMeshContaining( aSubShape );
 674   if ( !subMesh || !subMesh->IsApplicableHypotesis( hyp ))
 675     return false;
 676
 677   SMESH_Algo *algo = _gen->GetAlgo(*this, aSubShape);
 678
 679   // algorithm
 680   if (anHyp->GetType() > SMESHDS_Hypothesis::PARAM_ALGO)
 681     return ( anHyp == algo );
 682
 683   // algorithm parameter
 684   if (algo)
 685   {
 686     // look trough hypotheses used by algo
 687     const list <const SMESHDS_Hypothesis * >&usedHyps =
 688       algo->GetUsedHypothesis(*this, aSubShape);
 689     return ( find( usedHyps.begin(), usedHyps.end(), anHyp ) != usedHyps.end() );
 690   }
 691
 692   // look through all assigned hypotheses
 693   SMESH_HypoFilter filter( SMESH_HypoFilter::Is( hyp ));
 694   return GetHypothesis( aSubShape, filter, true );
 695 }
 696
 697
 698 //=============================================================================
 699 /*!
 700  *
 701  */
 702 //=============================================================================
 703
 704 const list < SMESH_subMesh * >&
 705         SMESH_Mesh::GetSubMeshUsingHypothesis(SMESHDS_Hypothesis * anHyp)
 706 throw(SALOME_Exception)
 707 {
 708   Unexpect aCatch(SalomeException);
 709         if(MYDEBUG) MESSAGE("SMESH_Mesh::GetSubMeshUsingHypothesis");
 710         map < int, SMESH_subMesh * >::iterator itsm;
 711         _subMeshesUsingHypothesisList.clear();
 712         for (itsm = _mapSubMesh.begin(); itsm != _mapSubMesh.end(); itsm++)
 713         {
 714                 SMESH_subMesh *aSubMesh = (*itsm).second;
 715                 if ( IsUsedHypothesis ( anHyp, aSubMesh->GetSubShape() ))
 716                         _subMeshesUsingHypothesisList.push_back(aSubMesh);
 717         }
 718         return _subMeshesUsingHypothesisList;
 719 }
 720
 721 //=============================================================================
 722 /*!
 723  *
 724  */
 725 //=============================================================================
 726
 727 void SMESH_Mesh::ExportMED(const char *file,
 728                            const char* theMeshName,
 729                            bool theAutoGroups,
 730                            int theVersion)
 731   throw(SALOME_Exception)
 732 {
 733   Unexpect aCatch(SalomeException);
 734   DriverMED_W_SMESHDS_Mesh myWriter;
 735   myWriter.SetFile    ( file, MED::EVersion(theVersion) );
 736   myWriter.SetMesh    ( _myMeshDS   );
 737   if ( !theMeshName )
 738     myWriter.SetMeshId  ( _idDoc      );
 739   else {
 740     myWriter.SetMeshId  ( -1          );
 741     myWriter.SetMeshName( theMeshName );
 742   }
 743
 744   if ( theAutoGroups ) {
 745     myWriter.AddGroupOfNodes();
 746     myWriter.AddGroupOfEdges();
 747     myWriter.AddGroupOfFaces();
 748     myWriter.AddGroupOfVolumes();
 749   }
 750
 751   for ( map<int, SMESH_Group*>::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) {
 752     SMESH_Group*       aGroup   = it->second;
 753     SMESHDS_GroupBase* aGroupDS = aGroup->GetGroupDS();
 754     if ( aGroupDS ) {
 755       aGroupDS->SetStoreName( aGroup->GetName() );
 756       myWriter.AddGroup( aGroupDS );
 757     }
 758   }
 759
 760   myWriter.Perform();
 761 }
 762
 763 void SMESH_Mesh::ExportDAT(const char *file) throw(SALOME_Exception)
 764 {
 765   Unexpect aCatch(SalomeException);
 766   DriverDAT_W_SMDS_Mesh myWriter;
 767   myWriter.SetFile(string(file));
 768   myWriter.SetMesh(_myMeshDS);
 769   myWriter.SetMeshId(_idDoc);
 770   myWriter.Perform();
 771 }
 772
 773 void SMESH_Mesh::ExportUNV(const char *file) throw(SALOME_Exception)
 774 {
 775   Unexpect aCatch(SalomeException);
 776   DriverUNV_W_SMDS_Mesh myWriter;
 777   myWriter.SetFile(string(file));
 778   myWriter.SetMesh(_myMeshDS);
 779   myWriter.SetMeshId(_idDoc);
 780   myWriter.Perform();
 781 }
 782
 783 void SMESH_Mesh::ExportSTL(const char *file, const bool isascii) throw(SALOME_Exception)
 784 {
 785   Unexpect aCatch(SalomeException);
 786   DriverSTL_W_SMDS_Mesh myWriter;
 787   myWriter.SetFile(string(file));
 788   myWriter.SetIsAscii( isascii );
 789   myWriter.SetMesh(_myMeshDS);
 790   myWriter.SetMeshId(_idDoc);
 791   myWriter.Perform();
 792 }
 793
 794 //=============================================================================
 795 /*!
 796  *
 797  */
 798 //=============================================================================
 799 int SMESH_Mesh::NbNodes() throw(SALOME_Exception)
 800 {
 801   Unexpect aCatch(SalomeException);
 802   return _myMeshDS->NbNodes();
 803 }
 804
 805 //=============================================================================
 806 /*!
 807  *
 808  */
 809 //=============================================================================
 810 int SMESH_Mesh::NbEdges() throw(SALOME_Exception)
 811 {
 812   Unexpect aCatch(SalomeException);
 813   return _myMeshDS->NbEdges();
 814 }
 815
 816 //=============================================================================
 817 /*!
 818  *
 819  */
 820 //=============================================================================
 821 int SMESH_Mesh::NbFaces() throw(SALOME_Exception)
 822 {
 823   Unexpect aCatch(SalomeException);
 824   return _myMeshDS->NbFaces();
 825 }
 826
 827 ///////////////////////////////////////////////////////////////////////////////
 828 /// Return the number of 3 nodes faces in the mesh. This method run in O(n)
 829 ///////////////////////////////////////////////////////////////////////////////
 830 int SMESH_Mesh::NbTriangles() throw(SALOME_Exception)
 831 {
 832   Unexpect aCatch(SalomeException);
 833   int Nb = 0;
 834
 835   SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator();
 836   while(itFaces->more()) if(itFaces->next()->NbNodes()==3) Nb++;
 837   return Nb;
 838 }
 839
 840 ///////////////////////////////////////////////////////////////////////////////
 841 /// Return the number of 4 nodes faces in the mesh. This method run in O(n)
 842 ///////////////////////////////////////////////////////////////////////////////
 843 int SMESH_Mesh::NbQuadrangles() throw(SALOME_Exception)
 844 {
 845   Unexpect aCatch(SalomeException);
 846   int Nb = 0;
 847
 848   SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator();
 849   while(itFaces->more()) if(itFaces->next()->NbNodes()==4) Nb++;
 850   return Nb;
 851 }
 852
 853 //=============================================================================
 854 /*!
 855  *
 856  */
 857 //=============================================================================
 858 int SMESH_Mesh::NbVolumes() throw(SALOME_Exception)
 859 {
 860   Unexpect aCatch(SalomeException);
 861   return _myMeshDS->NbVolumes();
 862 }
 863
 864 int SMESH_Mesh::NbTetras() throw(SALOME_Exception)
 865 {
 866   Unexpect aCatch(SalomeException);
 867   int Nb = 0;
 868   SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
 869   while(itVolumes->more()) if(itVolumes->next()->NbNodes()==4) Nb++;
 870   return Nb;
 871 }
 872
 873 int SMESH_Mesh::NbHexas() throw(SALOME_Exception)
 874 {
 875   Unexpect aCatch(SalomeException);
 876   int Nb = 0;
 877   SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
 878   while(itVolumes->more()) if(itVolumes->next()->NbNodes()==8) Nb++;
 879   return Nb;
 880 }
 881
 882 int SMESH_Mesh::NbPyramids() throw(SALOME_Exception)
 883 {
 884   Unexpect aCatch(SalomeException);
 885   int Nb = 0;
 886   SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
 887   while(itVolumes->more()) if(itVolumes->next()->NbNodes()==5) Nb++;
 888   return Nb;
 889 }
 890
 891 int SMESH_Mesh::NbPrisms() throw(SALOME_Exception)
 892 {
 893   Unexpect aCatch(SalomeException);
 894   int Nb = 0;
 895   SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
 896   while(itVolumes->more()) if(itVolumes->next()->NbNodes()==6) Nb++;
 897   return Nb;
 898 }
 899
 900 //=============================================================================
 901 /*!
 902  *
 903  */
 904 //=============================================================================
 905 int SMESH_Mesh::NbSubMesh() throw(SALOME_Exception)
 906 {
 907   Unexpect aCatch(SalomeException);
 908   return _myMeshDS->NbSubMesh();
 909 }
 910
 911 //=======================================================================
 912 //function : IsNotConformAllowed
 913 //purpose  : check if a hypothesis alowing notconform mesh is present
 914 //=======================================================================
 915
 916 bool SMESH_Mesh::IsNotConformAllowed() const
 917 {
 918   if(MYDEBUG) MESSAGE("SMESH_Mesh::IsNotConformAllowed");
 919
 920   SMESH_HypoFilter filter( SMESH_HypoFilter::HasName( "NotConformAllowed" ));
 921   return GetHypothesis( _myMeshDS->ShapeToMesh(), filter, false );
 922 }
 923
 924 //=======================================================================
 925 //function : IsMainShape
 926 //purpose  :
 927 //=======================================================================
 928
 929 bool SMESH_Mesh::IsMainShape(const TopoDS_Shape& theShape) const
 930 {
 931   return theShape.IsSame(_myMeshDS->ShapeToMesh() );
 932 }
 933
 934 //=============================================================================
 935 /*!
 936  *
 937  */
 938 //=============================================================================
 939
 940 SMESH_Group* SMESH_Mesh::AddGroup (const SMDSAbs_ElementType theType,
 941                                    const char*               theName,
 942                                    int&                      theId,
 943                                    const TopoDS_Shape&       theShape)
 944 {
 945   if (_mapGroup.find(_groupId) != _mapGroup.end())
 946     return NULL;
 947   theId = _groupId;
 948   SMESH_Group* aGroup = new SMESH_Group (theId, this, theType, theName, theShape);
 949   GetMeshDS()->AddGroup( aGroup->GetGroupDS() );
 950   _mapGroup[_groupId++] = aGroup;
 951   return aGroup;
 952 }
 953
 954 //=============================================================================
 955 /*!
 956  *
 957  */
 958 //=============================================================================
 959
 960 SMESH_Group* SMESH_Mesh::GetGroup (const int theGroupID)
 961 {
 962   if (_mapGroup.find(theGroupID) == _mapGroup.end())
 963     return NULL;
 964   return _mapGroup[theGroupID];
 965 }
 966
 967
 968 //=============================================================================
 969 /*!
 970  *
 971  */
 972 //=============================================================================
 973
 974 list<int> SMESH_Mesh::GetGroupIds()
 975 {
 976   list<int> anIds;
 977   for ( map<int, SMESH_Group*>::const_iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ )
 978     anIds.push_back( it->first );
 979
 980   return anIds;
 981 }
 982
 983
 984 //=============================================================================
 985 /*!
 986  *
 987  */
 988 //=============================================================================
 989
 990 void SMESH_Mesh::RemoveGroup (const int theGroupID)
 991 {
 992   if (_mapGroup.find(theGroupID) == _mapGroup.end())
 993     return;
 994   GetMeshDS()->RemoveGroup( _mapGroup[theGroupID]->GetGroupDS() );
 995   _mapGroup.erase (theGroupID);
 996   delete _mapGroup[theGroupID];
 997 }
 998
 999 //=============================================================================
1000 /*!
1001  *  IsLocal1DHypothesis
1002  *  Returns a local 1D hypothesis used for theEdge
1003  */
1004 //=============================================================================
1005 const SMESH_Hypothesis* SMESH_Mesh::IsLocal1DHypothesis (const TopoDS_Shape& theEdge)
1006 {
1007   SMESH_HypoFilter filter( SMESH_HypoFilter::HasDim( 1 ));
1008   filter.AndNot( SMESH_HypoFilter::IsAlgo() );
1009   filter.AndNot( SMESH_HypoFilter::IsGlobal( GetMeshDS()->ShapeToMesh() ));
1010
1011   return GetHypothesis( theEdge, filter, true );
1012 }
1013
1014 //=============================================================================
1015 /*!
1016  *  IsPropagationHypothesis
1017  */
1018 //=============================================================================
1019 bool SMESH_Mesh::IsPropagationHypothesis (const TopoDS_Shape& theEdge)
1020 {
1021   return _mapPropagationChains.Contains(theEdge);
1022 }
1023
1024 //=============================================================================
1025 /*!
1026  *  IsPropagatedHypothesis
1027  */
1028 //=============================================================================
1029 bool SMESH_Mesh::IsPropagatedHypothesis (const TopoDS_Shape& theEdge,
1030                                          TopoDS_Shape&       theMainEdge)
1031 {
1032   int nbChains = _mapPropagationChains.Extent();
1033   for (int i = 1; i <= nbChains; i++) {
1034     const TopTools_IndexedMapOfShape& aChain = _mapPropagationChains.FindFromIndex(i);
1035     if (aChain.Contains(theEdge)) {
1036       theMainEdge = _mapPropagationChains.FindKey(i);
1037       return true;
1038     }
1039   }
1040
1041   return false;
1042 }
1043 //=============================================================================
1044 /*!
1045  *  IsReversedInChain
1046  */
1047 //=============================================================================
1048
1049 bool SMESH_Mesh::IsReversedInChain (const TopoDS_Shape& theEdge,
1050                                     const TopoDS_Shape& theMainEdge)
1051 {
1052   if ( !theMainEdge.IsNull() && !theEdge.IsNull() &&
1053       _mapPropagationChains.Contains( theMainEdge ))
1054   {
1055     const TopTools_IndexedMapOfShape& aChain =
1056       _mapPropagationChains.FindFromKey( theMainEdge );
1057     int index = aChain.FindIndex( theEdge );
1058     if ( index )
1059       return aChain(index).Orientation() == TopAbs_REVERSED;
1060   }
1061   return false;
1062 }
1063
1064 //=============================================================================
1065 /*!
1066  *  CleanMeshOnPropagationChain
1067  */
1068 //=============================================================================
1069 void SMESH_Mesh::CleanMeshOnPropagationChain (const TopoDS_Shape& theMainEdge)
1070 {
1071   const TopTools_IndexedMapOfShape& aChain = _mapPropagationChains.FindFromKey(theMainEdge);
1072   int i, nbEdges = aChain.Extent();
1073   for (i = 1; i <= nbEdges; i++) {
1074     TopoDS_Shape anEdge = aChain.FindKey(i);
1075     SMESH_subMesh *subMesh = GetSubMesh(anEdge);
1076     SMESHDS_SubMesh *subMeshDS = subMesh->GetSubMeshDS();
1077     if (subMeshDS && subMeshDS->NbElements() > 0) {
1078       subMesh->ComputeStateEngine(SMESH_subMesh::CLEANDEP);
1079     }
1080   }
1081 }
1082
1083 //=============================================================================
1084 /*!
1085  *  RebuildPropagationChains
1086  *  Rebuild all existing propagation chains.
1087  *  Have to be used, if 1D hypothesis have been assigned/removed to/from any edge
1088  */
1089 //=============================================================================
1090 bool SMESH_Mesh::RebuildPropagationChains()
1091 {
1092   bool ret = true;
1093
1094   // Clean all chains, because they can be not up-to-date
1095   int i, nbChains = _mapPropagationChains.Extent();
1096   for (i = 1; i <= nbChains; i++) {
1097     TopoDS_Shape aMainEdge = _mapPropagationChains.FindKey(i);
1098     CleanMeshOnPropagationChain(aMainEdge);
1099     _mapPropagationChains.ChangeFromIndex(i).Clear();
1100   }
1101
1102   // Build all chains
1103   for (i = 1; i <= nbChains; i++) {
1104     TopoDS_Shape aMainEdge = _mapPropagationChains.FindKey(i);
1105     if (!BuildPropagationChain(aMainEdge))
1106       ret = false;
1107     CleanMeshOnPropagationChain(aMainEdge);
1108   }
1109
1110   return ret;
1111 }
1112
1113 //=============================================================================
1114 /*!
1115  *  RemovePropagationChain
1116  *  Have to be used, if Propagation hypothesis is removed from <theMainEdge>
1117  */
1118 //=============================================================================
1119 bool SMESH_Mesh::RemovePropagationChain (const TopoDS_Shape& theMainEdge)
1120 {
1121   if (!_mapPropagationChains.Contains(theMainEdge))
1122     return false;
1123
1124   // Clean mesh elements and nodes, built on the chain
1125   CleanMeshOnPropagationChain(theMainEdge);
1126
1127   // Clean the chain
1128   _mapPropagationChains.ChangeFromKey(theMainEdge).Clear();
1129
1130   // Remove the chain from the map
1131   int i = _mapPropagationChains.FindIndex(theMainEdge);
1132   if ( i == _mapPropagationChains.Extent() )
1133     _mapPropagationChains.RemoveLast();
1134   else {
1135     TopoDS_Vertex anEmptyShape;
1136     BRep_Builder BB;
1137     BB.MakeVertex(anEmptyShape, gp_Pnt(0,0,0), 0.1);
1138     TopTools_IndexedMapOfShape anEmptyMap;
1139     _mapPropagationChains.Substitute(i, anEmptyShape, anEmptyMap);
1140   }
1141
1142   return true;
1143 }
1144
1145 //=============================================================================
1146 /*!
1147  *  BuildPropagationChain
1148  */
1149 //=============================================================================
1150 bool SMESH_Mesh::BuildPropagationChain (const TopoDS_Shape& theMainEdge)
1151 {
1152   if (theMainEdge.ShapeType() != TopAbs_EDGE) return true;
1153
1154   // Add new chain, if there is no
1155   if (!_mapPropagationChains.Contains(theMainEdge)) {
1156     TopTools_IndexedMapOfShape aNewChain;
1157     _mapPropagationChains.Add(theMainEdge, aNewChain);
1158   }
1159
1160   // Check presence of 1D hypothesis to be propagated
1161   const SMESH_Hypothesis* aMainHyp = IsLocal1DHypothesis(theMainEdge);
1162   if (!aMainHyp) {
1163     MESSAGE("Warning: There is no 1D hypothesis to propagate. Please, assign.");
1164     return true;
1165   }
1166
1167   // Edges, on which the 1D hypothesis will be propagated from <theMainEdge>
1168   TopTools_IndexedMapOfShape& aChain = _mapPropagationChains.ChangeFromKey(theMainEdge);
1169   if (aChain.Extent() > 0) {
1170     CleanMeshOnPropagationChain(theMainEdge);
1171     aChain.Clear();
1172   }
1173
1174   // At first put <theMainEdge> in the chain
1175   aChain.Add(theMainEdge);
1176
1177   // List of edges, added to chain on the previous cycle pass
1178   TopTools_ListOfShape listPrevEdges;
1179   listPrevEdges.Append(theMainEdge.Oriented( TopAbs_FORWARD ));
1180
1181 //   5____4____3____4____5____6
1182 //   |    |    |    |    |    |
1183 //   |    |    |    |    |    |
1184 //   4____3____2____3____4____5
1185 //   |    |    |    |    |    |      Number in the each knot of
1186 //   |    |    |    |    |    |      grid indicates cycle pass,
1187 //   3____2____1____2____3____4      on which corresponding edge
1188 //   |    |    |    |    |    |      (perpendicular to the plane
1189 //   |    |    |    |    |    |      of view) will be found.
1190 //   2____1____0____1____2____3
1191 //   |    |    |    |    |    |
1192 //   |    |    |    |    |    |
1193 //   3____2____1____2____3____4
1194
1195   // Collect all edges pass by pass
1196   while (listPrevEdges.Extent() > 0) {
1197     // List of edges, added to chain on this cycle pass
1198     TopTools_ListOfShape listCurEdges;
1199
1200     // Find the next portion of edges
1201     TopTools_ListIteratorOfListOfShape itE (listPrevEdges);
1202     for (; itE.More(); itE.Next()) {
1203       TopoDS_Shape anE = itE.Value();
1204
1205       // Iterate on faces, having edge <anE>
1206       TopTools_ListIteratorOfListOfShape itA (GetAncestors(anE));
1207       for (; itA.More(); itA.Next()) {
1208         TopoDS_Shape aW = itA.Value();
1209
1210         // There are objects of different type among the ancestors of edge
1211         if (aW.ShapeType() == TopAbs_WIRE) {
1212           TopoDS_Shape anOppE;
1213
1214           BRepTools_WireExplorer aWE (TopoDS::Wire(aW));
1215           Standard_Integer nb = 1, found = 0;
1216           TopTools_Array1OfShape anEdges (1,4);
1217           for (; aWE.More(); aWE.Next(), nb++) {
1218             if (nb > 4) {
1219               found = 0;
1220               break;
1221             }
1222             anEdges(nb) = aWE.Current();
1223             if (!_mapAncestors.Contains(anEdges(nb))) {
1224               MESSAGE("WIRE EXPLORER HAVE GIVEN AN INVALID EDGE !!!");
1225               break;
1226             }
1227             if (anEdges(nb).IsSame(anE)) found = nb;
1228           }
1229
1230           if (nb == 5 && found > 0) {
1231             // Quadrangle face found, get an opposite edge
1232             Standard_Integer opp = found + 2;
1233             if (opp > 4) opp -= 4;
1234             anOppE = anEdges(opp);
1235
1236             // add anOppE to aChain if ...
1237             if (!aChain.Contains(anOppE)) { // ... anOppE is not in aChain
1238               if (!IsLocal1DHypothesis(anOppE)) { // ... no other 1d hyp on anOppE
1239                 TopoDS_Shape aMainEdgeForOppEdge; // ... no other hyp is propagated to anOppE
1240                 if (!IsPropagatedHypothesis(anOppE, aMainEdgeForOppEdge))
1241                 {
1242                   // Add found edge to the chain oriented so that to
1243                   // have it co-directed with a forward MainEdge
1244                   TopAbs_Orientation ori = anE.Orientation();
1245                   if ( anEdges(opp).Orientation() == anEdges(found).Orientation() )
1246                     ori = TopAbs::Reverse( ori );
1247                   anOppE.Orientation( ori );
1248                   aChain.Add(anOppE);
1249                   listCurEdges.Append(anOppE);
1250                 }
1251                 else {
1252                   // Collision!
1253                   MESSAGE("Error: Collision between propagated hypotheses");
1254                   CleanMeshOnPropagationChain(theMainEdge);
1255                   aChain.Clear();
1256                   return ( aMainHyp == IsLocal1DHypothesis(aMainEdgeForOppEdge) );
1257                 }
1258               }
1259             }
1260           } // if (nb == 5 && found > 0)
1261         } // if (aF.ShapeType() == TopAbs_WIRE)
1262       } // for (; itF.More(); itF.Next())
1263     } // for (; itE.More(); itE.Next())
1264
1265     listPrevEdges = listCurEdges;
1266   } // while (listPrevEdges.Extent() > 0)
1267
1268   CleanMeshOnPropagationChain(theMainEdge);
1269   return true;
1270 }
1271
1272 //=======================================================================
1273 //function : GetAncestors
1274 //purpose  : return list of ancestors of theSubShape in the order
1275 //           that lower dimention shapes come first.
1276 //=======================================================================
1277
1278 const TopTools_ListOfShape& SMESH_Mesh::GetAncestors(const TopoDS_Shape& theS) const
1279 {
1280   if ( _mapAncestors.Contains( theS ) )
1281     return _mapAncestors.FindFromKey( theS );
1282
1283   static TopTools_ListOfShape emptyList;
1284   return emptyList;
1285 }
1286
1287 //=======================================================================
1288 //function : Dump
1289 //purpose  : dumps contents of mesh to stream [ debug purposes ]
1290 //=======================================================================
1291 ostream& SMESH_Mesh::Dump(ostream& save)
1292 {
1293   save << "========================== Dump contents of mesh ==========================" << endl;
1294   save << "1) Total number of nodes:     " << NbNodes() << endl;
1295   save << "2) Total number of edges:     " << NbEdges() << endl;
1296   save << "3) Total number of faces:     " << NbFaces() << endl;
1297   if ( NbFaces() > 0 ) {
1298     int nb3 = NbTriangles();
1299     int nb4 = NbQuadrangles();
1300     save << "3.1.) Number of triangles:    " << nb3 << endl;
1301     save << "3.2.) Number of quadrangles:  " << nb4 << endl;
1302     if ( nb3 + nb4 !=  NbFaces() ) {
1303       map<int,int> myFaceMap;
1304       SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator();
1305       while( itFaces->more( ) ) {
1306         int nbNodes = itFaces->next()->NbNodes();
1307         if ( myFaceMap.find( nbNodes ) == myFaceMap.end() )
1308           myFaceMap[ nbNodes ] = 0;
1309         myFaceMap[ nbNodes ] = myFaceMap[ nbNodes ] + 1;
1310       }
1311       save << "3.3.) Faces in detail: " << endl;
1312       map <int,int>::iterator itF;
1313       for (itF = myFaceMap.begin(); itF != myFaceMap.end(); itF++)
1314         save << "--> nb nodes: " << itF->first << " - nb elemens: " << itF->second << endl;
1315     }
1316   }
1317   save << "4) Total number of volumes:   " << NbVolumes() << endl;
1318   if ( NbVolumes() > 0 ) {
1319     int nb8 = NbHexas();
1320     int nb4 = NbTetras();
1321     int nb5 = NbPyramids();
1322     int nb6 = NbPrisms();
1323     save << "4.1.) Number of hexahedrons:  " << nb8 << endl;
1324     save << "4.2.) Number of tetrahedrons: " << nb4 << endl;
1325     save << "4.3.) Number of prisms:       " << nb6 << endl;
1326     save << "4.4.) Number of pyramides:    " << nb5 << endl;
1327     if ( nb8 + nb4 + nb5 + nb6 != NbVolumes() ) {
1328       map<int,int> myVolumesMap;
1329       SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
1330       while( itVolumes->more( ) ) {
1331         int nbNodes = itVolumes->next()->NbNodes();
1332         if ( myVolumesMap.find( nbNodes ) == myVolumesMap.end() )
1333           myVolumesMap[ nbNodes ] = 0;
1334         myVolumesMap[ nbNodes ] = myVolumesMap[ nbNodes ] + 1;
1335       }
1336       save << "4.5.) Volumes in detail: " << endl;
1337       map <int,int>::iterator itV;
1338       for (itV = myVolumesMap.begin(); itV != myVolumesMap.end(); itV++)
1339         save << "--> nb nodes: " << itV->first << " - nb elemens: " << itV->second << endl;
1340     }
1341   }
1342   save << "===========================================================================" << endl;
1343   return save;
1344 }