src/StdMeshers/StdMeshers_Import_1D.cxx

   1 //  Copyright (C) 2007-2010  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 //  Copyright (C) 2003-2007  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.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 //  SMESH SMESH : implementaion of SMESH idl descriptions
  24 //  File   : StdMeshers_Import_1D.cxx
  25 //  Module : SMESH
  26 //
  27 #include "StdMeshers_Import_1D.hxx"
  28 #include "StdMeshers_ImportSource.hxx"
  29
  30 #include "SMDS_MeshElement.hxx"
  31 #include "SMDS_MeshNode.hxx"
  32 #include "SMESHDS_Group.hxx"
  33 #include "SMESHDS_Mesh.hxx"
  34 #include "SMESH_Comment.hxx"
  35 #include "SMESH_Gen.hxx"
  36 #include "SMESH_Group.hxx"
  37 #include "SMESH_HypoFilter.hxx"
  38 #include "SMESH_Mesh.hxx"
  39 #include "SMESH_MesherHelper.hxx"
  40 #include "SMESH_subMesh.hxx"
  41 #include "SMESH_subMeshEventListener.hxx"
  42
  43 #include "Utils_SALOME_Exception.hxx"
  44 #include "utilities.h"
  45
  46 #include <BRep_Builder.hxx>
  47 #include <BRep_Tool.hxx>
  48 #include <TopExp.hxx>
  49 #include <TopExp_Explorer.hxx>
  50 #include <TopoDS.hxx>
  51 #include <TopoDS_Compound.hxx>
  52 #include <TopoDS_Edge.hxx>
  53 #include <TopoDS_Vertex.hxx>
  54
  55 using namespace std;
  56
  57 //=============================================================================
  58 /*!
  59  * Creates StdMeshers_Import_1D
  60  */
  61 //=============================================================================
  62
  63 StdMeshers_Import_1D::StdMeshers_Import_1D(int hypId, int studyId, SMESH_Gen * gen)
  64   :SMESH_1D_Algo(hypId, studyId, gen), _sourceHyp(0)
  65 {
  66   MESSAGE("StdMeshers_Import_1D::StdMeshers_Import_1D");
  67   _name = "Import_1D";
  68   _shapeType = (1 << TopAbs_EDGE);
  69
  70   _compatibleHypothesis.push_back("ImportSource1D");
  71 }
  72
  73 //=============================================================================
  74 /*!
  75  * Check presence of a hypothesis
  76  */
  77 //=============================================================================
  78
  79 bool StdMeshers_Import_1D::CheckHypothesis
  80                          (SMESH_Mesh&                          aMesh,
  81                           const TopoDS_Shape&                  aShape,
  82                           SMESH_Hypothesis::Hypothesis_Status& aStatus)
  83 {
  84   _sourceHyp = 0;
  85
  86   const list <const SMESHDS_Hypothesis * >&hyps = GetUsedHypothesis(aMesh, aShape);
  87   if ( hyps.size() == 0 )
  88   {
  89     aStatus = SMESH_Hypothesis::HYP_MISSING;
  90     return false;  // can't work with no hypothesis
  91   }
  92
  93   if ( hyps.size() > 1 )
  94   {
  95     aStatus = SMESH_Hypothesis::HYP_ALREADY_EXIST;
  96     return false;
  97   }
  98
  99   const SMESHDS_Hypothesis *theHyp = hyps.front();
 100
 101   string hypName = theHyp->GetName();
 102
 103   if (hypName == _compatibleHypothesis.front())
 104   {
 105     _sourceHyp = (StdMeshers_ImportSource1D *)theHyp;
 106     aStatus = SMESH_Hypothesis::HYP_OK;
 107     return true;
 108   }
 109
 110   aStatus = SMESH_Hypothesis::HYP_INCOMPATIBLE;
 111   return true;
 112 }
 113
 114 //================================================================================
 115 namespace // INTERNAL STUFF
 116 //================================================================================
 117 {
 118   int getSubmeshIDForCopiedMesh(const SMESHDS_Mesh* srcMeshDS, SMESH_Mesh* tgtMesh);
 119
 120   enum _ListenerDataType
 121     {
 122       WAIT_HYP_MODIF=1, // data indicating awaiting for valid parameters of src hyp
 123       LISTEN_SRC_MESH, // data storing submesh depending on source mesh state
 124       SRC_HYP // data storing ImportSource hyp
 125     };
 126   //================================================================================
 127   /*!
 128    * \brief _ListenerData holding ImportSource hyp holding in its turn
 129    *  imported groups
 130    */
 131   struct _ListenerData : public SMESH_subMeshEventListenerData
 132   {
 133     const StdMeshers_ImportSource1D* _srcHyp;
 134     _ListenerData(const StdMeshers_ImportSource1D* h, _ListenerDataType type=SRC_HYP):
 135       SMESH_subMeshEventListenerData(/*isDeletable=*/true), _srcHyp(h)
 136     {
 137       myType = type;
 138     }
 139   };
 140   //================================================================================
 141   /*!
 142    * \brief Comparator of sub-meshes
 143    */
 144   struct _SubLess
 145   {
 146     bool operator()(const SMESH_subMesh* sm1, const SMESH_subMesh* sm2 ) const
 147     {
 148       if ( sm1 == sm2 ) return false;
 149       if ( !sm1 || !sm2 ) return sm1 < sm2;
 150       const TopoDS_Shape& s1 = sm1->GetSubShape();
 151       const TopoDS_Shape& s2 = sm2->GetSubShape();
 152       TopAbs_ShapeEnum t1 = s1.IsNull() ? TopAbs_SHAPE : s1.ShapeType();
 153       TopAbs_ShapeEnum t2 = s2.IsNull() ? TopAbs_SHAPE : s2.ShapeType();
 154       if ( t1 == t2)
 155         return (sm1 < sm2);
 156       return t1 < t2; // to have: face < edge
 157     }
 158   };
 159   //================================================================================
 160   /*!
 161    * \brief Container of data dedicated to one source mesh
 162    */
 163   struct _ImportData
 164   {
 165     const SMESH_Mesh* _srcMesh;
 166     StdMeshers_Import_1D::TNodeNodeMap _n2n;
 167     StdMeshers_Import_1D::TElemElemMap _e2e;
 168
 169     set< SMESH_subMesh*, _SubLess > _subM; // submeshes relating to this srcMesh
 170     set< SMESH_subMesh*, _SubLess > _copyMeshSubM; // submeshes requesting mesh copying
 171     set< SMESH_subMesh*, _SubLess > _copyGroupSubM; // submeshes requesting mesh copying
 172     set< SMESH_subMesh*, _SubLess > _computedSubM;
 173
 174     SMESHDS_SubMesh*     _importMeshSubDS; // submesh storing a copy of _srcMesh
 175     int                  _importMeshSubID; // id of _importMeshSubDS
 176
 177     _ImportData(const SMESH_Mesh* srcMesh=0):
 178       _srcMesh(srcMesh), _importMeshSubDS(0),_importMeshSubID(-1) {}
 179
 180     void removeImportedMesh( SMESHDS_Mesh* meshDS )
 181     {
 182       if ( !_importMeshSubDS ) return;
 183       SMDS_ElemIteratorPtr eIt = _importMeshSubDS->GetElements();
 184       while ( eIt->more() )
 185         meshDS->RemoveFreeElement( eIt->next(), _importMeshSubDS, /*fromGroups=*/false );
 186       SMDS_NodeIteratorPtr nIt = _importMeshSubDS->GetNodes();
 187       while ( nIt->more() )
 188         meshDS->RemoveFreeNode( nIt->next(), _importMeshSubDS, /*fromGroups=*/false );
 189       _n2n.clear();
 190       _e2e.clear();
 191     }
 192     void removeGroups( SMESH_subMesh* subM, const StdMeshers_ImportSource1D* srcHyp )
 193     {
 194       if ( !srcHyp ) return;
 195       SMESH_Mesh*           tgtMesh = subM->GetFather();
 196       const SMESHDS_Mesh* tgtMeshDS = tgtMesh->GetMeshDS();
 197       const SMESHDS_Mesh* srcMeshDS = _srcMesh->GetMeshDS();
 198       vector<SMESH_Group*>*  groups =
 199         const_cast<StdMeshers_ImportSource1D*>(srcHyp)->GetResultGroups(*srcMeshDS,*tgtMeshDS);
 200       if ( groups )
 201       {
 202         for ( unsigned i = 0; i < groups->size(); ++i )
 203           tgtMesh->RemoveGroup( groups->at(i)->GetGroupDS()->GetID() );
 204         groups->clear();
 205       }
 206     }
 207     void trackHypParams( SMESH_subMesh* sm, const StdMeshers_ImportSource1D* srcHyp )
 208     {
 209       if ( !srcHyp ) return;
 210       bool toCopyMesh, toCopyGroups;
 211       srcHyp->GetCopySourceMesh(toCopyMesh, toCopyGroups);
 212
 213       if ( toCopyMesh )_copyMeshSubM.insert( sm );
 214       else             _copyMeshSubM.erase( sm );
 215
 216       if ( toCopyGroups ) _copyGroupSubM.insert( sm );
 217       else                _copyGroupSubM.erase( sm );
 218     }
 219     void addComputed( SMESH_subMesh* sm )
 220     {
 221       SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator(/*includeSelf=*/true,
 222                                                                /*complexShapeFirst=*/true);
 223       while ( smIt->more() )
 224       {
 225         sm = smIt->next();
 226         switch ( sm->GetSubShape().ShapeType() )
 227         {
 228         case TopAbs_EDGE:
 229         case TopAbs_FACE:
 230           _subM.insert( sm );
 231           if ( !sm->IsEmpty() )
 232             _computedSubM.insert( sm );
 233         case TopAbs_VERTEX:
 234           break;
 235         default:;
 236         }
 237       }
 238     }
 239   };
 240   //================================================================================
 241   /*!
 242    * Listener notified on events relating to imported submesh
 243    */
 244   class _Listener : public SMESH_subMeshEventListener
 245   {
 246     typedef map< SMESH_Mesh*, list< _ImportData > > TMesh2ImpData;
 247     TMesh2ImpData _tgtMesh2ImportData;
 248
 249     _Listener():SMESH_subMeshEventListener(/*isDeletable=*/false){}
 250
 251   public:
 252     // return poiter to a static listener
 253     static _Listener* get() { static _Listener theListener; return &theListener; }
 254
 255     static _ImportData* getImportData(const SMESH_Mesh* srcMesh, SMESH_Mesh* tgtMesh);
 256
 257     static void storeImportSubmesh(SMESH_subMesh*                   importSub,
 258                                    const SMESH_Mesh*                srcMesh,
 259                                    const StdMeshers_ImportSource1D* srcHyp);
 260
 261     virtual void ProcessEvent(const int                       event,
 262                               const int                       eventType,
 263                               SMESH_subMesh*                  subMesh,
 264                               SMESH_subMeshEventListenerData* data,
 265                               const SMESH_Hypothesis*         hyp);
 266     void removeSubmesh( SMESH_subMesh* sm, _ListenerData* data );
 267     void clearSubmesh ( SMESH_subMesh* sm, _ListenerData* data, bool clearAllSub );
 268
 269     // mark sm as missing src hyp with valid groups
 270     static void waitHypModification(SMESH_subMesh* sm)
 271     {
 272       sm->SetEventListener
 273         (get(), SMESH_subMeshEventListenerData::MakeData( sm, WAIT_HYP_MODIF ), sm);
 274     }
 275   };
 276   //--------------------------------------------------------------------------------
 277   /*!
 278    * \brief Find or create ImportData for given meshes
 279    */
 280   _ImportData* _Listener::getImportData(const SMESH_Mesh* srcMesh,
 281                                         SMESH_Mesh*       tgtMesh)
 282   {
 283     list< _ImportData >& dList = get()->_tgtMesh2ImportData[tgtMesh];
 284     list< _ImportData >::iterator d = dList.begin();
 285     for ( ; d != dList.end(); ++d )
 286       if ( d->_srcMesh == srcMesh )
 287         return &*d;
 288     dList.push_back(_ImportData(srcMesh));
 289     return &dList.back();
 290   }
 291
 292   //--------------------------------------------------------------------------------
 293   /*!
 294    * \brief Remember an imported sub-mesh and set needed even listeners
 295    *  \param importSub - submesh computed by Import algo
 296    *  \param srcMesh - source mesh
 297    *  \param srcHyp - ImportSource hypothesis
 298    */
 299   void _Listener::storeImportSubmesh(SMESH_subMesh*                   importSub,
 300                                      const SMESH_Mesh*                srcMesh,
 301                                      const StdMeshers_ImportSource1D* srcHyp)
 302   {
 303     // set listener to hear events of the submesh computed by "Import" algo
 304     importSub->SetEventListener( get(), new _ListenerData(srcHyp), importSub );
 305
 306     // set a listener to hear events of the source mesh
 307     SMESH_subMesh* smToNotify = importSub;
 308     SMESH_subMesh* smToListen = srcMesh->GetSubMeshContaining(1);
 309     SMESH_subMeshEventListenerData* data = new _ListenerData(srcHyp, LISTEN_SRC_MESH);
 310     data->mySubMeshes.push_back( smToNotify );
 311     importSub->SetEventListener( get(), data, smToListen );
 312
 313     // remeber the submesh importSub and its sub-submeshes
 314     _ImportData* iData = _Listener::getImportData( srcMesh, importSub->GetFather());
 315     iData->trackHypParams( importSub, srcHyp );
 316     iData->addComputed( importSub );
 317     if ( !iData->_copyMeshSubM.empty() && iData->_importMeshSubID < 1 )
 318     {
 319       SMESH_Mesh* tgtMesh = importSub->GetFather();
 320       iData->_importMeshSubID = getSubmeshIDForCopiedMesh( srcMesh->GetMeshDS(),tgtMesh);
 321       iData->_importMeshSubDS = tgtMesh->GetMeshDS()->NewSubMesh( iData->_importMeshSubID );
 322     }
 323   }
 324   //--------------------------------------------------------------------------------
 325   /*!
 326    * \brief Remove imported mesh and/or groups if needed
 327    *  \param sm - submesh loosing Import algo
 328    *  \param data - data holding imported groups
 329    */
 330   void _Listener::removeSubmesh( SMESH_subMesh* sm, _ListenerData* data )
 331   {
 332     list< _ImportData > &  dList = _tgtMesh2ImportData[ sm->GetFather() ];
 333     list< _ImportData >::iterator d = dList.begin();
 334     for ( ; d != dList.end(); ++d )
 335       if ( (*d)._subM.erase( sm ))
 336       {
 337         d->_computedSubM.erase( sm );
 338         bool rmMesh   = d->_copyMeshSubM.erase( sm ) && d->_copyMeshSubM.empty();
 339         bool rmGroups = (d->_copyGroupSubM.erase( sm ) && d->_copyGroupSubM.empty()) || rmMesh;
 340         if ( rmMesh )
 341           d->removeImportedMesh( sm->GetFather()->GetMeshDS() );
 342         if ( rmGroups && data )
 343           d->removeGroups( sm, data->_srcHyp );
 344       }
 345   }
 346   //--------------------------------------------------------------------------------
 347   /*!
 348    * \brief Clear submeshes and remove imported mesh and/or groups if necessary
 349    *  \param sm - cleared submesh
 350    *  \param data - data holding imported groups
 351    */
 352   void _Listener::clearSubmesh(SMESH_subMesh* sm, _ListenerData* data, bool clearAllSub)
 353   {
 354     list< _ImportData > &  dList = _tgtMesh2ImportData[ sm->GetFather() ];
 355     list< _ImportData >::iterator d = dList.begin();
 356     for ( ; d != dList.end(); ++d )
 357     {
 358       if ( !d->_subM.count( sm )) continue;
 359       if ( (*d)._computedSubM.erase( sm ) )
 360       {
 361         bool copyMesh = !d->_copyMeshSubM.empty();
 362         if ( copyMesh || clearAllSub )
 363         {
 364           // remove imported mesh and groups
 365           d->removeImportedMesh( sm->GetFather()->GetMeshDS() );
 366
 367           if ( data )
 368             d->removeGroups( sm, data->_srcHyp );
 369
 370           // clear the rest submeshes
 371           if ( !d->_computedSubM.empty() )
 372           {
 373             set< SMESH_subMesh*, _SubLess> subs;
 374             subs.swap( d->_computedSubM ); // avoid recursion via events
 375             while ( !subs.empty() )
 376             {
 377               SMESH_subMesh* subM = *subs.begin(); subs.erase( subs.begin() );
 378               _ListenerData* hypData = (_ListenerData*) subM->GetEventListenerData( get() );
 379               if ( hypData )
 380                 d->removeGroups( sm, hypData->_srcHyp );
 381
 382               subM->ComputeStateEngine( SMESH_subMesh::CLEAN );
 383               if ( subM->GetSubShape().ShapeType() == TopAbs_FACE )
 384                 subM->ComputeSubMeshStateEngine( SMESH_subMesh::CLEAN );
 385             }
 386           }
 387         }
 388         sm->ComputeStateEngine( SMESH_subMesh::CLEAN );
 389         if ( sm->GetSubShape().ShapeType() == TopAbs_FACE )
 390           sm->ComputeSubMeshStateEngine( SMESH_subMesh::CLEAN );
 391       }
 392       if ( data )
 393         d->trackHypParams( sm, data->_srcHyp );
 394       d->_n2n.clear();
 395       d->_e2e.clear();
 396     }
 397   }
 398   //--------------------------------------------------------------------------------
 399   /*!
 400    * \brief Remove imported mesh and/or groups
 401    */
 402   void _Listener::ProcessEvent(const int                       event,
 403                                const int                       eventType,
 404                                SMESH_subMesh*                  subMesh,
 405                                SMESH_subMeshEventListenerData* data,
 406                                const SMESH_Hypothesis*         /*hyp*/)
 407   {
 408     if ( data && data->myType == WAIT_HYP_MODIF )
 409     {
 410       // event of Import submesh
 411       if ( SMESH_subMesh::MODIF_HYP  == event &&
 412            SMESH_subMesh::ALGO_EVENT == eventType )
 413       {
 414         // re-call SetEventListener() to take into account valid parameters
 415         // of ImportSource hypothesis
 416         SMESH_Gen* gen = subMesh->GetFather()->GetGen();
 417         if ( SMESH_Algo* algo = gen->GetAlgo(*subMesh->GetFather(), subMesh->GetSubShape()))
 418           algo->SetEventListener( subMesh );
 419       }
 420     }
 421     else if ( data && data->myType == LISTEN_SRC_MESH )
 422     {
 423       // event of source mesh
 424       if ( SMESH_subMesh::COMPUTE_EVENT == eventType )
 425       {
 426         switch ( event ) {
 427         case SMESH_subMesh::CLEAN:
 428           // source mesh cleaned -> clean target mesh
 429           clearSubmesh( data->mySubMeshes.front(), (_ListenerData*) data, /*all=*/true );
 430           break;
 431         case SMESH_subMesh::SUBMESH_COMPUTED: {
 432           // source mesh computed -> reset FAILED state of Import submeshes to
 433           // READY_TO_COMPUTE
 434           SMESH_Mesh* srcMesh = subMesh->GetFather();
 435           if ( srcMesh->NbEdges() > 0 || srcMesh->NbFaces() > 0 )
 436           {
 437             SMESH_Mesh* m = data->mySubMeshes.front()->GetFather();
 438             if ( SMESH_subMesh* sm1 = m->GetSubMeshContaining(1))
 439             {
 440               sm1->ComputeStateEngine(SMESH_subMesh::SUBMESH_COMPUTED );
 441               sm1->ComputeSubMeshStateEngine( SMESH_subMesh::SUBMESH_COMPUTED );
 442             }
 443           }
 444           break;
 445         }
 446         default:;
 447         }
 448       }
 449     }
 450     else // event of Import submesh
 451     {
 452       // find out what happens: import hyp modified or removed
 453       bool removeImport = false, modifHyp = false;
 454       if ( SMESH_subMesh::ALGO_EVENT == eventType )
 455         modifHyp = true;
 456       if ( subMesh->GetAlgoState() != SMESH_subMesh::HYP_OK )
 457       {
 458         removeImport = true;
 459       }
 460       else if ( SMESH_subMesh::REMOVE_ALGO == event ||
 461                 SMESH_subMesh::REMOVE_FATHER_ALGO == event )
 462       {
 463         SMESH_Gen* gen = subMesh->GetFather()->GetGen();
 464         SMESH_Algo* algo = gen->GetAlgo(*subMesh->GetFather(),subMesh->GetSubShape() );
 465         removeImport = ( strncmp( "Import", algo->GetName(), 6 ) != 0 );
 466       }
 467
 468       if ( removeImport )
 469       {
 470         // treate removal of Import algo from subMesh
 471         removeSubmesh( subMesh, (_ListenerData*) data );
 472       }
 473       else if ( modifHyp )
 474       {
 475         // treate modification of ImportSource hypothesis
 476         clearSubmesh( subMesh, (_ListenerData*) data, /*all=*/false );
 477       }
 478       else if ( SMESH_subMesh::CHECK_COMPUTE_STATE == event &&
 479                 SMESH_subMesh::COMPUTE_EVENT       == eventType )
 480       {
 481         // check compute state of all submeshes impoting from same src mesh;
 482         // this is to take into account 1D computed submeshes hidden by 2D import algo;
 483         // else source mesh is not copied as _subM.size != _computedSubM.size()
 484         list< _ImportData > &  dList = _tgtMesh2ImportData[ subMesh->GetFather() ];
 485         list< _ImportData >::iterator d = dList.begin();
 486         for ( ; d != dList.end(); ++d )
 487           if ( d->_subM.count( subMesh ))
 488           {
 489             set<SMESH_subMesh*>::iterator smIt = d->_subM.begin();
 490             for( ; smIt != d->_subM.end(); ++smIt )
 491               if ( (*smIt)->IsMeshComputed() )
 492                 d->_computedSubM.insert( *smIt);
 493           }
 494       }
 495     }
 496   }
 497
 498   //================================================================================
 499   /*!
 500    * \brief Return an ID of submesh to store nodes and elements of a copied mesh
 501    */
 502   //================================================================================
 503
 504   int getSubmeshIDForCopiedMesh(const SMESHDS_Mesh* srcMeshDS,
 505                                 SMESH_Mesh*         tgtMesh)
 506   {
 507     // To get SMESH_subMesh corresponding to srcMeshDS we need to have a shape
 508     // for which SMESHDS_Mesh::IsGroupOfSubShapes() returns true.
 509     // And this shape must be different from subshapes of the main shape.
 510     // So we create a compound containing
 511     // 1) some sub-shapes of SMESH_Mesh::PseudoShape() corresponding to
 512     //    srcMeshDS->GetPersistentId()
 513     // 2) the 1-st vertex of the main shape to assure
 514     //    SMESHDS_Mesh::IsGroupOfSubShapes(shape)==true
 515     TopoDS_Shape shapeForSrcMesh;
 516     TopTools_IndexedMapOfShape pseudoSubShapes;
 517     TopExp::MapShapes( SMESH_Mesh::PseudoShape(), pseudoSubShapes );
 518
 519     // index of pseudoSubShapes corresponding to srcMeshDS
 520     int subIndex = srcMeshDS->GetPersistentId() % pseudoSubShapes.Extent();
 521     int nbSubShapes = 1 + srcMeshDS->GetPersistentId() / pseudoSubShapes.Extent();
 522
 523     // try to find already present shapeForSrcMesh
 524     SMESHDS_Mesh* tgtMeshDS = tgtMesh->GetMeshDS();
 525     for ( int i = tgtMeshDS->MaxShapeIndex(); i > 0 && shapeForSrcMesh.IsNull(); --i )
 526     {
 527       const TopoDS_Shape& s = tgtMeshDS->IndexToShape(i);
 528       if ( s.ShapeType() != TopAbs_COMPOUND ) break;
 529       TopoDS_Iterator sSubIt( s );
 530       for ( int iSub = 0; iSub < nbSubShapes && sSubIt.More(); ++iSub, sSubIt.Next() )
 531         if ( pseudoSubShapes( subIndex+iSub ).IsSame( sSubIt.Value()))
 532           if ( iSub+1 == nbSubShapes )
 533           {
 534             shapeForSrcMesh = s;
 535             break;
 536           }
 537     }
 538     if ( shapeForSrcMesh.IsNull() )
 539     {
 540       // make a new shapeForSrcMesh
 541       BRep_Builder aBuilder;
 542       TopoDS_Compound comp;
 543       aBuilder.MakeCompound( comp );
 544       shapeForSrcMesh = comp;
 545       for ( int iSub = 0; iSub < nbSubShapes; ++iSub )
 546         aBuilder.Add( comp, pseudoSubShapes( subIndex+iSub ));
 547       TopExp_Explorer vExp( tgtMeshDS->ShapeToMesh(), TopAbs_VERTEX );
 548       aBuilder.Add( comp, vExp.Current() );
 549     }
 550     SMESH_subMesh* sm = tgtMesh->GetSubMesh( shapeForSrcMesh );
 551     SMESHDS_SubMesh* smDS = sm->GetSubMeshDS();
 552     if ( !smDS )
 553       smDS = tgtMeshDS->NewSubMesh( sm->GetId() );
 554
 555     // make ordinary submesh from a complex one
 556     if ( smDS->IsComplexSubmesh() )
 557     {
 558       list< const SMESHDS_SubMesh* > subSM;
 559       SMESHDS_SubMeshIteratorPtr smIt = smDS->GetSubMeshIterator();
 560       while ( smIt->more() ) subSM.push_back( smIt->next() );
 561       list< const SMESHDS_SubMesh* >::iterator sub = subSM.begin();
 562       for ( ; sub != subSM.end(); ++sub)
 563         smDS->RemoveSubMesh( *sub );
 564     }
 565     return sm->GetId();
 566   }
 567
 568   //================================================================================
 569   /*!
 570    * \brief Return a submesh to store nodes and elements of a copied mesh
 571    * and set event listeners in order to clear
 572    * imported mesh and groups as soon as submesh state requires it
 573    */
 574   //================================================================================
 575
 576   SMESHDS_SubMesh* getSubmeshForCopiedMesh(const SMESH_Mesh*                    srcMesh,
 577                                            SMESH_Mesh*                          tgtMesh,
 578                                            const TopoDS_Shape&                  tgtShape,
 579                                            StdMeshers_Import_1D::TNodeNodeMap*& n2n,
 580                                            StdMeshers_Import_1D::TElemElemMap*& e2e,
 581                                            bool &                               toCopyGroups)
 582   {
 583     StdMeshers_Import_1D::getMaps( srcMesh, tgtMesh, n2n,e2e );
 584
 585     _ImportData* iData = _Listener::getImportData(srcMesh,tgtMesh);
 586
 587     SMESH_subMesh* importedSM = tgtMesh->GetSubMesh( tgtShape );
 588     iData->addComputed( importedSM );
 589     if ( iData->_computedSubM.size() != iData->_subM.size() )
 590       return 0; // not all submeshes computed yet
 591
 592     toCopyGroups = !iData->_copyGroupSubM.empty();
 593
 594     if ( !iData->_copyMeshSubM.empty())
 595     {
 596       // make submesh to store a copied mesh
 597       int smID = getSubmeshIDForCopiedMesh( srcMesh->GetMeshDS(), tgtMesh );
 598       SMESHDS_SubMesh* subDS = tgtMesh->GetMeshDS()->NewSubMesh( smID );
 599
 600       iData->_importMeshSubID = smID;
 601       iData->_importMeshSubDS = subDS;
 602       return subDS;
 603     }
 604     return 0;
 605   }
 606
 607 } // namespace
 608
 609
 610 //=============================================================================
 611 /*!
 612  * Import elements from the other mesh
 613  */
 614 //=============================================================================
 615
 616 bool StdMeshers_Import_1D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & theShape)
 617 {
 618   if ( !_sourceHyp ) return false;
 619
 620   const vector<SMESH_Group*>& srcGroups = _sourceHyp->GetGroups();
 621   if ( srcGroups.empty() )
 622     return error("Invalid source groups");
 623
 624   SMESH_MesherHelper helper(theMesh);
 625   helper.SetSubShape(theShape);
 626   SMESHDS_Mesh* tgtMesh = theMesh.GetMeshDS();
 627
 628   const TopoDS_Edge& geomEdge = TopoDS::Edge( theShape );
 629   const double edgeTol = BRep_Tool::Tolerance( geomEdge );
 630   const int shapeID = tgtMesh->ShapeToIndex( geomEdge );
 631
 632   set<int> subShapeIDs;
 633   subShapeIDs.insert( shapeID );
 634
 635   // get nodes on vertices
 636   list < SMESH_MeshEditor::TNodeXYZ > vertexNodes;
 637  list < SMESH_MeshEditor::TNodeXYZ >::iterator vNIt;
 638   TopExp_Explorer vExp( theShape, TopAbs_VERTEX );
 639   for ( ; vExp.More(); vExp.Next() )
 640   {
 641     const TopoDS_Vertex& v = TopoDS::Vertex( vExp.Current() );
 642     if ( !subShapeIDs.insert( tgtMesh->ShapeToIndex( v )).second )
 643       continue; // closed edge
 644     const SMDS_MeshNode* n = SMESH_Algo::VertexNode( v, tgtMesh );
 645     if ( !n )
 646     {
 647       _gen->Compute(theMesh,v,/*anUpward=*/true);
 648       n = SMESH_Algo::VertexNode( v, tgtMesh );
 649       if ( !n ) return false; // very strange
 650     }
 651     vertexNodes.push_back( SMESH_MeshEditor::TNodeXYZ( n ));
 652   }
 653
 654   // import edges from groups
 655   TNodeNodeMap* n2n;
 656   TElemElemMap* e2e;
 657   for ( int iG = 0; iG < srcGroups.size(); ++iG )
 658   {
 659     const SMESHDS_GroupBase* srcGroup = srcGroups[iG]->GetGroupDS();
 660
 661     const int meshID = srcGroup->GetMesh()->GetPersistentId();
 662     const SMESH_Mesh* srcMesh = GetMeshByPersistentID( meshID );
 663     if ( !srcMesh ) continue;
 664     getMaps( srcMesh, &theMesh, n2n, e2e );
 665
 666     SMDS_ElemIteratorPtr srcElems = srcGroup->GetElements();
 667     vector<const SMDS_MeshNode*> newNodes;
 668     SMDS_MeshNode tmpNode(0,0,0);
 669     double u;
 670     while ( srcElems->more() ) // loop on group contents
 671     {
 672       const SMDS_MeshElement* edge = srcElems->next();
 673       // find or create nodes of a new edge
 674       newNodes.resize( edge->NbNodes() );
 675       newNodes.back() = 0;
 676       SMDS_MeshElement::iterator node = edge->begin_nodes();
 677       for ( unsigned i = 0; i < newNodes.size(); ++i, ++node )
 678       {
 679         TNodeNodeMap::iterator n2nIt = n2n->insert( make_pair( *node, (SMDS_MeshNode*)0 )).first;
 680         if ( n2nIt->second )
 681         {
 682           if ( !subShapeIDs.count( n2nIt->second->GetPosition()->GetShapeId() ))
 683             break;
 684         }
 685         else
 686         {
 687           // find an existing vertex node
 688           for ( vNIt = vertexNodes.begin(); vNIt != vertexNodes.end(); ++vNIt)
 689             if ( vNIt->SquareDistance( *node ) < 10 * edgeTol * edgeTol)
 690             {
 691               (*n2nIt).second = vNIt->_node;
 692               vertexNodes.erase( vNIt );
 693               break;
 694             }
 695         }
 696         if ( !n2nIt->second )
 697         {
 698           // find out if node lies on theShape
 699           tmpNode.setXYZ( (*node)->X(), (*node)->Y(), (*node)->Z());
 700           if ( helper.CheckNodeU( geomEdge, &tmpNode, u, 10 * edgeTol, /*force=*/true ))
 701           {
 702             SMDS_MeshNode* newNode = tgtMesh->AddNode( (*node)->X(), (*node)->Y(), (*node)->Z());
 703             n2nIt->second = newNode;
 704             tgtMesh->SetNodeOnEdge( newNode, shapeID, u );
 705           }
 706         }
 707         if ( !(newNodes[i] = n2nIt->second ))
 708           break;
 709       }
 710       if ( !newNodes.back() )
 711         continue; // not all nodes of edge lie on theShape
 712
 713       // make a new edge
 714       SMDS_MeshElement * newEdge;
 715       if ( newNodes.size() == 3 )
 716         newEdge = tgtMesh->AddEdge( newNodes[0], newNodes[1], newNodes[2] );
 717       else
 718         newEdge = tgtMesh->AddEdge( newNodes[0], newNodes[1]);
 719       tgtMesh->SetMeshElementOnShape( newEdge, shapeID );
 720       e2e->insert( make_pair( edge, newEdge ));
 721     }
 722   }
 723   if ( n2n->empty())
 724     return error("Empty source groups");
 725
 726   // check if the whole geom edge is covered by imported segments;
 727   // the check consist in passing by segments from one vetrex node to another
 728   bool isEdgeMeshed = false;
 729   if ( SMESHDS_SubMesh* tgtSM = tgtMesh->MeshElements( theShape ))
 730   {
 731     const TopoDS_Vertex& v = ( vExp.ReInit(), TopoDS::Vertex( vExp.Current() ));
 732     const SMDS_MeshNode* n = SMESH_Algo::VertexNode( v, tgtMesh );
 733     const SMDS_MeshElement* seg = 0;
 734     SMDS_ElemIteratorPtr segIt = n->GetInverseElementIterator(SMDSAbs_Edge);
 735     while ( segIt->more() && !seg )
 736       if ( !tgtSM->Contains( seg = segIt->next()))
 737         seg = 0;
 738     int nbPassedSegs = 0;
 739     while ( seg )
 740     {
 741       ++nbPassedSegs;
 742       const SMDS_MeshNode* n2 = seg->GetNode(0);
 743       n = ( n2 == n ? seg->GetNode(1) : n2 );
 744       if ( n->GetPosition()->GetTypeOfPosition() == SMDS_TOP_VERTEX )
 745         break;
 746       const SMDS_MeshElement* seg2 = 0;
 747       segIt = n->GetInverseElementIterator(SMDSAbs_Edge);
 748       while ( segIt->more() && !seg2 )
 749         if ( seg == ( seg2 = segIt->next()))
 750           seg2 = 0;
 751       seg = seg2;
 752     }
 753     if (nbPassedSegs > 0 && tgtSM->NbElements() > nbPassedSegs )
 754       return error( "Source elements overlap one another");
 755
 756     isEdgeMeshed = ( tgtSM->NbElements() == nbPassedSegs &&
 757                      n->GetPosition()->GetTypeOfPosition() == SMDS_TOP_VERTEX );
 758   }
 759   if ( !isEdgeMeshed )
 760     return error( "Source elements don't cover totally the geometrical edge" );
 761
 762   // copy meshes
 763   vector<SMESH_Mesh*> srcMeshes = _sourceHyp->GetSourceMeshes();
 764   for ( unsigned i = 0; i < srcMeshes.size(); ++i )
 765     importMesh( srcMeshes[i], theMesh, _sourceHyp, theShape );
 766
 767   return true;
 768 }
 769
 770 //================================================================================
 771 /*!
 772  * \brief Copy mesh and groups
 773  */
 774 //================================================================================
 775
 776 void StdMeshers_Import_1D::importMesh(const SMESH_Mesh*          srcMesh,
 777                                       SMESH_Mesh &               tgtMesh,
 778                                       StdMeshers_ImportSource1D* srcHyp,
 779                                       const TopoDS_Shape&        tgtShape)
 780 {
 781   // get submesh to store the imported mesh
 782   TNodeNodeMap* n2n;
 783   TElemElemMap* e2e;
 784   bool toCopyGroups;
 785   SMESHDS_SubMesh* tgtSubMesh =
 786     getSubmeshForCopiedMesh( srcMesh, &tgtMesh, tgtShape, n2n, e2e, toCopyGroups );
 787   if ( !tgtSubMesh || tgtSubMesh->NbNodes() + tgtSubMesh->NbElements() > 0 )
 788     return; // not to copy srcMeshDS twice
 789
 790   SMESHDS_Mesh* tgtMeshDS = tgtMesh.GetMeshDS();
 791   SMESH_MeshEditor additor( &tgtMesh );
 792
 793   // 1. Copy mesh
 794
 795   vector<const SMDS_MeshNode*> newNodes;
 796   const SMESHDS_Mesh* srcMeshDS = srcMesh->GetMeshDS();
 797   SMDS_ElemIteratorPtr eIt = srcMeshDS->elementsIterator();
 798   while ( eIt->more() )
 799   {
 800     const SMDS_MeshElement* elem = eIt->next();
 801     TElemElemMap::iterator e2eIt = e2e->insert( make_pair( elem, (SMDS_MeshElement*)0 )).first;
 802     if ( e2eIt->second ) continue; // already copied by Compute()
 803     newNodes.resize( elem->NbNodes() );
 804     SMDS_MeshElement::iterator node = elem->begin_nodes();
 805     for ( unsigned i = 0; i < newNodes.size(); ++i, ++node )
 806     {
 807       TNodeNodeMap::iterator n2nIt = n2n->insert( make_pair( *node, (SMDS_MeshNode*)0 )).first;
 808       if ( !n2nIt->second )
 809       {
 810         (*n2nIt).second = tgtMeshDS->AddNode( (*node)->X(), (*node)->Y(), (*node)->Z());
 811         tgtSubMesh->AddNode( n2nIt->second );
 812       }
 813       newNodes[i] = n2nIt->second;
 814     }
 815     const SMDS_MeshElement* newElem =
 816       tgtMeshDS->FindElement( newNodes, elem->GetType(), /*noMedium=*/false );
 817     if ( !newElem )
 818     {
 819       newElem = additor.AddElement( newNodes, elem->GetType(), elem->IsPoly());
 820       tgtSubMesh->AddElement( newElem );
 821     }
 822     if ( toCopyGroups )
 823       (*e2eIt).second = newElem;
 824   }
 825   // copy free nodes
 826   if ( srcMeshDS->NbNodes() > n2n->size() )
 827   {
 828     SMDS_NodeIteratorPtr nIt = srcMeshDS->nodesIterator();
 829     while( nIt->more() )
 830     {
 831       const SMDS_MeshNode* node = nIt->next();
 832       if ( node->NbInverseElements() == 0 )
 833       {
 834         const SMDS_MeshNode* newNode = tgtMeshDS->AddNode( node->X(), node->Y(), node->Z());
 835         n2n->insert( make_pair( node, newNode ));
 836         tgtSubMesh->AddNode( newNode );
 837       }
 838     }
 839   }
 840
 841   // 2. Copy groups
 842
 843   vector<SMESH_Group*> resultGroups;
 844   if ( toCopyGroups )
 845   {
 846     // collect names of existing groups to assure uniqueness of group names within a type
 847     map< SMDSAbs_ElementType, set<string> > namesByType;
 848     SMESH_Mesh::GroupIteratorPtr groupIt = tgtMesh.GetGroups();
 849     while ( groupIt->more() )
 850     {
 851       SMESH_Group* tgtGroup = groupIt->next();
 852       namesByType[ tgtGroup->GetGroupDS()->GetType() ].insert( tgtGroup->GetName() );
 853     }
 854     if (srcMesh)
 855     {
 856       SMESH_Mesh::GroupIteratorPtr groupIt = srcMesh->GetGroups();
 857       while ( groupIt->more() )
 858       {
 859         SMESH_Group* srcGroup = groupIt->next();
 860         SMESHDS_GroupBase* srcGroupDS = srcGroup->GetGroupDS();
 861         string name = srcGroup->GetName();
 862         int nb = 1;
 863         while ( !namesByType[ srcGroupDS->GetType() ].insert( name ).second )
 864           name = SMESH_Comment(srcGroup->GetName()) << "_imported_" << nb++;
 865         SMESH_Group* newGroup = tgtMesh.AddGroup( srcGroupDS->GetType(), name.c_str(), nb );
 866         SMESHDS_Group* newGroupDS = (SMESHDS_Group*)newGroup->GetGroupDS();
 867         resultGroups.push_back( newGroup );
 868
 869         eIt = srcGroupDS->GetElements();
 870         if ( srcGroupDS->GetType() == SMDSAbs_Node )
 871           while (eIt->more())
 872           {
 873             TNodeNodeMap::iterator n2nIt = n2n->find((const SMDS_MeshNode*) eIt->next() );
 874             if ( n2nIt != n2n->end() && n2nIt->second )
 875               newGroupDS->SMDSGroup().Add((*n2nIt).second );
 876           }
 877         else
 878           while (eIt->more())
 879           {
 880             TElemElemMap::iterator e2eIt = e2e->find( eIt->next() );
 881             if ( e2eIt != e2e->end() && e2eIt->second )
 882               newGroupDS->SMDSGroup().Add((*e2eIt).second );
 883           }
 884       }
 885     }
 886   }
 887   n2n->clear();
 888   e2e->clear();
 889
 890   // Remember created groups in order to remove them as soon as the srcHyp is
 891   // modified or something other similar happens. Store them in a hypothesis
 892   // as it stores its values anyway
 893   srcHyp->StoreResultGroups( resultGroups, *srcMeshDS, *tgtMeshDS );
 894 }
 895
 896 //=============================================================================
 897 /*!
 898  * \brief Set needed event listeners and create a submesh for a copied mesh
 899  *
 900  * This method is called only if a submesh has HYP_OK algo_state.
 901  */
 902 //=============================================================================
 903
 904 void StdMeshers_Import_1D::setEventListener(SMESH_subMesh*             subMesh,
 905                                             StdMeshers_ImportSource1D* sourceHyp)
 906 {
 907   if ( sourceHyp )
 908   {
 909     vector<SMESH_Mesh*> srcMeshes = sourceHyp->GetSourceMeshes();
 910     if ( srcMeshes.empty() )
 911       _Listener::waitHypModification( subMesh );
 912     for ( unsigned i = 0; i < srcMeshes.size(); ++i )
 913       // set a listener to remove the imported mesh and groups
 914       _Listener::storeImportSubmesh( subMesh, srcMeshes[i], sourceHyp );
 915   }
 916 }
 917 void StdMeshers_Import_1D::SetEventListener(SMESH_subMesh* subMesh)
 918 {
 919   if ( !_sourceHyp )
 920   {
 921     const TopoDS_Shape& tgtShape = subMesh->GetSubShape();
 922     SMESH_Mesh*         tgtMesh  = subMesh->GetFather();
 923     Hypothesis_Status aStatus;
 924     CheckHypothesis( *tgtMesh, tgtShape, aStatus );
 925   }
 926   setEventListener( subMesh, _sourceHyp );
 927 }
 928
 929 void StdMeshers_Import_1D::SubmeshRestored(SMESH_subMesh* subMesh)
 930 {
 931   SetEventListener(subMesh);
 932 }
 933
 934 //=============================================================================
 935 /*!
 936  * Predict nb of mesh entities created by Compute()
 937  */
 938 //=============================================================================
 939
 940 bool StdMeshers_Import_1D::Evaluate(SMESH_Mesh &         theMesh,
 941                                     const TopoDS_Shape & theShape,
 942                                     MapShapeNbElems&     aResMap)
 943 {
 944   if ( !_sourceHyp ) return false;
 945
 946   const vector<SMESH_Group*>& srcGroups = _sourceHyp->GetGroups();
 947   if ( srcGroups.empty() )
 948     return error("Invalid source groups");
 949
 950   vector<int> aVec(SMDSEntity_Last,0);
 951
 952   bool toCopyMesh, toCopyGroups;
 953   _sourceHyp->GetCopySourceMesh(toCopyMesh, toCopyGroups);
 954   if ( toCopyMesh ) // the whole mesh is copied
 955   {
 956     vector<SMESH_Mesh*> srcMeshes = _sourceHyp->GetSourceMeshes();
 957     for ( unsigned i = 0; i < srcMeshes.size(); ++i )
 958     {
 959       SMESH_subMesh* sm = getSubMeshOfCopiedMesh( theMesh, *srcMeshes[i]);
 960       if ( !sm || aResMap.count( sm )) continue; // already counted
 961       aVec.assign( SMDSEntity_Last, 0);
 962       const SMDS_MeshInfo& aMeshInfo = srcMeshes[i]->GetMeshDS()->GetMeshInfo();
 963       for (int i = 0; i < SMDSEntity_Last; i++)
 964         aVec[i] = aMeshInfo.NbEntities((SMDSAbs_EntityType)i);
 965     }
 966   }
 967   else
 968   {
 969     SMESH_MesherHelper helper(theMesh);
 970
 971     const TopoDS_Edge& geomEdge = TopoDS::Edge( theShape );
 972     const double edgeTol = helper.MaxTolerance( geomEdge );
 973
 974     // take into account nodes on vertices
 975     TopExp_Explorer vExp( theShape, TopAbs_VERTEX );
 976     for ( ; vExp.More(); vExp.Next() )
 977       theMesh.GetSubMesh( vExp.Current())->Evaluate( aResMap );
 978
 979     // count edges imported from groups
 980     int nbEdges = 0, nbQuadEdges = 0;
 981     for ( int iG = 0; iG < srcGroups.size(); ++iG )
 982     {
 983       const SMESHDS_GroupBase* srcGroup = srcGroups[iG]->GetGroupDS();
 984       SMDS_ElemIteratorPtr srcElems = srcGroup->GetElements();
 985       SMDS_MeshNode tmpNode(0,0,0);
 986       while ( srcElems->more() ) // loop on group contents
 987       {
 988         const SMDS_MeshElement* edge = srcElems->next();
 989         // find out if edge is located on geomEdge by projecting
 990         // a middle of edge to geomEdge
 991         SMESH_MeshEditor::TNodeXYZ p1( edge->GetNode(0));
 992         SMESH_MeshEditor::TNodeXYZ p2( edge->GetNode(1));
 993         gp_XYZ middle = ( p1 + p2 ) / 2.;
 994         tmpNode.setXYZ( middle.X(), middle.Y(), middle.Z());
 995         double u = 0;
 996         if ( helper.CheckNodeU( geomEdge, &tmpNode, u, 10 * edgeTol, /*force=*/true ))
 997           ++( edge->IsQuadratic() ? nbQuadEdges : nbEdges);
 998       }
 999     }
1000
1001     int nbNodes = nbEdges + 2 * nbQuadEdges - 1;
1002
1003     aVec[SMDSEntity_Node     ] = nbNodes;
1004     aVec[SMDSEntity_Edge     ] = nbEdges;
1005     aVec[SMDSEntity_Quad_Edge] = nbQuadEdges;
1006   }
1007
1008   SMESH_subMesh * sm = theMesh.GetSubMesh(theShape);
1009   aResMap.insert(make_pair(sm,aVec));
1010
1011   return true;
1012 }
1013
1014 //================================================================================
1015 /*!
1016  * \brief Return node-node and element-element maps for import of geiven source mesh
1017  */
1018 //================================================================================
1019
1020 void StdMeshers_Import_1D::getMaps(const SMESH_Mesh* srcMesh,
1021                                    SMESH_Mesh*       tgtMesh,
1022                                    TNodeNodeMap*&    n2n,
1023                                    TElemElemMap*&    e2e)
1024 {
1025   _ImportData* iData = _Listener::getImportData(srcMesh,tgtMesh);
1026   n2n = &iData->_n2n;
1027   e2e = &iData->_e2e;
1028   if ( iData->_copyMeshSubM.empty() )
1029   {
1030     n2n->clear();
1031     e2e->clear();
1032   }
1033 }
1034
1035 //================================================================================
1036 /*!
1037  * \brief Return submesh corresponding to the copied mesh
1038  */
1039 //================================================================================
1040
1041 SMESH_subMesh* StdMeshers_Import_1D::getSubMeshOfCopiedMesh( SMESH_Mesh& tgtMesh,
1042                                                              SMESH_Mesh& srcMesh )
1043 {
1044   _ImportData* iData = _Listener::getImportData(&srcMesh,&tgtMesh);
1045   if ( iData->_copyMeshSubM.empty() ) return 0;
1046   SMESH_subMesh* sm = tgtMesh.GetSubMeshContaining( iData->_importMeshSubID );
1047   return sm;
1048 }
1049