src/StdMeshers/StdMeshers_Import_1D.cxx

   1 // Copyright (C) 2007-2020  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, or (at your option) any later version.
  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 : implementation 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_MeshEditor.hxx"
  40 #include "SMESH_MesherHelper.hxx"
  41 #include "SMESH_Octree.hxx"
  42 #include "SMESH_subMesh.hxx"
  43 #include "SMESH_subMeshEventListener.hxx"
  44
  45 #include "Utils_SALOME_Exception.hxx"
  46 #include "utilities.h"
  47
  48 #include <BRepAdaptor_Curve.hxx>
  49 #include <BRep_Builder.hxx>
  50 #include <BRep_Tool.hxx>
  51 #include <BndLib_Add3dCurve.hxx>
  52 #include <GCPnts_TangentialDeflection.hxx>
  53 #include <ShapeAnalysis_Curve.hxx>
  54 #include <TopExp.hxx>
  55 #include <TopExp_Explorer.hxx>
  56 #include <TopoDS.hxx>
  57 #include <TopoDS_Compound.hxx>
  58 #include <TopoDS_Edge.hxx>
  59 #include <TopoDS_Vertex.hxx>
  60
  61 using namespace std;
  62
  63 //================================================================================
  64 namespace // INTERNAL STUFF
  65 //================================================================================
  66 {
  67   /*!
  68    * \brief Compute point position on a curve. Use octree to fast reject far points
  69    */
  70   class CurveProjector : public SMESH_Octree
  71   {
  72   public:
  73     CurveProjector( const TopoDS_Edge& edge, double enlarge );
  74
  75     bool IsOnCurve( const gp_XYZ& point, double & distance2, double & u );
  76
  77     bool IsOut( const gp_XYZ& point ) const { return getBox()->IsOut( point ); }
  78
  79   protected:
  80     CurveProjector() {}
  81     SMESH_Octree* newChild() const { return new CurveProjector; }
  82     void          buildChildrenData();
  83     Bnd_B3d*      buildRootBox();
  84
  85   private:
  86     struct CurveSegment : public Bnd_B3d
  87     {
  88       double _chord, _chord2, _length2;
  89       gp_Pnt _pFirst, _pLast;
  90       gp_Lin _line;
  91       Handle(Geom_Curve) _curve;
  92
  93       CurveSegment() {}
  94       void Init( const gp_Pnt& pf, const gp_Pnt& pl,
  95                  double uf, double ul, double tol, Handle(Geom_Curve)& curve );
  96       bool IsOn( const gp_XYZ& point, double & distance2, double & u );
  97       bool IsInContact( const Bnd_B3d& bb );
  98     };
  99     std::vector< CurveSegment > _segments;
 100   };
 101
 102   //===============================================================================
 103   /*!
 104    * \brief Create an octree of curve segments
 105    */
 106   //================================================================================
 107
 108   CurveProjector::CurveProjector( const TopoDS_Edge& edge, double enlarge )
 109     :SMESH_Octree( 0 )
 110   {
 111     double f,l;
 112     Handle(Geom_Curve) curve = BRep_Tool::Curve( edge, f, l );
 113     double curDeflect = 0.3; // Curvature deflection
 114     double angDeflect = 1e+100; // Angular deflection - don't control chordal error
 115     GCPnts_TangentialDeflection div( BRepAdaptor_Curve( edge ), angDeflect, curDeflect );
 116     _segments.resize( div.NbPoints() - 1 );
 117     for ( int i = 1; i < div.NbPoints(); ++i )
 118       try {
 119         _segments[ i - 1 ].Init( div.Value( i ),     div.Value( i+1 ),
 120                                  div.Parameter( i ), div.Parameter( i+1 ),
 121                                  enlarge, curve );
 122       }
 123       catch ( Standard_Failure ) {
 124         _segments.resize( _segments.size() - 1 );
 125         --i;
 126       }
 127     if ( _segments.size() < 3 )
 128       myIsLeaf = true;
 129
 130     compute();
 131
 132     if ( _segments.size() == 1 )
 133       myBox->Enlarge( enlarge );
 134   }
 135
 136   //================================================================================
 137   /*!
 138    * \brief Return the maximal box
 139    */
 140   //================================================================================
 141
 142   Bnd_B3d* CurveProjector::buildRootBox()
 143   {
 144     Bnd_B3d* box = new Bnd_B3d;
 145     for ( size_t i = 0; i < _segments.size(); ++i )
 146       box->Add( _segments[i] );
 147     return box;
 148   }
 149
 150   //================================================================================
 151   /*!
 152    * \brief Redistribute segments among children
 153    */
 154   //================================================================================
 155
 156   void CurveProjector::buildChildrenData()
 157   {
 158     bool allIn = true;
 159     for ( size_t i = 0; i < _segments.size(); ++i )
 160     {
 161       for (int j = 0; j < 8; j++)
 162       {
 163         if ( _segments[i].IsInContact( *myChildren[j]->getBox() ))
 164           ((CurveProjector*)myChildren[j])->_segments.push_back( _segments[i]);
 165         else
 166           allIn = false;
 167       }
 168     }
 169     if ( allIn && _segments.size() < 3 )
 170     {
 171       myIsLeaf = true;
 172       for (int j = 0; j < 8; j++)
 173         static_cast<CurveProjector*>( myChildren[j])->myIsLeaf = true;
 174     }
 175     else
 176     {
 177       SMESHUtils::FreeVector( _segments ); // = _segments.clear() + free memory
 178
 179       for (int j = 0; j < 8; j++)
 180       {
 181         CurveProjector* child = static_cast<CurveProjector*>( myChildren[j]);
 182         if ( child->_segments.size() < 3 )
 183           child->myIsLeaf = true;
 184       }
 185     }
 186   }
 187
 188   //================================================================================
 189   /*!
 190    * \brief Return true if a point is close to the curve
 191    *  \param [in] point - the point
 192    *  \param [out] distance2 - distance to the curve
 193    *  \param [out] u - parameter on the curve
 194    *  \return bool - is the point is close to the curve
 195    */
 196   //================================================================================
 197
 198   bool CurveProjector::IsOnCurve( const gp_XYZ& point, double & distance2, double & u )
 199   {
 200     if ( getBox()->IsOut( point ))
 201       return false;
 202
 203     bool ok = false;
 204     double dist2, param;
 205     distance2 = Precision::Infinite();
 206
 207     if ( isLeaf() )
 208     {
 209       for ( size_t i = 0; i < _segments.size(); ++i )
 210         if ( !_segments[i].IsOut( point ) &&
 211              _segments[i].IsOn( point, dist2, param ) &&
 212              dist2 < distance2 )
 213         {
 214           distance2 = dist2;
 215           u         = param;
 216           ok        = true;
 217         }
 218       return ok;
 219     }
 220     else
 221     {
 222       for (int i = 0; i < 8; i++)
 223         if (((CurveProjector*) myChildren[i])->IsOnCurve( point, dist2, param ) &&
 224             dist2 < distance2 )
 225         {
 226           distance2 = dist2;
 227           u         = param;
 228           ok        = true;
 229         }
 230     }
 231     return ok;
 232   }
 233
 234   //================================================================================
 235   /*!
 236    * \brief Initialize
 237    */
 238   //================================================================================
 239
 240   void CurveProjector::CurveSegment::Init(const gp_Pnt&       pf,
 241                                           const gp_Pnt&       pl,
 242                                           const double        uf,
 243                                           const double        ul,
 244                                           const double        tol,
 245                                           Handle(Geom_Curve)& curve )
 246   {
 247     _pFirst  = pf;
 248     _pLast   = pl;
 249     _curve   = curve;
 250     _length2 = pf.SquareDistance( pl );
 251     _line.SetLocation( pf );
 252     _line.SetDirection( gp_Vec( pf, pl ));
 253     _chord2  = Max( _line.     SquareDistance( curve->Value( uf + 0.25 * ( ul - uf ))),
 254                     Max( _line.SquareDistance( curve->Value( uf + 0.5  * ( ul - uf ))),
 255                          _line.SquareDistance( curve->Value( uf + 0.75 * ( ul - uf )))));
 256     _chord2  = Max( tol, _chord2 );
 257     _chord   = Sqrt( _chord2 );
 258
 259     Bnd_Box bb;
 260     BndLib_Add3dCurve::Add( GeomAdaptor_Curve( curve, uf, ul ), tol, bb );
 261     Add( bb.CornerMin() );
 262     Add( bb.CornerMax() );
 263   }
 264
 265   //================================================================================
 266   /*!
 267    * \brief Return true if a point is close to the curve segment
 268    *  \param [in] point - the point
 269    *  \param [out] distance2 - distance to the curve
 270    *  \param [out] u - parameter on the curve
 271    *  \return bool - is the point is close to the curve segment
 272    */
 273   //================================================================================
 274
 275   bool CurveProjector::CurveSegment::IsOn( const gp_XYZ& point, double & distance2, double & u )
 276   {
 277     distance2 = _line.SquareDistance( point );
 278     if ( distance2 > _chord2 )
 279       return false;
 280
 281     // check if the point projection falls into the segment range
 282     {
 283       gp_Vec edge( _pFirst, _pLast );
 284       gp_Vec n1p ( _pFirst, point  );
 285       u = ( edge * n1p ) / _length2; // param [0,1] on the edge
 286       if ( u < 0. )
 287       {
 288         if ( _pFirst.SquareDistance( point ) > _chord2 )
 289           return false;
 290       }
 291       else if ( u > 1. )
 292       {
 293         if ( _pLast.SquareDistance( point ) > _chord2 )
 294           return false;
 295       }
 296     }
 297     gp_Pnt proj;
 298     distance2 = ShapeAnalysis_Curve().Project( _curve, point, Precision::Confusion(),
 299                                                proj, u, false );
 300     distance2 *= distance2;
 301     return true;
 302   }
 303
 304   //================================================================================
 305   /*!
 306    * \brief Check if the segment is in contact with a box
 307    */
 308   //================================================================================
 309
 310   bool CurveProjector::CurveSegment::IsInContact( const Bnd_B3d& bb )
 311   {
 312     if ( bb.IsOut( _line.Position(), /*isRay=*/true, _chord ))
 313       return false;
 314
 315     gp_Ax1 axRev = _line.Position().Reversed();
 316     axRev.SetLocation( _pLast );
 317     return !bb.IsOut( axRev, /*isRay=*/true, _chord );
 318   }
 319
 320   //================================================================================
 321   //================================================================================
 322
 323   int getSubmeshIDForCopiedMesh(const SMESHDS_Mesh* srcMeshDS, SMESH_Mesh* tgtMesh);
 324
 325   enum _ListenerDataType
 326     {
 327       WAIT_HYP_MODIF=1, // data indicating awaiting for valid parameters of src hyp
 328       LISTEN_SRC_MESH, // data storing submesh depending on source mesh state
 329       SRC_HYP // data storing ImportSource hyp
 330     };
 331   //================================================================================
 332   /*!
 333    * \brief _ListenerData holding ImportSource hyp holding in its turn
 334    *  imported groups
 335    */
 336   struct _ListenerData : public SMESH_subMeshEventListenerData
 337   {
 338     const StdMeshers_ImportSource1D* _srcHyp;
 339     _ListenerData(const StdMeshers_ImportSource1D* h, _ListenerDataType type=SRC_HYP):
 340       SMESH_subMeshEventListenerData(/*isDeletable=*/true), _srcHyp(h)
 341     {
 342       myType = type;
 343     }
 344   };
 345   //================================================================================
 346   /*!
 347    * \brief Comparator of sub-meshes
 348    */
 349   struct _SubLess
 350   {
 351     bool operator()(const SMESH_subMesh* sm1, const SMESH_subMesh* sm2 ) const
 352     {
 353       if ( sm1 == sm2 ) return false;
 354       if ( !sm1 || !sm2 ) return sm1 < sm2;
 355       const TopoDS_Shape& s1 = sm1->GetSubShape();
 356       const TopoDS_Shape& s2 = sm2->GetSubShape();
 357       TopAbs_ShapeEnum t1 = s1.IsNull() ? TopAbs_SHAPE : s1.ShapeType();
 358       TopAbs_ShapeEnum t2 = s2.IsNull() ? TopAbs_SHAPE : s2.ShapeType();
 359       if ( t1 == t2)
 360         return (sm1 < sm2);
 361       return t1 < t2; // to have: face < edge
 362     }
 363   };
 364   //================================================================================
 365   /*!
 366    * \brief Container of data dedicated to one source mesh
 367    */
 368   struct _ImportData
 369   {
 370     const SMESH_Mesh* _srcMesh;
 371     StdMeshers_Import_1D::TNodeNodeMap _n2n;
 372     StdMeshers_Import_1D::TElemElemMap _e2e;
 373
 374     set< SMESH_subMesh*, _SubLess > _subM; // submeshes relating to this srcMesh
 375     set< SMESH_subMesh*, _SubLess > _copyMeshSubM; // submeshes requesting mesh copying
 376     set< SMESH_subMesh*, _SubLess > _copyGroupSubM; // submeshes requesting group copying
 377     set< SMESH_subMesh*, _SubLess > _computedSubM;
 378
 379     SMESHDS_SubMesh*     _importMeshSubDS; // submesh storing a copy of _srcMesh
 380     int                  _importMeshSubID; // id of _importMeshSubDS
 381
 382     _ImportData(const SMESH_Mesh* srcMesh=0):
 383       _srcMesh(srcMesh), _importMeshSubDS(0),_importMeshSubID(-1) {}
 384
 385     void removeImportedMesh( SMESHDS_Mesh* meshDS )
 386     {
 387       if ( !_importMeshSubDS ) return;
 388       SMDS_ElemIteratorPtr eIt = _importMeshSubDS->GetElements();
 389       while ( eIt->more() )
 390         meshDS->RemoveFreeElement( eIt->next(), 0, /*fromGroups=*/false );
 391       SMDS_NodeIteratorPtr nIt = _importMeshSubDS->GetNodes();
 392       while ( nIt->more() )
 393         meshDS->RemoveFreeNode( nIt->next(), 0, /*fromGroups=*/false );
 394       _importMeshSubDS->Clear();
 395       _n2n.clear();
 396       _e2e.clear();
 397     }
 398     void removeGroups( SMESH_subMesh* subM, const StdMeshers_ImportSource1D* srcHyp )
 399     {
 400       if ( !srcHyp ) return;
 401       SMESH_Mesh*           tgtMesh = subM->GetFather();
 402       const SMESHDS_Mesh* tgtMeshDS = tgtMesh->GetMeshDS();
 403       const SMESHDS_Mesh* srcMeshDS = _srcMesh->GetMeshDS();
 404       vector<SMESH_Group*>*  groups =
 405         const_cast<StdMeshers_ImportSource1D*>(srcHyp)->GetResultGroups(*srcMeshDS,*tgtMeshDS);
 406       if ( groups )
 407       {
 408         for ( unsigned i = 0; i < groups->size(); ++i )
 409           tgtMesh->RemoveGroup( groups->at(i)->GetGroupDS()->GetID() );
 410         groups->clear();
 411       }
 412     }
 413     void trackHypParams( SMESH_subMesh* sm, const StdMeshers_ImportSource1D* srcHyp )
 414     {
 415       if ( !srcHyp ) return;
 416       bool toCopyMesh, toCopyGroups;
 417       srcHyp->GetCopySourceMesh(toCopyMesh, toCopyGroups);
 418
 419       if ( toCopyMesh )_copyMeshSubM.insert( sm );
 420       else             _copyMeshSubM.erase( sm );
 421
 422       if ( toCopyGroups ) _copyGroupSubM.insert( sm );
 423       else                _copyGroupSubM.erase( sm );
 424     }
 425     void addComputed( SMESH_subMesh* sm )
 426     {
 427       SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator(/*includeSelf=*/true,
 428                                                                /*complexShapeFirst=*/true);
 429       while ( smIt->more() )
 430       {
 431         sm = smIt->next();
 432         switch ( sm->GetSubShape().ShapeType() )
 433         {
 434         case TopAbs_EDGE:
 435           if ( SMESH_Algo::isDegenerated( TopoDS::Edge( sm->GetSubShape() )))
 436             continue;
 437           // fall through
 438         case TopAbs_FACE:
 439           _subM.insert( sm );
 440           if ( !sm->IsEmpty() )
 441             _computedSubM.insert( sm );
 442         case TopAbs_VERTEX:
 443           break;
 444         default:;
 445         }
 446       }
 447     }
 448   };
 449   //================================================================================
 450   /*!
 451    * Listener notified on events relating to imported submesh
 452    */
 453   class _Listener : public SMESH_subMeshEventListener
 454   {
 455     typedef map< SMESH_Mesh*, list< _ImportData > > TMesh2ImpData;
 456     TMesh2ImpData _tgtMesh2ImportData;
 457
 458     _Listener():SMESH_subMeshEventListener(/*isDeletable=*/false,
 459                                            "StdMeshers_Import_1D::_Listener") {}
 460
 461   public:
 462     // return pointer to a static listener
 463     static _Listener* get() { static _Listener theListener; return &theListener; }
 464
 465     static _ImportData* getImportData(const SMESH_Mesh* srcMesh, SMESH_Mesh* tgtMesh);
 466
 467     static void storeImportSubmesh(SMESH_subMesh*                   importSub,
 468                                    const SMESH_Mesh*                srcMesh,
 469                                    const StdMeshers_ImportSource1D* srcHyp);
 470
 471     virtual void ProcessEvent(const int                       event,
 472                               const int                       eventType,
 473                               SMESH_subMesh*                  subMesh,
 474                               SMESH_subMeshEventListenerData* data,
 475                               const SMESH_Hypothesis*         hyp);
 476     void removeSubmesh( SMESH_subMesh* sm, _ListenerData* data );
 477     void clearSubmesh ( SMESH_subMesh* sm, _ListenerData* data, bool clearAllSub );
 478     void clearN2N     ( SMESH_Mesh* tgtMesh );
 479
 480     // mark sm as missing src hyp with valid groups
 481     static void waitHypModification(SMESH_subMesh* sm)
 482     {
 483       sm->SetEventListener
 484         (get(), SMESH_subMeshEventListenerData::MakeData( sm, WAIT_HYP_MODIF ), sm);
 485     }
 486   };
 487   //--------------------------------------------------------------------------------
 488   /*!
 489    * \brief Find or create ImportData for given meshes
 490    */
 491   _ImportData* _Listener::getImportData(const SMESH_Mesh* srcMesh,
 492                                         SMESH_Mesh*       tgtMesh)
 493   {
 494     list< _ImportData >& dList = get()->_tgtMesh2ImportData[tgtMesh];
 495     list< _ImportData >::iterator d = dList.begin();
 496     for ( ; d != dList.end(); ++d )
 497       if ( d->_srcMesh == srcMesh )
 498         return &*d;
 499     dList.push_back(_ImportData(srcMesh));
 500     return &dList.back();
 501   }
 502
 503   //--------------------------------------------------------------------------------
 504   /*!
 505    * \brief Remember an imported sub-mesh and set needed even listeners
 506    *  \param importSub - submesh computed by Import algo
 507    *  \param srcMesh - source mesh
 508    *  \param srcHyp - ImportSource hypothesis
 509    */
 510   void _Listener::storeImportSubmesh(SMESH_subMesh*                   importSub,
 511                                      const SMESH_Mesh*                srcMesh,
 512                                      const StdMeshers_ImportSource1D* srcHyp)
 513   {
 514     // set listener to hear events of the submesh computed by "Import" algo
 515     importSub->SetEventListener( get(), new _ListenerData(srcHyp), importSub );
 516
 517     // set listeners to hear events of the source mesh
 518     SMESH_subMesh* smToNotify = importSub;
 519     vector<SMESH_subMesh*> smToListen = srcHyp->GetSourceSubMeshes( srcMesh );
 520     for ( size_t i = 0; i < smToListen.size(); ++i )
 521     {
 522       SMESH_subMeshEventListenerData* data = new _ListenerData(srcHyp, LISTEN_SRC_MESH);
 523       data->mySubMeshes.push_back( smToNotify );
 524       importSub->SetEventListener( get(), data, smToListen[i] );
 525     }
 526     // remember the submesh importSub and its sub-submeshes
 527     _ImportData* iData = _Listener::getImportData( srcMesh, importSub->GetFather());
 528     iData->trackHypParams( importSub, srcHyp );
 529     iData->addComputed( importSub );
 530     if ( !iData->_copyMeshSubM.empty() && iData->_importMeshSubID < 1 )
 531     {
 532       SMESH_Mesh* tgtMesh = importSub->GetFather();
 533       iData->_importMeshSubID = getSubmeshIDForCopiedMesh( srcMesh->GetMeshDS(),tgtMesh);
 534       iData->_importMeshSubDS = tgtMesh->GetMeshDS()->NewSubMesh( iData->_importMeshSubID );
 535     }
 536   }
 537   //--------------------------------------------------------------------------------
 538   /*!
 539    * \brief Remove imported mesh and/or groups if needed
 540    *  \param sm - submesh losing Import algo
 541    *  \param data - data holding imported groups
 542    */
 543   void _Listener::removeSubmesh( SMESH_subMesh* sm, _ListenerData* data )
 544   {
 545     list< _ImportData > &  dList = _tgtMesh2ImportData[ sm->GetFather() ];
 546     list< _ImportData >::iterator d = dList.begin();
 547     for ( ; d != dList.end(); ++d )
 548       if ( (*d)._subM.erase( sm ))
 549       {
 550         d->_computedSubM.erase( sm );
 551         bool rmMesh   = d->_copyMeshSubM.erase( sm ) && d->_copyMeshSubM.empty();
 552         bool rmGroups = (d->_copyGroupSubM.erase( sm ) && d->_copyGroupSubM.empty()) || rmMesh;
 553         if ( rmMesh )
 554           d->removeImportedMesh( sm->GetFather()->GetMeshDS() );
 555         if ( rmGroups && data && data->myType == SRC_HYP )
 556           d->removeGroups( sm, data->_srcHyp );
 557       }
 558   }
 559   //--------------------------------------------------------------------------------
 560   /*!
 561    * \brief Clear _ImportData::_n2n.
 562    *        _n2n is useful within one mesh.Compute() only
 563    */
 564   void _Listener::clearN2N( SMESH_Mesh* tgtMesh )
 565   {
 566     list< _ImportData >& dList = get()->_tgtMesh2ImportData[tgtMesh];
 567     list< _ImportData >::iterator d = dList.begin();
 568     for ( ; d != dList.end(); ++d )
 569       d->_n2n.clear();
 570   }
 571   //--------------------------------------------------------------------------------
 572   /*!
 573    * \brief Clear submeshes and remove imported mesh and/or groups if necessary
 574    *  \param sm - cleared submesh
 575    *  \param data - data holding imported groups
 576    */
 577   void _Listener::clearSubmesh(SMESH_subMesh* sm, _ListenerData* data, bool clearAllSub)
 578   {
 579     list< _ImportData > &  dList = _tgtMesh2ImportData[ sm->GetFather() ];
 580     list< _ImportData >::iterator d = dList.begin();
 581     for ( ; d != dList.end(); ++d )
 582     {
 583       if ( !d->_subM.count( sm )) continue;
 584       if ( (*d)._computedSubM.erase( sm ) )
 585       {
 586         bool copyMesh = !d->_copyMeshSubM.empty();
 587         if ( copyMesh || clearAllSub )
 588         {
 589           // remove imported mesh and groups
 590           d->removeImportedMesh( sm->GetFather()->GetMeshDS() );
 591
 592           if ( data && data->myType == SRC_HYP )
 593             d->removeGroups( sm, data->_srcHyp );
 594
 595           // clear the rest submeshes
 596           if ( !d->_computedSubM.empty() )
 597           {
 598             d->_computedSubM.clear();
 599             set< SMESH_subMesh*, _SubLess>::iterator sub = d->_subM.begin();
 600             for ( ; sub != d->_subM.end(); ++sub )
 601             {
 602               SMESH_subMesh* subM = *sub;
 603               _ListenerData* hypData = (_ListenerData*) subM->GetEventListenerData( get() );
 604               if ( hypData && hypData->myType == SRC_HYP )
 605                 d->removeGroups( sm, hypData->_srcHyp );
 606
 607               subM->ComputeStateEngine( SMESH_subMesh::CLEAN );
 608               if ( subM->GetSubShape().ShapeType() == TopAbs_FACE )
 609                 subM->ComputeSubMeshStateEngine( SMESH_subMesh::CLEAN );
 610             }
 611           }
 612         }
 613         sm->ComputeStateEngine( SMESH_subMesh::CLEAN );
 614         if ( sm->GetSubShape().ShapeType() == TopAbs_FACE )
 615           sm->ComputeSubMeshStateEngine( SMESH_subMesh::CLEAN );
 616       }
 617       if ( data && data->myType == SRC_HYP )
 618         d->trackHypParams( sm, data->_srcHyp );
 619       d->_n2n.clear();
 620       d->_e2e.clear();
 621     }
 622   }
 623   //--------------------------------------------------------------------------------
 624   /*!
 625    * \brief Remove imported mesh and/or groups
 626    */
 627   void _Listener::ProcessEvent(const int                       event,
 628                                const int                       eventType,
 629                                SMESH_subMesh*                  subMesh,
 630                                SMESH_subMeshEventListenerData* data,
 631                                const SMESH_Hypothesis*         /*hyp*/)
 632   {
 633     if ( data && data->myType == WAIT_HYP_MODIF )
 634     {
 635       // event of Import submesh
 636       if ( SMESH_subMesh::MODIF_HYP  == event &&
 637            SMESH_subMesh::ALGO_EVENT == eventType )
 638       {
 639         // re-call SetEventListener() to take into account valid parameters
 640         // of ImportSource hypothesis
 641         if ( SMESH_Algo* algo = subMesh->GetAlgo() )
 642           algo->SetEventListener( subMesh );
 643       }
 644     }
 645     else if ( data && data->myType == LISTEN_SRC_MESH )
 646     {
 647       // event of source mesh
 648       if ( SMESH_subMesh::COMPUTE_EVENT == eventType )
 649       {
 650         switch ( event ) {
 651         case SMESH_subMesh::CLEAN:
 652           // source mesh cleaned -> clean target mesh
 653           clearSubmesh( data->mySubMeshes.front(), (_ListenerData*) data, /*all=*/true );
 654           break;
 655         case SMESH_subMesh::SUBMESH_COMPUTED: {
 656           // source mesh computed -> reset FAILED state of Import submeshes to
 657           // READY_TO_COMPUTE
 658           SMESH_Mesh* srcMesh = subMesh->GetFather();
 659           if ( srcMesh->NbEdges() > 0 || srcMesh->NbFaces() > 0 )
 660           {
 661             SMESH_Mesh* m = data->mySubMeshes.front()->GetFather();
 662             if ( SMESH_subMesh* sm1 = m->GetSubMeshContaining(1))
 663             {
 664               sm1->ComputeStateEngine(SMESH_subMesh::SUBMESH_COMPUTED );
 665               sm1->ComputeSubMeshStateEngine( SMESH_subMesh::SUBMESH_COMPUTED );
 666             }
 667           }
 668           break;
 669         }
 670         default:;
 671         }
 672       }
 673       if ( !data->mySubMeshes.empty() )
 674         clearN2N( data->mySubMeshes.front()->GetFather() );
 675     }
 676     else // event of Import submesh
 677     {
 678       // find out what happens: import hyp modified or removed
 679       bool removeImport = false, modifHyp = false;
 680       if ( SMESH_subMesh::ALGO_EVENT == eventType )
 681         modifHyp = true;
 682       if ( subMesh->GetAlgoState() != SMESH_subMesh::HYP_OK )
 683       {
 684         removeImport = true;
 685       }
 686       else if (( SMESH_subMesh::REMOVE_ALGO == event ||
 687                  SMESH_subMesh::REMOVE_FATHER_ALGO == event ) &&
 688                SMESH_subMesh::ALGO_EVENT == eventType )
 689       {
 690         SMESH_Algo* algo = subMesh->GetAlgo();
 691         removeImport = ( strncmp( "Import", algo->GetName(), 6 ) != 0 );
 692       }
 693
 694       if ( removeImport )
 695       {
 696         // treate removal of Import algo from subMesh
 697         removeSubmesh( subMesh, (_ListenerData*) data );
 698       }
 699       else if ( modifHyp ||
 700                 ( SMESH_subMesh::CLEAN         == event &&
 701                   SMESH_subMesh::COMPUTE_EVENT == eventType))
 702       {
 703         // treate modification of ImportSource hypothesis
 704         clearSubmesh( subMesh, (_ListenerData*) data, /*all=*/false );
 705       }
 706       else if ( SMESH_subMesh::CHECK_COMPUTE_STATE == event &&
 707                 SMESH_subMesh::COMPUTE_EVENT       == eventType )
 708       {
 709         // check compute state of all submeshes impoting from same src mesh;
 710         // this is to take into account 1D computed submeshes hidden by 2D import algo;
 711         // else source mesh is not copied as _subM.size != _computedSubM.size()
 712         list< _ImportData > &  dList = _tgtMesh2ImportData[ subMesh->GetFather() ];
 713         list< _ImportData >::iterator d = dList.begin();
 714         for ( ; d != dList.end(); ++d )
 715           if ( d->_subM.count( subMesh ))
 716           {
 717             set<SMESH_subMesh*,_SubLess>::iterator smIt = d->_subM.begin();
 718             for( ; smIt != d->_subM.end(); ++smIt )
 719               if ( (*smIt)->IsMeshComputed() )
 720                 d->_computedSubM.insert( *smIt);
 721           }
 722       }
 723       // Clear _ImportData::_n2n if it's no more useful, i.e. when
 724       // the event is not within mesh.Compute()
 725       if ( SMESH_subMesh::ALGO_EVENT == eventType )
 726         clearN2N( subMesh->GetFather() );
 727     }
 728   }
 729
 730   //================================================================================
 731   /*!
 732    * \brief Return an ID of submesh to store nodes and elements of a copied mesh
 733    */
 734   //================================================================================
 735
 736   int getSubmeshIDForCopiedMesh(const SMESHDS_Mesh* srcMeshDS,
 737                                 SMESH_Mesh*         tgtMesh)
 738   {
 739     // To get SMESH_subMesh corresponding to srcMeshDS we need to have a shape
 740     // for which SMESHDS_Mesh::IsGroupOfSubShapes() returns true.
 741     // And this shape must be different from sub-shapes of the main shape.
 742     // So we create a compound containing
 743     // 1) some sub-shapes of SMESH_Mesh::PseudoShape() corresponding to
 744     //    srcMeshDS->GetPersistentId()
 745     // 2) the 1-st vertex of the main shape to assure
 746     //    SMESHDS_Mesh::IsGroupOfSubShapes(shape)==true
 747     TopoDS_Shape shapeForSrcMesh;
 748     TopTools_IndexedMapOfShape pseudoSubShapes;
 749     TopExp::MapShapes( SMESH_Mesh::PseudoShape(), pseudoSubShapes );
 750
 751     // index of pseudoSubShapes corresponding to srcMeshDS
 752     int    subIndex = 1 + srcMeshDS->GetPersistentId() % pseudoSubShapes.Extent();
 753     int nbSubShapes = 1 + srcMeshDS->GetPersistentId() / pseudoSubShapes.Extent();
 754
 755     // try to find already present shapeForSrcMesh
 756     SMESHDS_Mesh* tgtMeshDS = tgtMesh->GetMeshDS();
 757     for ( int i = tgtMeshDS->MaxShapeIndex(); i > 0 && shapeForSrcMesh.IsNull(); --i )
 758     {
 759       const TopoDS_Shape& s = tgtMeshDS->IndexToShape(i);
 760       if ( s.ShapeType() != TopAbs_COMPOUND ) break;
 761       TopoDS_Iterator sSubIt( s );
 762       for ( int iSub = 0; iSub < nbSubShapes && sSubIt.More(); ++iSub, sSubIt.Next() )
 763         if ( pseudoSubShapes( subIndex+iSub ).IsSame( sSubIt.Value()))
 764           if ( iSub+1 == nbSubShapes )
 765           {
 766             shapeForSrcMesh = s;
 767             break;
 768           }
 769     }
 770     if ( shapeForSrcMesh.IsNull() )
 771     {
 772       // make a new shapeForSrcMesh
 773       BRep_Builder aBuilder;
 774       TopoDS_Compound comp;
 775       aBuilder.MakeCompound( comp );
 776       shapeForSrcMesh = comp;
 777       for ( int iSub = 0; iSub < nbSubShapes; ++iSub )
 778         if ( subIndex+iSub <= pseudoSubShapes.Extent() )
 779           aBuilder.Add( comp, pseudoSubShapes( subIndex+iSub ));
 780       TopExp_Explorer vExp( tgtMeshDS->ShapeToMesh(), TopAbs_VERTEX );
 781       aBuilder.Add( comp, vExp.Current() );
 782     }
 783     SMESH_subMesh* sm = tgtMesh->GetSubMesh( shapeForSrcMesh );
 784     SMESHDS_SubMesh* smDS = sm->GetSubMeshDS();
 785     if ( !smDS )
 786       smDS = tgtMeshDS->NewSubMesh( sm->GetId() );
 787
 788     // make ordinary submesh from a complex one
 789     if ( smDS->IsComplexSubmesh() )
 790     {
 791       list< const SMESHDS_SubMesh* > subSM;
 792       SMESHDS_SubMeshIteratorPtr smIt = smDS->GetSubMeshIterator();
 793       while ( smIt->more() ) subSM.push_back( smIt->next() );
 794       list< const SMESHDS_SubMesh* >::iterator sub = subSM.begin();
 795       for ( ; sub != subSM.end(); ++sub)
 796         smDS->RemoveSubMesh( *sub );
 797     }
 798     return sm->GetId();
 799   }
 800
 801   //================================================================================
 802   /*!
 803    * \brief Return a submesh to store nodes and elements of a copied mesh
 804    * and set event listeners in order to clear
 805    * imported mesh and groups as soon as submesh state requires it
 806    */
 807   //================================================================================
 808
 809   SMESHDS_SubMesh* getSubmeshForCopiedMesh(const SMESH_Mesh*                    srcMesh,
 810                                            SMESH_Mesh*                          tgtMesh,
 811                                            const TopoDS_Shape&                  tgtShape,
 812                                            StdMeshers_Import_1D::TNodeNodeMap*& n2n,
 813                                            StdMeshers_Import_1D::TElemElemMap*& e2e,
 814                                            bool &                               toCopyGroups)
 815   {
 816     StdMeshers_Import_1D::getMaps( srcMesh, tgtMesh, n2n,e2e );
 817
 818     _ImportData* iData = _Listener::getImportData(srcMesh,tgtMesh);
 819
 820     SMESH_subMesh* importedSM = tgtMesh->GetSubMesh( tgtShape );
 821     iData->addComputed( importedSM );
 822     if ( iData->_computedSubM.size() != iData->_subM.size() )
 823       return 0; // not all submeshes computed yet
 824
 825     toCopyGroups = !iData->_copyGroupSubM.empty();
 826
 827     if ( !iData->_copyMeshSubM.empty())
 828     {
 829       // make submesh to store a copied mesh
 830       int smID = getSubmeshIDForCopiedMesh( srcMesh->GetMeshDS(), tgtMesh );
 831       SMESHDS_SubMesh* subDS = tgtMesh->GetMeshDS()->NewSubMesh( smID );
 832
 833       iData->_importMeshSubID = smID;
 834       iData->_importMeshSubDS = subDS;
 835       return subDS;
 836     }
 837     return 0;
 838   }
 839
 840   //================================================================================
 841   /*!
 842    * \brief Return minimal square length of edges of 1D and 2D elements sharing the node
 843    */
 844   //================================================================================
 845
 846   double getMinEdgeLength2( const SMDS_MeshNode* n )
 847   {
 848     SMESH_NodeXYZ p = n;
 849     double minLen2 = Precision::Infinite();
 850     for ( SMDS_ElemIteratorPtr eIt = n->GetInverseElementIterator(); eIt->more();  )
 851     {
 852       const SMDS_MeshElement*      e = eIt->next();
 853       const SMDSAbs_ElementType type = e->GetType();
 854       if ( type != SMDSAbs_Edge && type != SMDSAbs_Face )
 855         continue;
 856       int i = e->GetNodeIndex( n );
 857       int iNext = SMESH_MesherHelper::WrapIndex( i + 1, e->NbCornerNodes() );
 858       minLen2 = Min( minLen2, p.SquareDistance( e->GetNode( iNext )));
 859       if ( type != SMDSAbs_Face )
 860         continue;
 861       int iPrev = SMESH_MesherHelper::WrapIndex( i - 1, e->NbCornerNodes() );
 862       minLen2 = Min( minLen2, p.SquareDistance( e->GetNode( iPrev )));
 863     }
 864     return minLen2;
 865   }
 866
 867 } // namespace
 868
 869 //=============================================================================
 870 /*!
 871  * Creates StdMeshers_Import_1D
 872  */
 873 //=============================================================================
 874
 875 StdMeshers_Import_1D::StdMeshers_Import_1D(int hypId, SMESH_Gen * gen)
 876   :SMESH_1D_Algo(hypId, gen), _sourceHyp(0)
 877 {
 878   _name = "Import_1D";
 879   _shapeType = (1 << TopAbs_EDGE);
 880
 881   _compatibleHypothesis.push_back("ImportSource1D");
 882 }
 883
 884 //=============================================================================
 885 /*!
 886  * Check presence of a hypothesis
 887  */
 888 //=============================================================================
 889
 890 bool StdMeshers_Import_1D::CheckHypothesis
 891                          (SMESH_Mesh&                          aMesh,
 892                           const TopoDS_Shape&                  aShape,
 893                           SMESH_Hypothesis::Hypothesis_Status& aStatus)
 894 {
 895   _sourceHyp = 0;
 896
 897   const list <const SMESHDS_Hypothesis * >&hyps = GetUsedHypothesis(aMesh, aShape);
 898   if ( hyps.size() == 0 )
 899   {
 900     aStatus = SMESH_Hypothesis::HYP_MISSING;
 901     return false;  // can't work with no hypothesis
 902   }
 903
 904   if ( hyps.size() > 1 )
 905   {
 906     aStatus = SMESH_Hypothesis::HYP_ALREADY_EXIST;
 907     return false;
 908   }
 909
 910   const SMESHDS_Hypothesis *theHyp = hyps.front();
 911
 912   string hypName = theHyp->GetName();
 913
 914   if (hypName == _compatibleHypothesis.front())
 915   {
 916     _sourceHyp = (StdMeshers_ImportSource1D *)theHyp;
 917     aStatus = _sourceHyp->GetGroups().empty() ? HYP_BAD_PARAMETER : HYP_OK;
 918     if ( aStatus == HYP_BAD_PARAMETER )
 919       _Listener::waitHypModification( aMesh.GetSubMesh( aShape ));
 920     return aStatus == HYP_OK;
 921   }
 922
 923   aStatus = SMESH_Hypothesis::HYP_INCOMPATIBLE;
 924   return false;
 925 }
 926
 927 //=============================================================================
 928 /*!
 929  * Import elements from the other mesh
 930  */
 931 //=============================================================================
 932
 933 bool StdMeshers_Import_1D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & theShape)
 934 {
 935   if ( !_sourceHyp ) return false;
 936
 937   //MESSAGE("---------> StdMeshers_Import_1D::Compute");
 938   const vector<SMESH_Group*>& srcGroups = _sourceHyp->GetGroups(/*loaded=*/true);
 939   if ( srcGroups.empty() )
 940     return error("Invalid source groups");
 941
 942   SMESH_MesherHelper helper(theMesh);
 943   helper.SetSubShape(theShape);
 944   SMESHDS_Mesh* tgtMesh = theMesh.GetMeshDS();
 945
 946   const TopoDS_Edge& geomEdge = TopoDS::Edge( theShape );
 947   const double edgeTol = BRep_Tool::Tolerance( geomEdge );
 948   const int shapeID = tgtMesh->ShapeToIndex( geomEdge );
 949
 950
 951   double geomTol = Precision::Confusion();
 952   for ( size_t iG = 0; iG < srcGroups.size(); ++iG )
 953   {
 954     const SMESHDS_GroupBase* srcGroup = srcGroups[iG]->GetGroupDS();
 955     for ( SMDS_ElemIteratorPtr srcElems = srcGroup->GetElements(); srcElems->more(); )
 956     {
 957       const SMDS_MeshElement* edge = srcElems->next();
 958       geomTol = Sqrt( 0.5 * ( getMinEdgeLength2( edge->GetNode(0) ) +
 959                               getMinEdgeLength2( edge->GetNode(1) ))) / 25;
 960       iG = srcGroups.size();
 961       break;
 962     }
 963   }
 964   CurveProjector curveProjector( geomEdge, geomTol );
 965
 966   // get nodes on vertices
 967   set<int> vertexIDs;
 968   list < SMESH_TNodeXYZ > vertexNodes;
 969   list < SMESH_TNodeXYZ >::iterator vNIt;
 970   TopExp_Explorer vExp( theShape, TopAbs_VERTEX );
 971   for ( ; vExp.More(); vExp.Next() )
 972   {
 973     const TopoDS_Vertex& v = TopoDS::Vertex( vExp.Current() );
 974     if ( !vertexIDs.insert( tgtMesh->ShapeToIndex( v )).second )
 975       continue; // closed edge
 976     const SMDS_MeshNode* n = SMESH_Algo::VertexNode( v, tgtMesh );
 977     if ( !n )
 978     {
 979       _gen->Compute(theMesh,v,/*anUpward=*/true);
 980       n = SMESH_Algo::VertexNode( v, tgtMesh );
 981       //MESSAGE("_gen->Compute " << n);
 982       if ( !n ) return false; // very strange
 983     }
 984     vertexNodes.push_back( SMESH_TNodeXYZ( n ));
 985     //MESSAGE("SMESH_Algo::VertexNode " << n->GetID() << " " << n->X() << " " << n->Y() << " " << n->Z() );
 986   }
 987
 988   // import edges from groups
 989   TNodeNodeMap* n2n;
 990   TElemElemMap* e2e;
 991   for ( size_t iG = 0; iG < srcGroups.size(); ++iG )
 992   {
 993     const SMESHDS_GroupBase* srcGroup = srcGroups[iG]->GetGroupDS();
 994
 995     const int meshID = srcGroup->GetMesh()->GetPersistentId();
 996     const SMESH_Mesh* srcMesh = GetMeshByPersistentID( meshID );
 997     if ( !srcMesh ) continue;
 998     getMaps( srcMesh, &theMesh, n2n, e2e );
 999
1000     SMDS_ElemIteratorPtr srcElems = srcGroup->GetElements();
1001     vector<const SMDS_MeshNode*> newNodes;
1002     while ( srcElems->more() ) // loop on group contents
1003     {
1004       const SMDS_MeshElement* edge = srcElems->next();
1005       gp_XYZ middle = 0.5 * ( SMESH_NodeXYZ( edge->GetNode(0)) +
1006                               SMESH_NodeXYZ( edge->GetNode(1)));
1007       if ( curveProjector.IsOut( middle ))
1008         continue;
1009
1010       // find or create nodes of a new edge
1011       newNodes.resize( edge->NbNodes() );
1012       newNodes.back() = 0;
1013       int nbNodesOnVertex = 0;
1014       SMDS_MeshElement::iterator node = edge->begin_nodes();
1015       for ( size_t i = 0; i < newNodes.size(); ++i, ++node )
1016       {
1017         TNodeNodeMap::iterator n2nIt = n2n->insert( make_pair( *node, nullptr )).first;
1018         if ( n2nIt->second )
1019         {
1020           int sId = n2nIt->second->getshapeId();
1021           if ( sId != shapeID )
1022           {
1023             if ( vertexIDs.count( sId ))
1024               ++nbNodesOnVertex;
1025             else
1026               break;
1027           }
1028         }
1029         else if ( !vertexNodes.empty() )
1030         {
1031           // find an existing vertex node
1032           double checktol = max(1.E-10, 10*edgeTol*edgeTol);
1033           for ( vNIt = vertexNodes.begin(); vNIt != vertexNodes.end(); ++vNIt)
1034             if ( vNIt->SquareDistance( *node ) < checktol)
1035             {
1036               (*n2nIt).second = vNIt->_node;
1037               vertexNodes.erase( vNIt );
1038               ++nbNodesOnVertex;
1039               break;
1040             }
1041         }
1042         if ( !n2nIt->second )
1043         {
1044           // find out if the node lies on theShape
1045           SMESH_NodeXYZ xyz = *node;
1046           double dist2, u;
1047           if ( curveProjector.IsOnCurve( xyz, dist2, u ))
1048           {
1049             // tolerance relative to the length of surrounding edges
1050             double mytol2 = getMinEdgeLength2( *node ) / 25 / 25;
1051             if ( dist2 < mytol2 )
1052             {
1053               SMDS_MeshNode* newNode = tgtMesh->AddNode( xyz.X(), xyz.Y(), xyz.Z() );
1054               n2nIt->second = newNode;
1055               tgtMesh->SetNodeOnEdge( newNode, shapeID, u );
1056             }
1057           }
1058         }
1059         if ( !(newNodes[i] = n2nIt->second ))
1060           break;
1061       }
1062       if ( !newNodes.back() )
1063       {
1064         //MESSAGE("not all nodes of edge lie on theShape");
1065         continue; // not all nodes of edge lie on theShape
1066       }
1067
1068       // make a new edge
1069       SMDS_MeshElement * newEdge;
1070       if ( newNodes.size() == 3 )
1071         newEdge = tgtMesh->AddEdge( newNodes[0], newNodes[1], newNodes[2] );
1072       else
1073         newEdge = tgtMesh->AddEdge( newNodes[0], newNodes[1]);
1074       tgtMesh->SetMeshElementOnShape( newEdge, shapeID );
1075       e2e->insert( make_pair( edge, newEdge ));
1076
1077       if ( nbNodesOnVertex >= 2 ) // EDGE is meshed by a sole segment
1078       {
1079         iG = srcGroups.size(); // stop looingp on groups
1080         break;
1081       }
1082     }  // loop on group contents
1083   } // loop on groups
1084
1085   if ( n2n->empty())
1086     return error("Empty source groups");
1087
1088   // check if the whole geom edge is covered by imported segments;
1089   // the check consist in passing by segments from one vetrex node to another
1090   bool isEdgeMeshed = false;
1091   if ( SMESHDS_SubMesh* tgtSM = tgtMesh->MeshElements( theShape ))
1092   {
1093     const TopoDS_Vertex& v = ( vExp.ReInit(), TopoDS::Vertex( vExp.Current() ));
1094     const SMDS_MeshNode* n = SMESH_Algo::VertexNode( v, tgtMesh );
1095     const SMDS_MeshElement* seg = 0;
1096     SMDS_ElemIteratorPtr segIt = n->GetInverseElementIterator(SMDSAbs_Edge);
1097     while ( segIt->more() && !seg )
1098       if ( !tgtSM->Contains( seg = segIt->next()))
1099         seg = 0;
1100     int nbPassedSegs = 0;
1101     while ( seg )
1102     {
1103       ++nbPassedSegs;
1104       const SMDS_MeshNode* n2 = seg->GetNode(0);
1105       n = ( n2 == n ? seg->GetNode(1) : n2 );
1106       if ( n->GetPosition()->GetTypeOfPosition() == SMDS_TOP_VERTEX )
1107         break;
1108       const SMDS_MeshElement* seg2 = 0;
1109       segIt = n->GetInverseElementIterator(SMDSAbs_Edge);
1110       while ( segIt->more() && !seg2 )
1111         if ( seg == ( seg2 = segIt->next()))
1112           seg2 = 0;
1113       seg = seg2;
1114     }
1115     if (nbPassedSegs > 0 && tgtSM->NbElements() > nbPassedSegs )
1116       return error( "Source elements overlap one another");
1117
1118     isEdgeMeshed = ( tgtSM->NbElements() == nbPassedSegs &&
1119                      n->GetPosition()->GetTypeOfPosition() == SMDS_TOP_VERTEX );
1120   }
1121   if ( !isEdgeMeshed )
1122     return error( "Source elements don't cover totally the geometrical edge" );
1123
1124   // copy meshes
1125   vector<SMESH_Mesh*> srcMeshes = _sourceHyp->GetSourceMeshes();
1126   for ( size_t i = 0; i < srcMeshes.size(); ++i )
1127     importMesh( srcMeshes[i], theMesh, _sourceHyp, theShape );
1128
1129   return true;
1130 }
1131
1132 //================================================================================
1133 /*!
1134  * \brief Copy mesh and groups
1135  */
1136 //================================================================================
1137
1138 void StdMeshers_Import_1D::importMesh(const SMESH_Mesh*          srcMesh,
1139                                       SMESH_Mesh &               tgtMesh,
1140                                       StdMeshers_ImportSource1D* srcHyp,
1141                                       const TopoDS_Shape&        tgtShape)
1142 {
1143   // get submesh to store the imported mesh
1144   TNodeNodeMap* n2n;
1145   TElemElemMap* e2e;
1146   bool toCopyGroups;
1147   SMESHDS_SubMesh* tgtSubMesh =
1148     getSubmeshForCopiedMesh( srcMesh, &tgtMesh, tgtShape, n2n, e2e, toCopyGroups );
1149   if ( !tgtSubMesh || tgtSubMesh->NbNodes() + tgtSubMesh->NbElements() > 0 )
1150     return; // not to copy srcMeshDS twice
1151
1152   SMESHDS_Mesh* tgtMeshDS = tgtMesh.GetMeshDS();
1153   SMESH_MeshEditor additor( &tgtMesh );
1154
1155   // 1. Copy mesh
1156
1157   SMESH_MeshEditor::ElemFeatures elemType;
1158   vector<const SMDS_MeshNode*> newNodes;
1159   const SMESHDS_Mesh* srcMeshDS = srcMesh->GetMeshDS();
1160   SMDS_ElemIteratorPtr eIt = srcMeshDS->elementsIterator();
1161   while ( eIt->more() )
1162   {
1163     const SMDS_MeshElement* elem = eIt->next();
1164     TElemElemMap::iterator e2eIt = e2e->insert( make_pair( elem, (SMDS_MeshElement*)0 )).first;
1165     if ( e2eIt->second ) continue; // already copied by Compute()
1166     newNodes.resize( elem->NbNodes() );
1167     SMDS_MeshElement::iterator node = elem->begin_nodes();
1168     for ( unsigned i = 0; i < newNodes.size(); ++i, ++node )
1169     {
1170       TNodeNodeMap::iterator n2nIt = n2n->insert( make_pair( *node, (SMDS_MeshNode*)0 )).first;
1171       if ( !n2nIt->second )
1172       {
1173         (*n2nIt).second = tgtMeshDS->AddNode( (*node)->X(), (*node)->Y(), (*node)->Z());
1174         tgtSubMesh->AddNode( n2nIt->second );
1175       }
1176       newNodes[i] = n2nIt->second;
1177     }
1178     const SMDS_MeshElement* newElem =
1179       tgtMeshDS->FindElement( newNodes, elem->GetType(), /*noMedium=*/false );
1180     if ( !newElem )
1181     {
1182       newElem = additor.AddElement( newNodes, elemType.Init( elem, /*basicOnly=*/false ));
1183       tgtSubMesh->AddElement( newElem );
1184     }
1185     if ( toCopyGroups )
1186       (*e2eIt).second = newElem;
1187   }
1188   // copy free nodes
1189   if ( srcMeshDS->NbNodes() > (int) n2n->size() )
1190   {
1191     SMDS_NodeIteratorPtr nIt = srcMeshDS->nodesIterator();
1192     while( nIt->more() )
1193     {
1194       const SMDS_MeshNode* node = nIt->next();
1195       if ( node->NbInverseElements() == 0 )
1196       {
1197         const SMDS_MeshNode* newNode = tgtMeshDS->AddNode( node->X(), node->Y(), node->Z());
1198         n2n->insert( make_pair( node, newNode ));
1199         tgtSubMesh->AddNode( newNode );
1200       }
1201     }
1202   }
1203
1204   // 2. Copy groups
1205
1206   vector<SMESH_Group*> resultGroups;
1207   if ( toCopyGroups )
1208   {
1209     // collect names of existing groups to assure uniqueness of group names within a type
1210     map< SMDSAbs_ElementType, set<string> > namesByType;
1211     SMESH_Mesh::GroupIteratorPtr groupIt = tgtMesh.GetGroups();
1212     while ( groupIt->more() )
1213     {
1214       SMESH_Group* tgtGroup = groupIt->next();
1215       namesByType[ tgtGroup->GetGroupDS()->GetType() ].insert( tgtGroup->GetName() );
1216     }
1217     if (srcMesh)
1218     {
1219       SMESH_Mesh::GroupIteratorPtr groupIt = srcMesh->GetGroups();
1220       while ( groupIt->more() )
1221       {
1222         SMESH_Group* srcGroup = groupIt->next();
1223         SMESHDS_GroupBase* srcGroupDS = srcGroup->GetGroupDS();
1224         string name = srcGroup->GetName();
1225         int nb = 1;
1226         while ( !namesByType[ srcGroupDS->GetType() ].insert( name ).second )
1227           name = SMESH_Comment(srcGroup->GetName()) << "_imported_" << nb++;
1228         SMESH_Group* newGroup = tgtMesh.AddGroup( srcGroupDS->GetType(), name.c_str() );
1229         SMESHDS_Group* newGroupDS = (SMESHDS_Group*)newGroup->GetGroupDS();
1230         resultGroups.push_back( newGroup );
1231
1232         eIt = srcGroupDS->GetElements();
1233         if ( srcGroupDS->GetType() == SMDSAbs_Node )
1234           while (eIt->more())
1235           {
1236             TNodeNodeMap::iterator n2nIt = n2n->find((const SMDS_MeshNode*) eIt->next() );
1237             if ( n2nIt != n2n->end() && n2nIt->second )
1238               newGroupDS->SMDSGroup().Add((*n2nIt).second );
1239           }
1240         else
1241           while (eIt->more())
1242           {
1243             TElemElemMap::iterator e2eIt = e2e->find( eIt->next() );
1244             if ( e2eIt != e2e->end() && e2eIt->second )
1245               newGroupDS->SMDSGroup().Add((*e2eIt).second );
1246           }
1247       }
1248     }
1249   }
1250   n2n->clear();
1251   e2e->clear();
1252
1253   // Remember created groups in order to remove them as soon as the srcHyp is
1254   // modified or something other similar happens. This imformation must be persistent,
1255   // for that store them in a hypothesis as it stores its values in the file anyway
1256   srcHyp->StoreResultGroups( resultGroups, *srcMeshDS, *tgtMeshDS );
1257 }
1258
1259 //=============================================================================
1260 /*!
1261  * \brief Set needed event listeners and create a submesh for a copied mesh
1262  *
1263  * This method is called only if a submesh has HYP_OK algo_state.
1264  */
1265 //=============================================================================
1266
1267 void StdMeshers_Import_1D::setEventListener(SMESH_subMesh*             subMesh,
1268                                             StdMeshers_ImportSource1D* sourceHyp)
1269 {
1270   if ( sourceHyp )
1271   {
1272     vector<SMESH_Mesh*> srcMeshes = sourceHyp->GetSourceMeshes();
1273     if ( srcMeshes.empty() )
1274       _Listener::waitHypModification( subMesh );
1275     for ( unsigned i = 0; i < srcMeshes.size(); ++i )
1276       // set a listener to remove the imported mesh and groups
1277       _Listener::storeImportSubmesh( subMesh, srcMeshes[i], sourceHyp );
1278   }
1279 }
1280 void StdMeshers_Import_1D::SetEventListener(SMESH_subMesh* subMesh)
1281 {
1282   if ( !_sourceHyp )
1283   {
1284     const TopoDS_Shape& tgtShape = subMesh->GetSubShape();
1285     SMESH_Mesh*         tgtMesh  = subMesh->GetFather();
1286     Hypothesis_Status aStatus;
1287     CheckHypothesis( *tgtMesh, tgtShape, aStatus );
1288   }
1289   setEventListener( subMesh, _sourceHyp );
1290 }
1291
1292 void StdMeshers_Import_1D::SubmeshRestored(SMESH_subMesh* subMesh)
1293 {
1294   SetEventListener(subMesh);
1295 }
1296
1297 //=============================================================================
1298 /*!
1299  * Predict nb of mesh entities created by Compute()
1300  */
1301 //=============================================================================
1302
1303 bool StdMeshers_Import_1D::Evaluate(SMESH_Mesh &         theMesh,
1304                                     const TopoDS_Shape & theShape,
1305                                     MapShapeNbElems&     aResMap)
1306 {
1307   if ( !_sourceHyp ) return false;
1308
1309   const vector<SMESH_Group*>& srcGroups = _sourceHyp->GetGroups();
1310   if ( srcGroups.empty() )
1311     return error("Invalid source groups");
1312
1313   vector<int> aVec(SMDSEntity_Last,0);
1314
1315   bool toCopyMesh, toCopyGroups;
1316   _sourceHyp->GetCopySourceMesh(toCopyMesh, toCopyGroups);
1317   if ( toCopyMesh ) // the whole mesh is copied
1318   {
1319     vector<SMESH_Mesh*> srcMeshes = _sourceHyp->GetSourceMeshes();
1320     for ( unsigned i = 0; i < srcMeshes.size(); ++i )
1321     {
1322       SMESH_subMesh* sm = getSubMeshOfCopiedMesh( theMesh, *srcMeshes[i]);
1323       if ( !sm || aResMap.count( sm )) continue; // already counted
1324       aVec.assign( SMDSEntity_Last, 0);
1325       const SMDS_MeshInfo& aMeshInfo = srcMeshes[i]->GetMeshDS()->GetMeshInfo();
1326       for (int i = 0; i < SMDSEntity_Last; i++)
1327         aVec[i] = aMeshInfo.NbEntities((SMDSAbs_EntityType)i);
1328     }
1329   }
1330   else
1331   {
1332     SMESH_MesherHelper helper(theMesh);
1333
1334     const TopoDS_Edge& geomEdge = TopoDS::Edge( theShape );
1335     const double edgeTol = helper.MaxTolerance( geomEdge );
1336
1337     // take into account nodes on vertices
1338     TopExp_Explorer vExp( theShape, TopAbs_VERTEX );
1339     for ( ; vExp.More(); vExp.Next() )
1340       theMesh.GetSubMesh( vExp.Current())->Evaluate( aResMap );
1341
1342     // count edges imported from groups
1343     int nbEdges = 0, nbQuadEdges = 0;
1344     for ( size_t iG = 0; iG < srcGroups.size(); ++iG )
1345     {
1346       const SMESHDS_GroupBase* srcGroup = srcGroups[iG]->GetGroupDS();
1347       SMDS_ElemIteratorPtr srcElems = srcGroup->GetElements();
1348       SMDS_MeshNode *tmpNode = helper.AddNode(0,0,0);
1349       while ( srcElems->more() ) // loop on group contents
1350       {
1351         const SMDS_MeshElement* edge = srcElems->next();
1352         // find out if edge is located on geomEdge by projecting
1353         // a middle of edge to geomEdge
1354         SMESH_TNodeXYZ p1( edge->GetNode(0));
1355         SMESH_TNodeXYZ p2( edge->GetNode(1));
1356         gp_XYZ middle = ( p1 + p2 ) / 2.;
1357         tmpNode->setXYZ( middle.X(), middle.Y(), middle.Z());
1358         double u = 0;
1359         if ( helper.CheckNodeU( geomEdge, tmpNode, u, 10 * edgeTol, /*force=*/true ))
1360           ++( edge->IsQuadratic() ? nbQuadEdges : nbEdges);
1361       }
1362       helper.GetMeshDS()->RemoveNode(tmpNode);
1363     }
1364
1365     int nbNodes = nbEdges + 2 * nbQuadEdges - 1;
1366
1367     aVec[SMDSEntity_Node     ] = nbNodes;
1368     aVec[SMDSEntity_Edge     ] = nbEdges;
1369     aVec[SMDSEntity_Quad_Edge] = nbQuadEdges;
1370   }
1371
1372   SMESH_subMesh * sm = theMesh.GetSubMesh(theShape);
1373   aResMap.insert( make_pair( sm, aVec ));
1374
1375   return true;
1376 }
1377
1378 //================================================================================
1379 /*!
1380  * \brief Return node-node and element-element maps for import of geiven source mesh
1381  */
1382 //================================================================================
1383
1384 void StdMeshers_Import_1D::getMaps(const SMESH_Mesh* srcMesh,
1385                                    SMESH_Mesh*       tgtMesh,
1386                                    TNodeNodeMap*&    n2n,
1387                                    TElemElemMap*&    e2e)
1388 {
1389   _ImportData* iData = _Listener::getImportData(srcMesh,tgtMesh);
1390   n2n = &iData->_n2n;
1391   e2e = &iData->_e2e;
1392   if ( iData->_copyMeshSubM.empty() )
1393   {
1394     // n2n->clear(); -- for sharing nodes on EDGEs
1395     e2e->clear();
1396   }
1397 }
1398
1399 //================================================================================
1400 /*!
1401  * \brief Return submesh corresponding to the copied mesh
1402  */
1403 //================================================================================
1404
1405 SMESH_subMesh* StdMeshers_Import_1D::getSubMeshOfCopiedMesh( SMESH_Mesh& tgtMesh,
1406                                                              SMESH_Mesh& srcMesh )
1407 {
1408   _ImportData* iData = _Listener::getImportData(&srcMesh,&tgtMesh);
1409   if ( iData->_copyMeshSubM.empty() ) return 0;
1410   SMESH_subMesh* sm = tgtMesh.GetSubMeshContaining( iData->_importMeshSubID );
1411   return sm;
1412 }
1413