src/StdMeshers/StdMeshers_Import_1D.cxx

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