1 // Copyright (C) 2007-2020 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
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.
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.
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
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
23 // SMESH SMESH : implementation of SMESH idl descriptions
24 // File : StdMeshers_Import_1D.cxx
27 #include "StdMeshers_Import_1D.hxx"
28 #include "StdMeshers_ImportSource.hxx"
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"
45 #include "Utils_SALOME_Exception.hxx"
46 #include "utilities.h"
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>
55 #include <TopExp_Explorer.hxx>
57 #include <TopoDS_Compound.hxx>
58 #include <TopoDS_Edge.hxx>
59 #include <TopoDS_Vertex.hxx>
63 //================================================================================
64 namespace // INTERNAL STUFF
65 //================================================================================
68 * \brief Compute point position on a curve. Use octree to fast reject far points
70 class CurveProjector : public SMESH_Octree
73 CurveProjector( const TopoDS_Edge& edge, double enlarge );
75 bool IsOnCurve( const gp_XYZ& point, double & distance2, double & u );
77 bool IsOut( const gp_XYZ& point ) const { return getBox()->IsOut( point ); }
81 SMESH_Octree* newChild() const { return new CurveProjector; }
82 void buildChildrenData();
83 Bnd_B3d* buildRootBox();
86 struct CurveSegment : public Bnd_B3d
88 double _chord, _chord2, _length2;
89 gp_Pnt _pFirst, _pLast;
91 Handle(Geom_Curve) _curve;
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 );
99 std::vector< CurveSegment > _segments;
102 //===============================================================================
104 * \brief Create an octree of curve segments
106 //================================================================================
108 CurveProjector::CurveProjector( const TopoDS_Edge& edge, double enlarge )
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 )
119 _segments[ i - 1 ].Init( div.Value( i ), div.Value( i+1 ),
120 div.Parameter( i ), div.Parameter( i+1 ),
123 catch ( Standard_Failure ) {
124 _segments.resize( _segments.size() - 1 );
127 if ( _segments.size() < 3 )
132 if ( _segments.size() == 1 )
133 myBox->Enlarge( enlarge );
136 //================================================================================
138 * \brief Return the maximal box
140 //================================================================================
142 Bnd_B3d* CurveProjector::buildRootBox()
144 Bnd_B3d* box = new Bnd_B3d;
145 for ( size_t i = 0; i < _segments.size(); ++i )
146 box->Add( _segments[i] );
150 //================================================================================
152 * \brief Redistribute segments among children
154 //================================================================================
156 void CurveProjector::buildChildrenData()
159 for ( size_t i = 0; i < _segments.size(); ++i )
161 for (int j = 0; j < 8; j++)
163 if ( _segments[i].IsInContact( *myChildren[j]->getBox() ))
164 ((CurveProjector*)myChildren[j])->_segments.push_back( _segments[i]);
169 if ( allIn && _segments.size() < 3 )
172 for (int j = 0; j < 8; j++)
173 static_cast<CurveProjector*>( myChildren[j])->myIsLeaf = true;
177 SMESHUtils::FreeVector( _segments ); // = _segments.clear() + free memory
179 for (int j = 0; j < 8; j++)
181 CurveProjector* child = static_cast<CurveProjector*>( myChildren[j]);
182 if ( child->_segments.size() < 3 )
183 child->myIsLeaf = true;
188 //================================================================================
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
196 //================================================================================
198 bool CurveProjector::IsOnCurve( const gp_XYZ& point, double & distance2, double & u )
200 if ( getBox()->IsOut( point ))
205 distance2 = Precision::Infinite();
209 for ( size_t i = 0; i < _segments.size(); ++i )
210 if ( !_segments[i].IsOut( point ) &&
211 _segments[i].IsOn( point, dist2, param ) &&
222 for (int i = 0; i < 8; i++)
223 if (((CurveProjector*) myChildren[i])->IsOnCurve( point, dist2, param ) &&
234 //================================================================================
238 //================================================================================
240 void CurveProjector::CurveSegment::Init(const gp_Pnt& pf,
245 Handle(Geom_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 );
260 BndLib_Add3dCurve::Add( GeomAdaptor_Curve( curve, uf, ul ), tol, bb );
261 Add( bb.CornerMin() );
262 Add( bb.CornerMax() );
265 //================================================================================
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
273 //================================================================================
275 bool CurveProjector::CurveSegment::IsOn( const gp_XYZ& point, double & distance2, double & u )
277 distance2 = _line.SquareDistance( point );
278 if ( distance2 > _chord2 )
281 // check if the point projection falls into the segment range
283 gp_Vec edge( _pFirst, _pLast );
284 gp_Vec n1p ( _pFirst, point );
285 u = ( edge * n1p ) / _length2; // param [0,1] on the edge
288 if ( _pFirst.SquareDistance( point ) > _chord2 )
293 if ( _pLast.SquareDistance( point ) > _chord2 )
298 distance2 = ShapeAnalysis_Curve().Project( _curve, point, Precision::Confusion(),
300 distance2 *= distance2;
304 //================================================================================
306 * \brief Check if the segment is in contact with a box
308 //================================================================================
310 bool CurveProjector::CurveSegment::IsInContact( const Bnd_B3d& bb )
312 if ( bb.IsOut( _line.Position(), /*isRay=*/true, _chord ))
315 gp_Ax1 axRev = _line.Position().Reversed();
316 axRev.SetLocation( _pLast );
317 return !bb.IsOut( axRev, /*isRay=*/true, _chord );
320 //================================================================================
321 //================================================================================
323 int getSubmeshIDForCopiedMesh(const SMESHDS_Mesh* srcMeshDS, SMESH_Mesh* tgtMesh);
325 enum _ListenerDataType
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
331 //================================================================================
333 * \brief _ListenerData holding ImportSource hyp holding in its turn
336 struct _ListenerData : public SMESH_subMeshEventListenerData
338 const StdMeshers_ImportSource1D* _srcHyp;
339 _ListenerData(const StdMeshers_ImportSource1D* h, _ListenerDataType type=SRC_HYP):
340 SMESH_subMeshEventListenerData(/*isDeletable=*/true), _srcHyp(h)
345 //================================================================================
347 * \brief Comparator of sub-meshes
351 bool operator()(const SMESH_subMesh* sm1, const SMESH_subMesh* sm2 ) const
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();
361 return t1 < t2; // to have: face < edge
364 //================================================================================
366 * \brief Container of data dedicated to one source mesh
370 const SMESH_Mesh* _srcMesh;
371 StdMeshers_Import_1D::TNodeNodeMap _n2n;
372 StdMeshers_Import_1D::TElemElemMap _e2e;
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;
379 SMESHDS_SubMesh* _importMeshSubDS; // submesh storing a copy of _srcMesh
380 int _importMeshSubID; // id of _importMeshSubDS
382 _ImportData(const SMESH_Mesh* srcMesh=0):
383 _srcMesh(srcMesh), _importMeshSubDS(0),_importMeshSubID(-1) {}
385 void removeImportedMesh( SMESHDS_Mesh* meshDS )
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();
398 void removeGroups( SMESH_subMesh* subM, const StdMeshers_ImportSource1D* srcHyp )
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);
408 for ( unsigned i = 0; i < groups->size(); ++i )
409 tgtMesh->RemoveGroup( groups->at(i)->GetGroupDS()->GetID() );
413 void trackHypParams( SMESH_subMesh* sm, const StdMeshers_ImportSource1D* srcHyp )
415 if ( !srcHyp ) return;
416 bool toCopyMesh, toCopyGroups;
417 srcHyp->GetCopySourceMesh(toCopyMesh, toCopyGroups);
419 if ( toCopyMesh )_copyMeshSubM.insert( sm );
420 else _copyMeshSubM.erase( sm );
422 if ( toCopyGroups ) _copyGroupSubM.insert( sm );
423 else _copyGroupSubM.erase( sm );
425 void addComputed( SMESH_subMesh* sm )
427 SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator(/*includeSelf=*/true,
428 /*complexShapeFirst=*/true);
429 while ( smIt->more() )
432 switch ( sm->GetSubShape().ShapeType() )
435 if ( SMESH_Algo::isDegenerated( TopoDS::Edge( sm->GetSubShape() )))
440 if ( !sm->IsEmpty() )
441 _computedSubM.insert( sm );
449 //================================================================================
451 * Listener notified on events relating to imported submesh
453 class _Listener : public SMESH_subMeshEventListener
455 typedef map< SMESH_Mesh*, list< _ImportData > > TMesh2ImpData;
456 TMesh2ImpData _tgtMesh2ImportData;
458 _Listener():SMESH_subMeshEventListener(/*isDeletable=*/false,
459 "StdMeshers_Import_1D::_Listener") {}
462 // return pointer to a static listener
463 static _Listener* get() { static _Listener theListener; return &theListener; }
465 static _ImportData* getImportData(const SMESH_Mesh* srcMesh, SMESH_Mesh* tgtMesh);
467 static void storeImportSubmesh(SMESH_subMesh* importSub,
468 const SMESH_Mesh* srcMesh,
469 const StdMeshers_ImportSource1D* srcHyp);
471 virtual void ProcessEvent(const int event,
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 );
480 // mark sm as missing src hyp with valid groups
481 static void waitHypModification(SMESH_subMesh* sm)
484 (get(), SMESH_subMeshEventListenerData::MakeData( sm, WAIT_HYP_MODIF ), sm);
487 //--------------------------------------------------------------------------------
489 * \brief Find or create ImportData for given meshes
491 _ImportData* _Listener::getImportData(const SMESH_Mesh* srcMesh,
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 )
499 dList.push_back(_ImportData(srcMesh));
500 return &dList.back();
503 //--------------------------------------------------------------------------------
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
510 void _Listener::storeImportSubmesh(SMESH_subMesh* importSub,
511 const SMESH_Mesh* srcMesh,
512 const StdMeshers_ImportSource1D* srcHyp)
514 // set listener to hear events of the submesh computed by "Import" algo
515 importSub->SetEventListener( get(), new _ListenerData(srcHyp), importSub );
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 )
522 SMESH_subMeshEventListenerData* data = new _ListenerData(srcHyp, LISTEN_SRC_MESH);
523 data->mySubMeshes.push_back( smToNotify );
524 importSub->SetEventListener( get(), data, smToListen[i] );
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 )
532 SMESH_Mesh* tgtMesh = importSub->GetFather();
533 iData->_importMeshSubID = getSubmeshIDForCopiedMesh( srcMesh->GetMeshDS(),tgtMesh);
534 iData->_importMeshSubDS = tgtMesh->GetMeshDS()->NewSubMesh( iData->_importMeshSubID );
537 //--------------------------------------------------------------------------------
539 * \brief Remove imported mesh and/or groups if needed
540 * \param sm - submesh losing Import algo
541 * \param data - data holding imported groups
543 void _Listener::removeSubmesh( SMESH_subMesh* sm, _ListenerData* data )
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 ))
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;
554 d->removeImportedMesh( sm->GetFather()->GetMeshDS() );
555 if ( rmGroups && data && data->myType == SRC_HYP )
556 d->removeGroups( sm, data->_srcHyp );
559 //--------------------------------------------------------------------------------
561 * \brief Clear _ImportData::_n2n.
562 * _n2n is useful within one mesh.Compute() only
564 void _Listener::clearN2N( SMESH_Mesh* tgtMesh )
566 list< _ImportData >& dList = get()->_tgtMesh2ImportData[tgtMesh];
567 list< _ImportData >::iterator d = dList.begin();
568 for ( ; d != dList.end(); ++d )
571 //--------------------------------------------------------------------------------
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
577 void _Listener::clearSubmesh(SMESH_subMesh* sm, _ListenerData* data, bool clearAllSub)
579 list< _ImportData > & dList = _tgtMesh2ImportData[ sm->GetFather() ];
580 list< _ImportData >::iterator d = dList.begin();
581 for ( ; d != dList.end(); ++d )
583 if ( !d->_subM.count( sm )) continue;
584 if ( (*d)._computedSubM.erase( sm ) )
586 bool copyMesh = !d->_copyMeshSubM.empty();
587 if ( copyMesh || clearAllSub )
589 // remove imported mesh and groups
590 d->removeImportedMesh( sm->GetFather()->GetMeshDS() );
592 if ( data && data->myType == SRC_HYP )
593 d->removeGroups( sm, data->_srcHyp );
595 // clear the rest submeshes
596 if ( !d->_computedSubM.empty() )
598 d->_computedSubM.clear();
599 set< SMESH_subMesh*, _SubLess>::iterator sub = d->_subM.begin();
600 for ( ; sub != d->_subM.end(); ++sub )
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 );
607 subM->ComputeStateEngine( SMESH_subMesh::CLEAN );
608 if ( subM->GetSubShape().ShapeType() == TopAbs_FACE )
609 subM->ComputeSubMeshStateEngine( SMESH_subMesh::CLEAN );
613 sm->ComputeStateEngine( SMESH_subMesh::CLEAN );
614 if ( sm->GetSubShape().ShapeType() == TopAbs_FACE )
615 sm->ComputeSubMeshStateEngine( SMESH_subMesh::CLEAN );
617 if ( data && data->myType == SRC_HYP )
618 d->trackHypParams( sm, data->_srcHyp );
623 //--------------------------------------------------------------------------------
625 * \brief Remove imported mesh and/or groups
627 void _Listener::ProcessEvent(const int event,
629 SMESH_subMesh* subMesh,
630 SMESH_subMeshEventListenerData* data,
631 const SMESH_Hypothesis* /*hyp*/)
633 if ( data && data->myType == WAIT_HYP_MODIF )
635 // event of Import submesh
636 if ( SMESH_subMesh::MODIF_HYP == event &&
637 SMESH_subMesh::ALGO_EVENT == eventType )
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 );
645 else if ( data && data->myType == LISTEN_SRC_MESH )
647 // event of source mesh
648 if ( SMESH_subMesh::COMPUTE_EVENT == eventType )
651 case SMESH_subMesh::CLEAN:
652 // source mesh cleaned -> clean target mesh
653 clearSubmesh( data->mySubMeshes.front(), (_ListenerData*) data, /*all=*/true );
655 case SMESH_subMesh::SUBMESH_COMPUTED: {
656 // source mesh computed -> reset FAILED state of Import submeshes to
658 SMESH_Mesh* srcMesh = subMesh->GetFather();
659 if ( srcMesh->NbEdges() > 0 || srcMesh->NbFaces() > 0 )
661 SMESH_Mesh* m = data->mySubMeshes.front()->GetFather();
662 if ( SMESH_subMesh* sm1 = m->GetSubMeshContaining(1))
664 sm1->ComputeStateEngine(SMESH_subMesh::SUBMESH_COMPUTED );
665 sm1->ComputeSubMeshStateEngine( SMESH_subMesh::SUBMESH_COMPUTED );
673 if ( !data->mySubMeshes.empty() )
674 clearN2N( data->mySubMeshes.front()->GetFather() );
676 else // event of Import submesh
678 // find out what happens: import hyp modified or removed
679 bool removeImport = false, modifHyp = false;
680 if ( SMESH_subMesh::ALGO_EVENT == eventType )
682 if ( subMesh->GetAlgoState() != SMESH_subMesh::HYP_OK )
686 else if (( SMESH_subMesh::REMOVE_ALGO == event ||
687 SMESH_subMesh::REMOVE_FATHER_ALGO == event ) &&
688 SMESH_subMesh::ALGO_EVENT == eventType )
690 SMESH_Algo* algo = subMesh->GetAlgo();
691 removeImport = ( strncmp( "Import", algo->GetName(), 6 ) != 0 );
696 // treat removal of Import algo from subMesh
697 removeSubmesh( subMesh, (_ListenerData*) data );
699 else if ( modifHyp ||
700 ( SMESH_subMesh::CLEAN == event &&
701 SMESH_subMesh::COMPUTE_EVENT == eventType))
703 // treat modification of ImportSource hypothesis
704 clearSubmesh( subMesh, (_ListenerData*) data, /*all=*/false );
706 else if ( SMESH_subMesh::CHECK_COMPUTE_STATE == event &&
707 SMESH_subMesh::COMPUTE_EVENT == eventType )
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 ))
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);
723 // Clear _ImportData::_n2n if it isn't useful anymore, i.e. when
724 // the event is not within mesh.Compute()
725 if ( SMESH_subMesh::ALGO_EVENT == eventType )
726 clearN2N( subMesh->GetFather() );
730 //================================================================================
732 * \brief Return an ID of submesh to store nodes and elements of a copied mesh
734 //================================================================================
736 int getSubmeshIDForCopiedMesh(const SMESHDS_Mesh* srcMeshDS,
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 );
751 // index of pseudoSubShapes corresponding to srcMeshDS
752 int subIndex = 1 + srcMeshDS->GetPersistentId() % pseudoSubShapes.Extent();
753 int nbSubShapes = 1 + srcMeshDS->GetPersistentId() / pseudoSubShapes.Extent();
755 // try to find already present shapeForSrcMesh
756 SMESHDS_Mesh* tgtMeshDS = tgtMesh->GetMeshDS();
757 for ( int i = tgtMeshDS->MaxShapeIndex(); i > 0 && shapeForSrcMesh.IsNull(); --i )
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 )
770 if ( shapeForSrcMesh.IsNull() )
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() );
783 SMESH_subMesh* sm = tgtMesh->GetSubMesh( shapeForSrcMesh );
784 SMESHDS_SubMesh* smDS = sm->GetSubMeshDS();
786 smDS = tgtMeshDS->NewSubMesh( sm->GetId() );
788 // make ordinary submesh from a complex one
789 if ( smDS->IsComplexSubmesh() )
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 );
801 //================================================================================
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
807 //================================================================================
809 SMESHDS_SubMesh* getSubmeshForCopiedMesh(const SMESH_Mesh* srcMesh,
811 const TopoDS_Shape& tgtShape,
812 StdMeshers_Import_1D::TNodeNodeMap*& n2n,
813 StdMeshers_Import_1D::TElemElemMap*& e2e,
816 StdMeshers_Import_1D::getMaps( srcMesh, tgtMesh, n2n,e2e );
818 _ImportData* iData = _Listener::getImportData(srcMesh,tgtMesh);
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
825 toCopyGroups = !iData->_copyGroupSubM.empty();
827 if ( !iData->_copyMeshSubM.empty())
829 // make submesh to store a copied mesh
830 int smID = getSubmeshIDForCopiedMesh( srcMesh->GetMeshDS(), tgtMesh );
831 SMESHDS_SubMesh* subDS = tgtMesh->GetMeshDS()->NewSubMesh( smID );
833 iData->_importMeshSubID = smID;
834 iData->_importMeshSubDS = subDS;
840 //================================================================================
842 * \brief Return minimal square length of edges of 1D and 2D elements sharing the node
844 //================================================================================
846 double getMinEdgeLength2( const SMDS_MeshNode* n )
849 double minLen2 = Precision::Infinite();
850 for ( SMDS_ElemIteratorPtr eIt = n->GetInverseElementIterator(); eIt->more(); )
852 const SMDS_MeshElement* e = eIt->next();
853 const SMDSAbs_ElementType type = e->GetType();
854 if ( type != SMDSAbs_Edge && type != SMDSAbs_Face )
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 )
861 int iPrev = SMESH_MesherHelper::WrapIndex( i - 1, e->NbCornerNodes() );
862 minLen2 = Min( minLen2, p.SquareDistance( e->GetNode( iPrev )));
869 //=============================================================================
871 * Creates StdMeshers_Import_1D
873 //=============================================================================
875 StdMeshers_Import_1D::StdMeshers_Import_1D(int hypId, SMESH_Gen * gen)
876 :SMESH_1D_Algo(hypId, gen), _sourceHyp(0)
879 _shapeType = (1 << TopAbs_EDGE);
881 _compatibleHypothesis.push_back("ImportSource1D");
884 //=============================================================================
886 * Check presence of a hypothesis
888 //=============================================================================
890 bool StdMeshers_Import_1D::CheckHypothesis
892 const TopoDS_Shape& aShape,
893 SMESH_Hypothesis::Hypothesis_Status& aStatus)
897 const list <const SMESHDS_Hypothesis * >&hyps = GetUsedHypothesis(aMesh, aShape);
898 if ( hyps.size() == 0 )
900 aStatus = SMESH_Hypothesis::HYP_MISSING;
901 return false; // can't work with no hypothesis
904 if ( hyps.size() > 1 )
906 aStatus = SMESH_Hypothesis::HYP_ALREADY_EXIST;
910 const SMESHDS_Hypothesis *theHyp = hyps.front();
912 string hypName = theHyp->GetName();
914 if (hypName == _compatibleHypothesis.front())
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;
923 aStatus = SMESH_Hypothesis::HYP_INCOMPATIBLE;
927 //=============================================================================
929 * Import elements from the other mesh
931 //=============================================================================
933 bool StdMeshers_Import_1D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & theShape)
935 if ( !_sourceHyp ) return false;
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");
942 SMESH_MesherHelper helper(theMesh);
943 helper.SetSubShape(theShape);
944 SMESHDS_Mesh* tgtMesh = theMesh.GetMeshDS();
946 const TopoDS_Edge& geomEdge = TopoDS::Edge( theShape );
947 const double edgeTol = BRep_Tool::Tolerance( geomEdge );
948 const int shapeID = tgtMesh->ShapeToIndex( geomEdge );
951 double geomTol = Precision::Confusion();
952 for ( size_t iG = 0; iG < srcGroups.size(); ++iG )
954 const SMESHDS_GroupBase* srcGroup = srcGroups[iG]->GetGroupDS();
955 for ( SMDS_ElemIteratorPtr srcElems = srcGroup->GetElements(); srcElems->more(); )
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();
964 CurveProjector curveProjector( geomEdge, geomTol );
966 // get nodes on vertices
968 list < SMESH_TNodeXYZ > vertexNodes;
969 list < SMESH_TNodeXYZ >::iterator vNIt;
970 TopExp_Explorer vExp( theShape, TopAbs_VERTEX );
971 for ( ; vExp.More(); vExp.Next() )
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 );
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
984 vertexNodes.push_back( SMESH_TNodeXYZ( n ));
985 //MESSAGE("SMESH_Algo::VertexNode " << n->GetID() << " " << n->X() << " " << n->Y() << " " << n->Z() );
988 // import edges from groups
991 for ( size_t iG = 0; iG < srcGroups.size(); ++iG )
993 const SMESHDS_GroupBase* srcGroup = srcGroups[iG]->GetGroupDS();
995 const int meshID = srcGroup->GetMesh()->GetPersistentId();
996 const SMESH_Mesh* srcMesh = GetMeshByPersistentID( meshID );
997 if ( !srcMesh ) continue;
998 getMaps( srcMesh, &theMesh, n2n, e2e );
1000 SMDS_ElemIteratorPtr srcElems = srcGroup->GetElements();
1001 vector<const SMDS_MeshNode*> newNodes;
1002 while ( srcElems->more() ) // loop on group contents
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 ))
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 )
1017 TNodeNodeMap::iterator n2nIt = n2n->insert( make_pair( *node, nullptr )).first;
1018 if ( n2nIt->second )
1020 int sId = n2nIt->second->getshapeId();
1021 if ( sId != shapeID )
1023 if ( vertexIDs.count( sId ))
1029 else if ( !vertexNodes.empty() )
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)
1036 (*n2nIt).second = vNIt->_node;
1037 vertexNodes.erase( vNIt );
1042 if ( !n2nIt->second )
1044 // find out if the node lies on theShape
1045 SMESH_NodeXYZ xyz = *node;
1047 if ( curveProjector.IsOnCurve( xyz, dist2, u ))
1049 // tolerance relative to the length of surrounding edges
1050 double mytol2 = getMinEdgeLength2( *node ) / 25 / 25;
1051 if ( dist2 < mytol2 )
1053 SMDS_MeshNode* newNode = tgtMesh->AddNode( xyz.X(), xyz.Y(), xyz.Z() );
1054 n2nIt->second = newNode;
1055 tgtMesh->SetNodeOnEdge( newNode, shapeID, u );
1059 if ( !(newNodes[i] = n2nIt->second ))
1062 if ( !newNodes.back() )
1064 //MESSAGE("not all nodes of edge lie on theShape");
1065 continue; // not all nodes of edge lie on theShape
1069 SMDS_MeshElement * newEdge;
1070 if ( newNodes.size() == 3 )
1071 newEdge = tgtMesh->AddEdge( newNodes[0], newNodes[1], newNodes[2] );
1073 newEdge = tgtMesh->AddEdge( newNodes[0], newNodes[1]);
1074 tgtMesh->SetMeshElementOnShape( newEdge, shapeID );
1075 e2e->insert( make_pair( edge, newEdge ));
1077 if ( nbNodesOnVertex >= 2 ) // EDGE is meshed by a sole segment
1079 iG = srcGroups.size(); // stop looingp on groups
1082 } // loop on group contents
1086 return error("Empty source groups");
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 ))
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()))
1100 int nbPassedSegs = 0;
1104 const SMDS_MeshNode* n2 = seg->GetNode(0);
1105 n = ( n2 == n ? seg->GetNode(1) : n2 );
1106 if ( n->GetPosition()->GetTypeOfPosition() == SMDS_TOP_VERTEX )
1108 const SMDS_MeshElement* seg2 = 0;
1109 segIt = n->GetInverseElementIterator(SMDSAbs_Edge);
1110 while ( segIt->more() && !seg2 )
1111 if ( seg == ( seg2 = segIt->next()))
1115 if (nbPassedSegs > 0 && tgtSM->NbElements() > nbPassedSegs )
1116 return error( "Source elements overlap one another");
1118 isEdgeMeshed = ( tgtSM->NbElements() == nbPassedSegs &&
1119 n->GetPosition()->GetTypeOfPosition() == SMDS_TOP_VERTEX );
1121 if ( !isEdgeMeshed )
1122 return error( "Source elements don't cover totally the geometrical edge" );
1125 vector<SMESH_Mesh*> srcMeshes = _sourceHyp->GetSourceMeshes();
1126 for ( size_t i = 0; i < srcMeshes.size(); ++i )
1127 importMesh( srcMeshes[i], theMesh, _sourceHyp, theShape );
1132 //================================================================================
1134 * \brief Copy mesh and groups
1136 //================================================================================
1138 void StdMeshers_Import_1D::importMesh(const SMESH_Mesh* srcMesh,
1139 SMESH_Mesh & tgtMesh,
1140 StdMeshers_ImportSource1D* srcHyp,
1141 const TopoDS_Shape& tgtShape)
1143 // get submesh to store the imported mesh
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
1152 SMESHDS_Mesh* tgtMeshDS = tgtMesh.GetMeshDS();
1153 SMESH_MeshEditor additor( &tgtMesh );
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() )
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 )
1170 TNodeNodeMap::iterator n2nIt = n2n->insert( make_pair( *node, (SMDS_MeshNode*)0 )).first;
1171 if ( !n2nIt->second )
1173 (*n2nIt).second = tgtMeshDS->AddNode( (*node)->X(), (*node)->Y(), (*node)->Z());
1174 tgtSubMesh->AddNode( n2nIt->second );
1176 newNodes[i] = n2nIt->second;
1178 const SMDS_MeshElement* newElem =
1179 tgtMeshDS->FindElement( newNodes, elem->GetType(), /*noMedium=*/false );
1182 newElem = additor.AddElement( newNodes, elemType.Init( elem, /*basicOnly=*/false ));
1183 tgtSubMesh->AddElement( newElem );
1186 (*e2eIt).second = newElem;
1189 if ( srcMeshDS->NbNodes() > (int) n2n->size() )
1191 SMDS_NodeIteratorPtr nIt = srcMeshDS->nodesIterator();
1192 while( nIt->more() )
1194 const SMDS_MeshNode* node = nIt->next();
1195 if ( node->NbInverseElements() == 0 )
1197 const SMDS_MeshNode* newNode = tgtMeshDS->AddNode( node->X(), node->Y(), node->Z());
1198 n2n->insert( make_pair( node, newNode ));
1199 tgtSubMesh->AddNode( newNode );
1206 vector<SMESH_Group*> resultGroups;
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() )
1214 SMESH_Group* tgtGroup = groupIt->next();
1215 namesByType[ tgtGroup->GetGroupDS()->GetType() ].insert( tgtGroup->GetName() );
1219 SMESH_Mesh::GroupIteratorPtr groupIt = srcMesh->GetGroups();
1220 while ( groupIt->more() )
1222 SMESH_Group* srcGroup = groupIt->next();
1223 SMESHDS_GroupBase* srcGroupDS = srcGroup->GetGroupDS();
1224 string name = srcGroup->GetName();
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 );
1232 eIt = srcGroupDS->GetElements();
1233 if ( srcGroupDS->GetType() == SMDSAbs_Node )
1236 TNodeNodeMap::iterator n2nIt = n2n->find((const SMDS_MeshNode*) eIt->next() );
1237 if ( n2nIt != n2n->end() && n2nIt->second )
1238 newGroupDS->SMDSGroup().Add((*n2nIt).second );
1243 TElemElemMap::iterator e2eIt = e2e->find( eIt->next() );
1244 if ( e2eIt != e2e->end() && e2eIt->second )
1245 newGroupDS->SMDSGroup().Add((*e2eIt).second );
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 );
1259 //=============================================================================
1261 * \brief Set needed event listeners and create a submesh for a copied mesh
1263 * This method is called only if a submesh has HYP_OK algo_state.
1265 //=============================================================================
1267 void StdMeshers_Import_1D::setEventListener(SMESH_subMesh* subMesh,
1268 StdMeshers_ImportSource1D* sourceHyp)
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 );
1280 void StdMeshers_Import_1D::SetEventListener(SMESH_subMesh* subMesh)
1284 const TopoDS_Shape& tgtShape = subMesh->GetSubShape();
1285 SMESH_Mesh* tgtMesh = subMesh->GetFather();
1286 Hypothesis_Status aStatus;
1287 CheckHypothesis( *tgtMesh, tgtShape, aStatus );
1289 setEventListener( subMesh, _sourceHyp );
1292 void StdMeshers_Import_1D::SubmeshRestored(SMESH_subMesh* subMesh)
1294 SetEventListener(subMesh);
1297 //=============================================================================
1299 * Predict nb of mesh entities created by Compute()
1301 //=============================================================================
1303 bool StdMeshers_Import_1D::Evaluate(SMESH_Mesh & theMesh,
1304 const TopoDS_Shape & theShape,
1305 MapShapeNbElems& aResMap)
1307 if ( !_sourceHyp ) return false;
1309 const vector<SMESH_Group*>& srcGroups = _sourceHyp->GetGroups();
1310 if ( srcGroups.empty() )
1311 return error("Invalid source groups");
1313 vector<int> aVec(SMDSEntity_Last,0);
1315 bool toCopyMesh, toCopyGroups;
1316 _sourceHyp->GetCopySourceMesh(toCopyMesh, toCopyGroups);
1317 if ( toCopyMesh ) // the whole mesh is copied
1319 vector<SMESH_Mesh*> srcMeshes = _sourceHyp->GetSourceMeshes();
1320 for ( unsigned i = 0; i < srcMeshes.size(); ++i )
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);
1332 SMESH_MesherHelper helper(theMesh);
1334 const TopoDS_Edge& geomEdge = TopoDS::Edge( theShape );
1335 const double edgeTol = helper.MaxTolerance( geomEdge );
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 );
1342 // count edges imported from groups
1343 int nbEdges = 0, nbQuadEdges = 0;
1344 for ( size_t iG = 0; iG < srcGroups.size(); ++iG )
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
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());
1359 if ( helper.CheckNodeU( geomEdge, tmpNode, u, 10 * edgeTol, /*force=*/true ))
1360 ++( edge->IsQuadratic() ? nbQuadEdges : nbEdges);
1362 helper.GetMeshDS()->RemoveNode(tmpNode);
1365 int nbNodes = nbEdges + 2 * nbQuadEdges - 1;
1367 aVec[SMDSEntity_Node ] = nbNodes;
1368 aVec[SMDSEntity_Edge ] = nbEdges;
1369 aVec[SMDSEntity_Quad_Edge] = nbQuadEdges;
1372 SMESH_subMesh * sm = theMesh.GetSubMesh(theShape);
1373 aResMap.insert( make_pair( sm, aVec ));
1378 //================================================================================
1380 * \brief Return node-node and element-element maps for import of geiven source mesh
1382 //================================================================================
1384 void StdMeshers_Import_1D::getMaps(const SMESH_Mesh* srcMesh,
1385 SMESH_Mesh* tgtMesh,
1389 _ImportData* iData = _Listener::getImportData(srcMesh,tgtMesh);
1392 if ( iData->_copyMeshSubM.empty() )
1394 // n2n->clear(); -- for sharing nodes on EDGEs
1399 //================================================================================
1401 * \brief Return submesh corresponding to the copied mesh
1403 //================================================================================
1405 SMESH_subMesh* StdMeshers_Import_1D::getSubMeshOfCopiedMesh( SMESH_Mesh& tgtMesh,
1406 SMESH_Mesh& srcMesh )
1408 _ImportData* iData = _Listener::getImportData(&srcMesh,&tgtMesh);
1409 if ( iData->_copyMeshSubM.empty() ) return 0;
1410 SMESH_subMesh* sm = tgtMesh.GetSubMeshContaining( iData->_importMeshSubID );