1 // Copyright (C) 2007-2015 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
22 // File : SMESH_MeshEditor_i.cxx
23 // Author : Nicolas REJNERI
30 // A macro used in SMESH_TryCatch.hxx,
31 // it re-raises a CORBA SALOME exception thrown by SMESH_MeshEditor_i and caught by SMESH_CATCH
32 #define SMY_OWN_CATCH \
33 catch ( SALOME::SALOME_Exception & e ) { throw e; }
35 #include "SMESH_MeshEditor_i.hxx"
37 #include "SMDS_EdgePosition.hxx"
38 #include "SMDS_ElemIterator.hxx"
39 #include "SMDS_FacePosition.hxx"
40 #include "SMDS_IteratorOnIterators.hxx"
41 #include "SMDS_LinearEdge.hxx"
42 #include "SMDS_Mesh0DElement.hxx"
43 #include "SMDS_MeshFace.hxx"
44 #include "SMDS_MeshVolume.hxx"
45 #include "SMDS_PolyhedralVolumeOfNodes.hxx"
46 #include "SMDS_SetIterator.hxx"
47 #include "SMDS_VolumeTool.hxx"
48 #include "SMESHDS_Group.hxx"
49 #include "SMESHDS_GroupOnGeom.hxx"
50 #include "SMESH_ControlsDef.hxx"
51 #include "SMESH_Filter_i.hxx"
52 #include "SMESH_Gen_i.hxx"
53 #include "SMESH_Group.hxx"
54 #include "SMESH_Group_i.hxx"
55 #include "SMESH_MeshAlgos.hxx"
56 #include "SMESH_MeshPartDS.hxx"
57 #include "SMESH_MesherHelper.hxx"
58 #include "SMESH_PythonDump.hxx"
59 #include "SMESH_subMeshEventListener.hxx"
60 #include "SMESH_subMesh_i.hxx"
62 #include <utilities.h>
63 #include <Utils_ExceptHandlers.hxx>
64 #include <Utils_CorbaException.hxx>
65 #include <SALOMEDS_wrap.hxx>
66 #include <SALOME_GenericObj_i.hh>
67 #include <Basics_OCCTVersion.hxx>
69 #include <BRepAdaptor_Surface.hxx>
70 #include <BRep_Tool.hxx>
71 #include <TopExp_Explorer.hxx>
73 #include <TopoDS_Edge.hxx>
74 #include <TopoDS_Face.hxx>
79 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
83 #include <Standard_Failure.hxx>
86 #include <Standard_ErrorHandler.hxx>
92 #include "SMESH_TryCatch.hxx" // include after OCCT headers!
94 #define cast2Node(elem) static_cast<const SMDS_MeshNode*>( elem )
97 using SMESH::TPythonDump;
100 namespace MeshEditor_I {
102 //=============================================================================
104 * \brief Mesh to apply modifications for preview purposes
106 //=============================================================================
108 struct TPreviewMesh: public SMESH_Mesh
110 SMDSAbs_ElementType myPreviewType; // type to show
112 TPreviewMesh(SMDSAbs_ElementType previewElements = SMDSAbs_All) {
113 _isShapeToMesh = (_id =_studyId = 0);
114 _myMeshDS = new SMESHDS_Mesh( _id, true );
115 myPreviewType = previewElements;
118 virtual ~TPreviewMesh() { delete _myMeshDS; _myMeshDS = 0; }
119 //!< Copy a set of elements
120 void Copy(const TIDSortedElemSet & theElements,
121 TIDSortedElemSet& theCopyElements,
122 SMDSAbs_ElementType theSelectType = SMDSAbs_All,
123 SMDSAbs_ElementType theAvoidType = SMDSAbs_All)
125 // loop on theIDsOfElements
126 TIDSortedElemSet::const_iterator eIt = theElements.begin();
127 for ( ; eIt != theElements.end(); ++eIt )
129 const SMDS_MeshElement* anElem = *eIt;
130 if ( !anElem ) continue;
131 SMDSAbs_ElementType type = anElem->GetType();
132 if ( type == theAvoidType ||
133 ( theSelectType != SMDSAbs_All && type != theSelectType ))
135 const SMDS_MeshElement* anElemCopy;
136 if ( type == SMDSAbs_Node)
137 anElemCopy = Copy( cast2Node(anElem) );
139 anElemCopy = Copy( anElem );
141 theCopyElements.insert( theCopyElements.end(), anElemCopy );
145 SMDS_MeshElement* Copy( const SMDS_MeshElement* anElem )
147 // copy element nodes
148 int anElemNbNodes = anElem->NbNodes();
149 vector< int > anElemNodesID( anElemNbNodes ) ;
150 SMDS_ElemIteratorPtr itElemNodes = anElem->nodesIterator();
151 for ( int i = 0; itElemNodes->more(); i++)
153 const SMDS_MeshNode* anElemNode = cast2Node( itElemNodes->next() );
155 anElemNodesID[i] = anElemNode->GetID();
158 // creates a corresponding element on copied nodes
159 SMDS_MeshElement* anElemCopy = 0;
160 if ( anElem->IsPoly() && anElem->GetType() == SMDSAbs_Volume )
162 const SMDS_VtkVolume* ph =
163 dynamic_cast<const SMDS_VtkVolume*> (anElem);
165 anElemCopy = _myMeshDS->AddPolyhedralVolumeWithID
166 (anElemNodesID, ph->GetQuantities(),anElem->GetID());
169 anElemCopy = ::SMESH_MeshEditor(this).AddElement( anElemNodesID,
176 SMDS_MeshNode* Copy( const SMDS_MeshNode* anElemNode )
178 return _myMeshDS->AddNodeWithID(anElemNode->X(), anElemNode->Y(), anElemNode->Z(),
179 anElemNode->GetID());
183 GetMeshDS()->ClearMesh();
185 };// struct TPreviewMesh
187 static SMESH_NodeSearcher * theNodeSearcher = 0;
188 static SMESH_ElementSearcher * theElementSearcher = 0;
190 //=============================================================================
192 * \brief Deleter of theNodeSearcher at any compute event occured
194 //=============================================================================
196 struct TSearchersDeleter : public SMESH_subMeshEventListener
199 string myMeshPartIOR;
201 TSearchersDeleter(): SMESH_subMeshEventListener( false, // won't be deleted by submesh
202 "SMESH_MeshEditor_i::TSearchersDeleter"),
204 //!< Delete theNodeSearcher
207 if ( theNodeSearcher ) delete theNodeSearcher; theNodeSearcher = 0;
208 if ( theElementSearcher ) delete theElementSearcher; theElementSearcher = 0;
210 typedef map < int, SMESH_subMesh * > TDependsOnMap;
211 //!< The meshod called by submesh: do my main job
212 void ProcessEvent(const int, const int eventType, SMESH_subMesh* sm,
213 SMESH_subMeshEventListenerData*,const SMESH_Hypothesis*)
215 if ( eventType == SMESH_subMesh::COMPUTE_EVENT ) {
217 Unset( sm->GetFather() );
220 //!< set self on all submeshes and delete theNodeSearcher if other mesh is set
221 void Set(SMESH_Mesh* mesh, const string& meshPartIOR = string())
223 if ( myMesh != mesh || myMeshPartIOR != meshPartIOR)
230 myMeshPartIOR = meshPartIOR;
231 SMESH_subMesh* sm = mesh->GetSubMesh( mesh->GetShapeToMesh() );
232 SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator( /*includeSelf=*/true );
233 while ( smIt->more() )
236 sm->SetEventListener( this, 0, sm );
240 //!< delete self from all submeshes
241 void Unset(SMESH_Mesh* mesh)
243 if ( SMESH_subMesh* sm = mesh->GetSubMeshContaining(1) ) {
244 SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator( /*includeSelf=*/true );
245 while ( smIt->more() )
246 smIt->next()->DeleteEventListener( this );
251 } theSearchersDeleter;
253 TCollection_AsciiString mirrorTypeName( SMESH::SMESH_MeshEditor::MirrorType theMirrorType )
255 TCollection_AsciiString typeStr;
256 switch ( theMirrorType ) {
257 case SMESH::SMESH_MeshEditor::POINT:
258 typeStr = "SMESH.SMESH_MeshEditor.POINT";
260 case SMESH::SMESH_MeshEditor::AXIS:
261 typeStr = "SMESH.SMESH_MeshEditor.AXIS";
264 typeStr = "SMESH.SMESH_MeshEditor.PLANE";
268 //================================================================================
270 * \brief function for conversion of long_array to TIDSortedElemSet
271 * \param IDs - array of IDs
272 * \param aMesh - mesh
273 * \param aMap - collection to fill
274 * \param aType - element type
276 //================================================================================
278 void arrayToSet(const SMESH::long_array & IDs,
279 const SMESHDS_Mesh* aMesh,
280 TIDSortedElemSet& aMap,
281 const SMDSAbs_ElementType aType = SMDSAbs_All,
282 SMDS_MeshElement::Filter* aFilter = NULL)
284 SMDS_MeshElement::NonNullFilter filter1;
285 SMDS_MeshElement::TypeFilter filter2( aType );
287 if ( aFilter == NULL )
288 aFilter = ( aType == SMDSAbs_All ) ? (SMDS_MeshElement::Filter*) &filter1 : (SMDS_MeshElement::Filter*) &filter2;
290 SMDS_MeshElement::Filter & filter = *aFilter;
292 if ( aType == SMDSAbs_Node )
293 for (int i=0; i<IDs.length(); i++) {
294 const SMDS_MeshElement * elem = aMesh->FindNode( IDs[i] );
296 aMap.insert( aMap.end(), elem );
299 for (int i=0; i<IDs.length(); i++) {
300 const SMDS_MeshElement * elem = aMesh->FindElement( IDs[i] );
302 aMap.insert( aMap.end(), elem );
305 //================================================================================
307 * \brief Retrieve elements of given type from SMESH_IDSource
309 //================================================================================
311 enum IDSource_Error { IDSource_OK, IDSource_INVALID, IDSource_EMPTY };
313 bool idSourceToSet(SMESH::SMESH_IDSource_ptr theIDSource,
314 const SMESHDS_Mesh* theMeshDS,
315 TIDSortedElemSet& theElemSet,
316 const SMDSAbs_ElementType theType,
317 const bool emptyIfIsMesh = false,
318 IDSource_Error* error = 0)
321 if ( error ) *error = IDSource_OK;
323 if ( CORBA::is_nil( theIDSource ) )
325 if ( error ) *error = IDSource_INVALID;
328 if ( emptyIfIsMesh && SMESH::DownCast<SMESH_Mesh_i*>( theIDSource ))
330 if ( error && theMeshDS->GetMeshInfo().NbElements( theType ) == 0 )
331 *error = IDSource_EMPTY;
334 SMESH::long_array_var anIDs = theIDSource->GetIDs();
335 if ( anIDs->length() == 0 )
337 if ( error ) *error = IDSource_EMPTY;
340 SMESH::array_of_ElementType_var types = theIDSource->GetTypes();
341 if ( types->length() == 1 && types[0] == SMESH::NODE ) // group of nodes
343 if ( theType == SMDSAbs_All || theType == SMDSAbs_Node )
345 arrayToSet( anIDs, theMeshDS, theElemSet, SMDSAbs_Node );
349 if ( error ) *error = IDSource_INVALID;
355 arrayToSet( anIDs, theMeshDS, theElemSet, theType);
356 if ( bool(anIDs->length()) != bool(theElemSet.size()))
358 if ( error ) *error = IDSource_INVALID;
364 //================================================================================
366 * \brief Retrieve nodes from SMESH_IDSource
368 //================================================================================
370 void idSourceToNodeSet(SMESH::SMESH_IDSource_ptr theObject,
371 const SMESHDS_Mesh* theMeshDS,
372 TIDSortedNodeSet& theNodeSet)
375 if ( CORBA::is_nil( theObject ) )
377 SMESH::array_of_ElementType_var types = theObject->GetTypes();
378 SMESH::long_array_var aElementsId = theObject->GetIDs();
379 if ( types->length() == 1 && types[0] == SMESH::NODE)
381 for(int i = 0; i < aElementsId->length(); i++)
382 if ( const SMDS_MeshNode * n = theMeshDS->FindNode( aElementsId[i] ))
383 theNodeSet.insert( theNodeSet.end(), n);
385 else if ( SMESH::DownCast<SMESH_Mesh_i*>( theObject ))
387 SMDS_NodeIteratorPtr nIt = theMeshDS->nodesIterator();
388 while ( nIt->more( ))
389 if( const SMDS_MeshElement * elem = nIt->next() )
390 theNodeSet.insert( elem->begin_nodes(), elem->end_nodes());
394 for(int i = 0; i < aElementsId->length(); i++)
395 if( const SMDS_MeshElement * elem = theMeshDS->FindElement( aElementsId[i] ))
396 theNodeSet.insert( elem->begin_nodes(), elem->end_nodes());
400 //================================================================================
402 * \brief Returns elements connected to the given elements
404 //================================================================================
406 void getElementsAround(const TIDSortedElemSet& theElements,
407 const SMESHDS_Mesh* theMeshDS,
408 TIDSortedElemSet& theElementsAround)
410 if ( theElements.empty() ) return;
412 SMDSAbs_ElementType elemType = (*theElements.begin())->GetType();
413 bool sameElemType = ( elemType == (*theElements.rbegin())->GetType() );
415 theMeshDS->GetMeshInfo().NbElements( elemType ) == theElements.size() )
416 return; // all the elements are in theElements
419 elemType = SMDSAbs_All;
421 vector<bool> isNodeChecked( theMeshDS->NbNodes(), false );
423 TIDSortedElemSet::const_iterator elemIt = theElements.begin();
424 for ( ; elemIt != theElements.end(); ++elemIt )
426 const SMDS_MeshElement* e = *elemIt;
427 int i = e->NbCornerNodes();
430 const SMDS_MeshNode* n = e->GetNode( i );
431 if ( !isNodeChecked[ n->GetID() ])
433 isNodeChecked[ n->GetID() ] = true;
434 SMDS_ElemIteratorPtr invIt = n->GetInverseElementIterator(elemType);
435 while ( invIt->more() )
437 const SMDS_MeshElement* elemAround = invIt->next();
438 if ( !theElements.count( elemAround ))
439 theElementsAround.insert( elemAround );
446 //================================================================================
448 * \brief Return a string used to detect change of mesh part on which theElementSearcher
449 * is going to be used
451 //================================================================================
453 string getPartIOR( SMESH::SMESH_IDSource_ptr theMeshPart, SMESH::ElementType type)
455 string partIOR = SMESH_Gen_i::GetORB()->object_to_string( theMeshPart );
456 if ( SMESH_Group_i* group_i = SMESH::DownCast<SMESH_Group_i*>( theMeshPart ))
457 // take into account passible group modification
458 partIOR += SMESH_Comment( ((SMESHDS_Group*)group_i->GetGroupDS())->SMDSGroup().Tic() );
459 partIOR += SMESH_Comment( type );
463 } // namespace MeshEditor_I
465 using namespace MeshEditor_I;
467 //=============================================================================
471 //=============================================================================
473 SMESH_MeshEditor_i::SMESH_MeshEditor_i(SMESH_Mesh_i* theMesh, bool isPreview):
475 myMesh( &theMesh->GetImpl() ),
477 myIsPreviewMode ( isPreview ),
483 //================================================================================
487 //================================================================================
489 SMESH_MeshEditor_i::~SMESH_MeshEditor_i()
491 PortableServer::POA_var poa = SMESH_Gen_i::GetPOA();
492 PortableServer::ObjectId_var anObjectId = poa->servant_to_id(this);
493 poa->deactivate_object(anObjectId.in());
495 //deleteAuxIDSources();
496 delete myPreviewMesh; myPreviewMesh = 0;
497 delete myPreviewEditor; myPreviewEditor = 0;
500 //================================================================================
502 * \brief Clear members
504 //================================================================================
506 void SMESH_MeshEditor_i::initData(bool deleteSearchers)
508 if ( myIsPreviewMode ) {
509 if ( myPreviewMesh ) myPreviewMesh->RemoveAll();
512 if ( deleteSearchers )
513 TSearchersDeleter::Delete();
515 getEditor().GetError().reset();
516 getEditor().ClearLastCreated();
519 //================================================================================
521 * \brief Increment mesh modif time and optionally record that the performed
522 * modification may influence futher mesh re-compute.
523 * \param [in] isReComputeSafe - true if the modification does not infulence
524 * futher mesh re-compute
526 //================================================================================
528 void SMESH_MeshEditor_i::declareMeshModified( bool isReComputeSafe )
530 myMesh->GetMeshDS()->Modified();
531 if ( !isReComputeSafe )
532 myMesh->SetIsModified( true );
535 //================================================================================
537 * \brief Return either myEditor or myPreviewEditor depending on myIsPreviewMode.
538 * WARNING: in preview mode call getPreviewMesh() before getEditor()!
540 //================================================================================
542 ::SMESH_MeshEditor& SMESH_MeshEditor_i::getEditor()
544 if ( myIsPreviewMode && !myPreviewEditor ) {
545 if ( !myPreviewMesh ) getPreviewMesh();
546 myPreviewEditor = new ::SMESH_MeshEditor( myPreviewMesh );
548 return myIsPreviewMode ? *myPreviewEditor : myEditor;
551 //================================================================================
553 * \brief Initialize and return myPreviewMesh
554 * \param previewElements - type of elements to show in preview
556 * WARNING: call it once par a method!
558 //================================================================================
560 TPreviewMesh * SMESH_MeshEditor_i::getPreviewMesh(SMDSAbs_ElementType previewElements)
562 if ( !myPreviewMesh || myPreviewMesh->myPreviewType != previewElements )
564 delete myPreviewEditor;
566 delete myPreviewMesh;
567 myPreviewMesh = new TPreviewMesh( previewElements );
569 myPreviewMesh->Clear();
570 return myPreviewMesh;
573 //================================================================================
575 * Return data of mesh edition preview
577 //================================================================================
579 SMESH::MeshPreviewStruct* SMESH_MeshEditor_i::GetPreviewData()
580 throw (SALOME::SALOME_Exception)
583 const bool hasBadElems = ( getEditor().GetError() && getEditor().GetError()->HasBadElems() );
585 if ( myIsPreviewMode || hasBadElems ) { // --- MeshPreviewStruct filling ---
587 list<int> aNodesConnectivity;
588 typedef map<int, int> TNodesMap;
591 SMESHDS_Mesh* aMeshDS;
592 std::auto_ptr< SMESH_MeshPartDS > aMeshPartDS;
594 aMeshPartDS.reset( new SMESH_MeshPartDS( getEditor().GetError()->myBadElements ));
595 aMeshDS = aMeshPartDS.get();
598 aMeshDS = getEditor().GetMeshDS();
600 myPreviewData = new SMESH::MeshPreviewStruct();
601 myPreviewData->nodesXYZ.length(aMeshDS->NbNodes());
604 SMDSAbs_ElementType previewType = SMDSAbs_All;
606 if (TPreviewMesh * aPreviewMesh = dynamic_cast< TPreviewMesh* >( getEditor().GetMesh() )) {
607 previewType = aPreviewMesh->myPreviewType;
608 switch ( previewType ) {
609 case SMDSAbs_Edge : break;
610 case SMDSAbs_Face : break;
611 case SMDSAbs_Volume: break;
613 if ( aMeshDS->GetMeshInfo().NbElements() == 0 ) previewType = SMDSAbs_Node;
617 myPreviewData->elementTypes.length( aMeshDS->GetMeshInfo().NbElements( previewType ));
619 SMDS_ElemIteratorPtr itMeshElems = aMeshDS->elementsIterator(previewType);
621 while ( itMeshElems->more() ) {
622 const SMDS_MeshElement* aMeshElem = itMeshElems->next();
623 SMDS_NodeIteratorPtr itElemNodes = aMeshElem->nodeIterator();
624 while ( itElemNodes->more() ) {
625 const SMDS_MeshNode* aMeshNode = itElemNodes->next();
626 int aNodeID = aMeshNode->GetID();
627 TNodesMap::iterator anIter = nodesMap.find(aNodeID);
628 if ( anIter == nodesMap.end() ) {
629 // filling the nodes coordinates
630 myPreviewData->nodesXYZ[j].x = aMeshNode->X();
631 myPreviewData->nodesXYZ[j].y = aMeshNode->Y();
632 myPreviewData->nodesXYZ[j].z = aMeshNode->Z();
633 anIter = nodesMap.insert( make_pair(aNodeID, j) ).first;
636 aNodesConnectivity.push_back(anIter->second);
639 // filling the elements types
640 SMDSAbs_ElementType aType = aMeshElem->GetType();
641 bool isPoly = aMeshElem->IsPoly();
642 myPreviewData->elementTypes[i].SMDS_ElementType = (SMESH::ElementType) aType;
643 myPreviewData->elementTypes[i].isPoly = isPoly;
644 myPreviewData->elementTypes[i].nbNodesInElement = aMeshElem->NbNodes();
647 myPreviewData->nodesXYZ.length( j );
649 // filling the elements connectivities
650 list<int>::iterator aConnIter = aNodesConnectivity.begin();
651 myPreviewData->elementConnectivities.length(aNodesConnectivity.size());
652 for( int i = 0; aConnIter != aNodesConnectivity.end(); aConnIter++, i++ )
653 myPreviewData->elementConnectivities[i] = *aConnIter;
655 return myPreviewData._retn();
657 SMESH_CATCH( SMESH::throwCorbaException );
661 //================================================================================
663 * \brief Returns list of it's IDs of created nodes
664 * \retval SMESH::long_array* - list of node ID
666 //================================================================================
668 SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedNodes()
669 throw (SALOME::SALOME_Exception)
672 SMESH::long_array_var myLastCreatedNodes = new SMESH::long_array();
674 const SMESH_SequenceOfElemPtr& aSeq = getEditor().GetLastCreatedNodes();
675 myLastCreatedNodes->length( aSeq.Length() );
676 for (int i = 1; i <= aSeq.Length(); i++)
677 myLastCreatedNodes[i-1] = aSeq.Value(i)->GetID();
679 return myLastCreatedNodes._retn();
680 SMESH_CATCH( SMESH::throwCorbaException );
684 //================================================================================
686 * \brief Returns list of it's IDs of created elements
687 * \retval SMESH::long_array* - list of elements' ID
689 //================================================================================
691 SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedElems()
692 throw (SALOME::SALOME_Exception)
695 SMESH::long_array_var myLastCreatedElems = new SMESH::long_array();
697 const SMESH_SequenceOfElemPtr& aSeq = getEditor().GetLastCreatedElems();
698 myLastCreatedElems->length( aSeq.Length() );
699 for ( int i = 1; i <= aSeq.Length(); i++ )
700 myLastCreatedElems[i-1] = aSeq.Value(i)->GetID();
702 return myLastCreatedElems._retn();
703 SMESH_CATCH( SMESH::throwCorbaException );
707 //=======================================================================
708 //function : ClearLastCreated
709 //purpose : Clears sequences of last created elements and nodes
710 //=======================================================================
712 void SMESH_MeshEditor_i::ClearLastCreated() throw (SALOME::SALOME_Exception)
715 getEditor().ClearLastCreated();
716 SMESH_CATCH( SMESH::throwCorbaException );
719 //=======================================================================
721 * Returns description of an error/warning occured during the last operation
722 * WARNING: ComputeError.code >= 100 and no corresponding enum in IDL API
724 //=======================================================================
726 SMESH::ComputeError* SMESH_MeshEditor_i::GetLastError()
727 throw (SALOME::SALOME_Exception)
730 SMESH::ComputeError_var errOut = new SMESH::ComputeError;
731 SMESH_ComputeErrorPtr& errIn = getEditor().GetError();
732 if ( errIn && !errIn->IsOK() )
734 errOut->code = -( errIn->myName < 0 ? errIn->myName + 1: errIn->myName ); // -1 -> 0
735 errOut->comment = errIn->myComment.c_str();
736 errOut->subShapeID = -1;
737 errOut->hasBadMesh = !errIn->myBadElements.empty();
742 errOut->subShapeID = -1;
743 errOut->hasBadMesh = false;
746 return errOut._retn();
747 SMESH_CATCH( SMESH::throwCorbaException );
751 //=======================================================================
752 //function : MakeIDSource
753 //purpose : Wrap a sequence of ids in a SMESH_IDSource.
754 // Call UnRegister() as you fininsh using it!!
755 //=======================================================================
757 struct SMESH_MeshEditor_i::_IDSource : public virtual POA_SMESH::SMESH_IDSource,
758 public virtual SALOME::GenericObj_i
760 SMESH::long_array _ids;
761 SMESH::ElementType _type;
762 SMESH::SMESH_Mesh_ptr _mesh;
763 SMESH::long_array* GetIDs() { return new SMESH::long_array( _ids ); }
764 SMESH::long_array* GetMeshInfo() { return 0; }
765 SMESH::long_array* GetNbElementsByType()
767 SMESH::long_array_var aRes = new SMESH::long_array();
768 aRes->length(SMESH::NB_ELEMENT_TYPES);
769 for (int i = 0; i < SMESH::NB_ELEMENT_TYPES; i++)
770 aRes[ i ] = ( i == _type ) ? _ids.length() : 0;
773 SMESH::SMESH_Mesh_ptr GetMesh() { return SMESH::SMESH_Mesh::_duplicate( _mesh ); }
774 bool IsMeshInfoCorrect() { return true; }
775 SMESH::array_of_ElementType* GetTypes()
777 SMESH::array_of_ElementType_var types = new SMESH::array_of_ElementType;
778 if ( _ids.length() > 0 ) {
782 return types._retn();
784 SALOMEDS::TMPFile* GetVtkUgStream()
786 SALOMEDS::TMPFile_var SeqFile;
787 return SeqFile._retn();
791 SMESH::SMESH_IDSource_ptr SMESH_MeshEditor_i::MakeIDSource(const SMESH::long_array& ids,
792 SMESH::ElementType type)
794 _IDSource* idSrc = new _IDSource;
795 idSrc->_mesh = myMesh_i->_this();
798 if ( type == SMESH::ALL && ids.length() > 0 )
799 idSrc->_type = myMesh_i->GetElementType( ids[0], true );
801 SMESH::SMESH_IDSource_var anIDSourceVar = idSrc->_this();
803 return anIDSourceVar._retn();
806 bool SMESH_MeshEditor_i::IsTemporaryIDSource( SMESH::SMESH_IDSource_ptr& idSource )
808 return SMESH::DownCast<SMESH_MeshEditor_i::_IDSource*>( idSource );
811 CORBA::Long* SMESH_MeshEditor_i::GetTemporaryIDs( SMESH::SMESH_IDSource_ptr& idSource,
814 if ( _IDSource* tmpIdSource = SMESH::DownCast<SMESH_MeshEditor_i::_IDSource*>( idSource ))
816 nbIds = (int) tmpIdSource->_ids.length();
817 return & tmpIdSource->_ids[0];
823 // void SMESH_MeshEditor_i::deleteAuxIDSources()
825 // std::list< _IDSource* >::iterator idSrcIt = myAuxIDSources.begin();
826 // for ( ; idSrcIt != myAuxIDSources.end(); ++idSrcIt )
828 // myAuxIDSources.clear();
831 //=============================================================================
835 //=============================================================================
838 SMESH_MeshEditor_i::RemoveElements(const SMESH::long_array & IDsOfElements)
839 throw (SALOME::SALOME_Exception)
846 for (int i = 0; i < IDsOfElements.length(); i++)
847 IdList.push_back( IDsOfElements[i] );
849 // Update Python script
850 TPythonDump() << "isDone = " << this << ".RemoveElements( " << IDsOfElements << " )";
853 bool ret = getEditor().Remove( IdList, false );
855 declareMeshModified( /*isReComputeSafe=*/ IDsOfElements.length() == 0 ); // issue 0020693
858 SMESH_CATCH( SMESH::throwCorbaException );
862 //=============================================================================
866 //=============================================================================
868 CORBA::Boolean SMESH_MeshEditor_i::RemoveNodes(const SMESH::long_array & IDsOfNodes)
869 throw (SALOME::SALOME_Exception)
875 for (int i = 0; i < IDsOfNodes.length(); i++)
876 IdList.push_back( IDsOfNodes[i] );
878 // Update Python script
879 TPythonDump() << "isDone = " << this << ".RemoveNodes( " << IDsOfNodes << " )";
881 bool ret = getEditor().Remove( IdList, true );
883 declareMeshModified( /*isReComputeSafe=*/ !ret ); // issue 0020693
886 SMESH_CATCH( SMESH::throwCorbaException );
890 //=============================================================================
894 //=============================================================================
896 CORBA::Long SMESH_MeshEditor_i::RemoveOrphanNodes()
897 throw (SALOME::SALOME_Exception)
902 // Update Python script
903 TPythonDump() << "nbRemoved = " << this << ".RemoveOrphanNodes()";
905 // Create filter to find all orphan nodes
906 SMESH::Controls::Filter::TIdSequence seq;
907 SMESH::Controls::PredicatePtr predicate( new SMESH::Controls::FreeNodes() );
908 SMESH::Controls::Filter::GetElementsId( getMeshDS(), predicate, seq );
910 // remove orphan nodes (if there are any)
912 for ( int i = 0; i < seq.size(); i++ )
913 IdList.push_back( seq[i] );
915 int nbNodesBefore = myMesh->NbNodes();
916 getEditor().Remove( IdList, true );
917 int nbNodesAfter = myMesh->NbNodes();
919 declareMeshModified( /*isReComputeSafe=*/ IdList.size() == 0 ); // issue 0020693
920 return nbNodesBefore - nbNodesAfter;
922 SMESH_CATCH( SMESH::throwCorbaException );
926 //=============================================================================
930 //=============================================================================
932 CORBA::Long SMESH_MeshEditor_i::AddNode(CORBA::Double x,CORBA::Double y, CORBA::Double z)
933 throw (SALOME::SALOME_Exception)
938 const SMDS_MeshNode* N = getMeshDS()->AddNode(x, y, z);
940 // Update Python script
941 TPythonDump() << "nodeID = " << this << ".AddNode( "
942 << TVar( x ) << ", " << TVar( y ) << ", " << TVar( z )<< " )";
944 declareMeshModified( /*isReComputeSafe=*/false );
947 SMESH_CATCH( SMESH::throwCorbaException );
951 //=============================================================================
953 * Create 0D element on the given node.
955 //=============================================================================
957 CORBA::Long SMESH_MeshEditor_i::Add0DElement(CORBA::Long IDOfNode)
958 throw (SALOME::SALOME_Exception)
963 const SMDS_MeshNode* aNode = getMeshDS()->FindNode(IDOfNode);
964 SMDS_MeshElement* elem = getMeshDS()->Add0DElement(aNode);
966 // Update Python script
967 TPythonDump() << "elem0d = " << this << ".Add0DElement( " << IDOfNode <<" )";
969 declareMeshModified( /*isReComputeSafe=*/false );
971 return elem ? elem->GetID() : 0;
973 SMESH_CATCH( SMESH::throwCorbaException );
977 //=============================================================================
979 * Create a ball element on the given node.
981 //=============================================================================
983 CORBA::Long SMESH_MeshEditor_i::AddBall(CORBA::Long IDOfNode, CORBA::Double diameter)
984 throw (SALOME::SALOME_Exception)
989 if ( diameter < std::numeric_limits<double>::min() )
990 THROW_SALOME_CORBA_EXCEPTION("Invalid diameter", SALOME::BAD_PARAM);
992 const SMDS_MeshNode* aNode = getMeshDS()->FindNode(IDOfNode);
993 SMDS_MeshElement* elem = getMeshDS()->AddBall(aNode, diameter);
995 // Update Python script
996 TPythonDump() << "ballElem = "
997 << this << ".AddBall( " << IDOfNode << ", " << diameter <<" )";
999 declareMeshModified( /*isReComputeSafe=*/false );
1000 return elem ? elem->GetID() : 0;
1002 SMESH_CATCH( SMESH::throwCorbaException );
1006 //=============================================================================
1008 * Create an edge, either linear and quadratic (this is determed
1009 * by number of given nodes, two or three)
1011 //=============================================================================
1013 CORBA::Long SMESH_MeshEditor_i::AddEdge(const SMESH::long_array & IDsOfNodes)
1014 throw (SALOME::SALOME_Exception)
1019 int NbNodes = IDsOfNodes.length();
1020 SMDS_MeshElement* elem = 0;
1023 CORBA::Long index1 = IDsOfNodes[0];
1024 CORBA::Long index2 = IDsOfNodes[1];
1025 elem = getMeshDS()->AddEdge( getMeshDS()->FindNode(index1),
1026 getMeshDS()->FindNode(index2));
1028 // Update Python script
1029 TPythonDump() << "edge = " << this << ".AddEdge([ "
1030 << index1 << ", " << index2 <<" ])";
1033 CORBA::Long n1 = IDsOfNodes[0];
1034 CORBA::Long n2 = IDsOfNodes[1];
1035 CORBA::Long n12 = IDsOfNodes[2];
1036 elem = getMeshDS()->AddEdge( getMeshDS()->FindNode(n1),
1037 getMeshDS()->FindNode(n2),
1038 getMeshDS()->FindNode(n12));
1039 // Update Python script
1040 TPythonDump() << "edgeID = " << this << ".AddEdge([ "
1041 <<n1<<", "<<n2<<", "<<n12<<" ])";
1044 declareMeshModified( /*isReComputeSafe=*/false );
1045 return elem ? elem->GetID() : 0;
1047 SMESH_CATCH( SMESH::throwCorbaException );
1051 //=============================================================================
1055 //=============================================================================
1057 CORBA::Long SMESH_MeshEditor_i::AddFace(const SMESH::long_array & IDsOfNodes)
1058 throw (SALOME::SALOME_Exception)
1063 int NbNodes = IDsOfNodes.length();
1069 std::vector<const SMDS_MeshNode*> nodes (NbNodes);
1070 for (int i = 0; i < NbNodes; i++)
1071 nodes[i] = getMeshDS()->FindNode(IDsOfNodes[i]);
1073 SMDS_MeshElement* elem = 0;
1075 case 3: elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2]); break;
1076 case 4: elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3]); break;
1077 case 6: elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
1078 nodes[4], nodes[5]); break;
1079 case 7: elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
1080 nodes[4], nodes[5], nodes[6]); break;
1081 case 8: elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
1082 nodes[4], nodes[5], nodes[6], nodes[7]); break;
1083 case 9: elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
1084 nodes[4], nodes[5], nodes[6], nodes[7],
1086 default: elem = getMeshDS()->AddPolygonalFace(nodes);
1089 // Update Python script
1090 TPythonDump() << "faceID = " << this << ".AddFace( " << IDsOfNodes << " )";
1092 declareMeshModified( /*isReComputeSafe=*/false );
1094 return elem ? elem->GetID() : 0;
1096 SMESH_CATCH( SMESH::throwCorbaException );
1100 //=============================================================================
1104 //=============================================================================
1105 CORBA::Long SMESH_MeshEditor_i::AddPolygonalFace (const SMESH::long_array & IDsOfNodes)
1106 throw (SALOME::SALOME_Exception)
1111 int NbNodes = IDsOfNodes.length();
1112 std::vector<const SMDS_MeshNode*> nodes (NbNodes);
1113 for (int i = 0; i < NbNodes; i++)
1114 nodes[i] = getMeshDS()->FindNode(IDsOfNodes[i]);
1116 const SMDS_MeshElement* elem = getMeshDS()->AddPolygonalFace(nodes);
1118 // Update Python script
1119 TPythonDump() <<"faceID = "<<this<<".AddPolygonalFace( "<<IDsOfNodes<<" )";
1121 declareMeshModified( /*isReComputeSafe=*/false );
1122 return elem ? elem->GetID() : 0;
1124 SMESH_CATCH( SMESH::throwCorbaException );
1128 //=============================================================================
1130 * Create volume, either linear and quadratic (this is determed
1131 * by number of given nodes)
1133 //=============================================================================
1135 CORBA::Long SMESH_MeshEditor_i::AddVolume(const SMESH::long_array & IDsOfNodes)
1136 throw (SALOME::SALOME_Exception)
1141 int NbNodes = IDsOfNodes.length();
1142 vector< const SMDS_MeshNode*> n(NbNodes);
1143 for(int i=0;i<NbNodes;i++)
1144 n[i]= getMeshDS()->FindNode(IDsOfNodes[i]);
1146 SMDS_MeshElement* elem = 0;
1149 case 4 :elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3]); break;
1150 case 5 :elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4]); break;
1151 case 6 :elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5]); break;
1152 case 8 :elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7]); break;
1153 case 10:elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],
1154 n[6],n[7],n[8],n[9]);
1156 case 12:elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],
1157 n[6],n[7],n[8],n[9],n[10],n[11]);
1159 case 13:elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],
1160 n[7],n[8],n[9],n[10],n[11],n[12]);
1162 case 15:elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],n[8],
1163 n[9],n[10],n[11],n[12],n[13],n[14]);
1165 case 20:elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],
1166 n[8],n[9],n[10],n[11],n[12],n[13],n[14],
1167 n[15],n[16],n[17],n[18],n[19]);
1169 case 27:elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],
1170 n[8],n[9],n[10],n[11],n[12],n[13],n[14],
1171 n[15],n[16],n[17],n[18],n[19],
1172 n[20],n[21],n[22],n[23],n[24],n[25],n[26]);
1176 // Update Python script
1177 TPythonDump() << "volID = " << this << ".AddVolume( " << IDsOfNodes << " )";
1179 declareMeshModified( /*isReComputeSafe=*/false );
1180 return elem ? elem->GetID() : 0;
1182 SMESH_CATCH( SMESH::throwCorbaException );
1186 //=============================================================================
1188 * AddPolyhedralVolume
1190 //=============================================================================
1191 CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolume (const SMESH::long_array & IDsOfNodes,
1192 const SMESH::long_array & Quantities)
1193 throw (SALOME::SALOME_Exception)
1198 int NbNodes = IDsOfNodes.length();
1199 std::vector<const SMDS_MeshNode*> n (NbNodes);
1200 for (int i = 0; i < NbNodes; i++)
1202 const SMDS_MeshNode* aNode = getMeshDS()->FindNode(IDsOfNodes[i]);
1203 if (!aNode) return 0;
1207 int NbFaces = Quantities.length();
1208 std::vector<int> q (NbFaces);
1209 for (int j = 0; j < NbFaces; j++)
1210 q[j] = Quantities[j];
1212 const SMDS_MeshElement* elem = getMeshDS()->AddPolyhedralVolume(n, q);
1214 // Update Python script
1215 TPythonDump() << "volID = " << this << ".AddPolyhedralVolume( "
1216 << IDsOfNodes << ", " << Quantities << " )";
1218 declareMeshModified( /*isReComputeSafe=*/false );
1219 return elem ? elem->GetID() : 0;
1221 SMESH_CATCH( SMESH::throwCorbaException );
1225 //=============================================================================
1227 * AddPolyhedralVolumeByFaces
1229 //=============================================================================
1231 CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolumeByFaces (const SMESH::long_array & IdsOfFaces)
1232 throw (SALOME::SALOME_Exception)
1237 int NbFaces = IdsOfFaces.length();
1238 std::vector<const SMDS_MeshNode*> poly_nodes;
1239 std::vector<int> quantities (NbFaces);
1241 for (int i = 0; i < NbFaces; i++) {
1242 const SMDS_MeshElement* aFace = getMeshDS()->FindElement(IdsOfFaces[i]);
1243 quantities[i] = aFace->NbNodes();
1245 SMDS_ElemIteratorPtr It = aFace->nodesIterator();
1246 while (It->more()) {
1247 poly_nodes.push_back(static_cast<const SMDS_MeshNode *>(It->next()));
1251 const SMDS_MeshElement* elem = getMeshDS()->AddPolyhedralVolume(poly_nodes, quantities);
1253 // Update Python script
1254 TPythonDump() << "volID = " << this << ".AddPolyhedralVolumeByFaces( "
1255 << IdsOfFaces << " )";
1257 declareMeshModified( /*isReComputeSafe=*/false );
1258 return elem ? elem->GetID() : 0;
1260 SMESH_CATCH( SMESH::throwCorbaException );
1264 //=============================================================================
1266 // \brief Create 0D elements on all nodes of the given object except those
1267 // nodes on which a 0D element already exists.
1268 // \param theObject object on whose nodes 0D elements will be created.
1269 // \param theGroupName optional name of a group to add 0D elements created
1270 // and/or found on nodes of \a theObject.
1271 // \return an object (a new group or a temporary SMESH_IDSource) holding
1272 // ids of new and/or found 0D elements.
1274 //=============================================================================
1276 SMESH::SMESH_IDSource_ptr
1277 SMESH_MeshEditor_i::Create0DElementsOnAllNodes(SMESH::SMESH_IDSource_ptr theObject,
1278 const char* theGroupName)
1279 throw (SALOME::SALOME_Exception)
1284 SMESH::SMESH_IDSource_var result;
1287 TIDSortedElemSet elements, elems0D;
1288 prepareIdSource( theObject );
1289 if ( idSourceToSet( theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
1290 getEditor().Create0DElementsOnAllNodes( elements, elems0D );
1292 SMESH::long_array_var newElems = new SMESH::long_array;
1293 newElems->length( elems0D.size() );
1294 TIDSortedElemSet::iterator eIt = elems0D.begin();
1295 for ( size_t i = 0; i < elems0D.size(); ++i, ++eIt )
1296 newElems[ i ] = (*eIt)->GetID();
1298 SMESH::SMESH_GroupBase_var groupToFill;
1299 if ( theGroupName && strlen( theGroupName ))
1301 // Get existing group named theGroupName
1302 SMESH::ListOfGroups_var groups = myMesh_i->GetGroups();
1303 for (int i = 0, nbGroups = groups->length(); i < nbGroups; i++ ) {
1304 SMESH::SMESH_GroupBase_var group = groups[i];
1305 if ( !group->_is_nil() ) {
1306 CORBA::String_var name = group->GetName();
1307 if ( strcmp( name.in(), theGroupName ) == 0 && group->GetType() == SMESH::ELEM0D ) {
1308 groupToFill = group;
1313 if ( groupToFill->_is_nil() )
1314 groupToFill = myMesh_i->CreateGroup( SMESH::ELEM0D, theGroupName );
1315 else if ( !SMESH::DownCast< SMESH_Group_i* > ( groupToFill ))
1316 groupToFill = myMesh_i->ConvertToStandalone( groupToFill );
1319 if ( SMESH_Group_i* group_i = SMESH::DownCast< SMESH_Group_i* > ( groupToFill ))
1321 group_i->Add( newElems );
1322 result = SMESH::SMESH_IDSource::_narrow( groupToFill );
1323 pyDump << groupToFill;
1327 result = MakeIDSource( newElems, SMESH::ELEM0D );
1328 pyDump << "elem0DIDs";
1331 pyDump << " = " << this << ".Create0DElementsOnAllNodes( "
1332 << theObject << ", '" << theGroupName << "' )";
1334 return result._retn();
1336 SMESH_CATCH( SMESH::throwCorbaException );
1340 //=============================================================================
1342 * \brief Bind a node to a vertex
1343 * \param NodeID - node ID
1344 * \param VertexID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
1345 * \retval boolean - false if NodeID or VertexID is invalid
1347 //=============================================================================
1349 void SMESH_MeshEditor_i::SetNodeOnVertex(CORBA::Long NodeID, CORBA::Long VertexID)
1350 throw (SALOME::SALOME_Exception)
1354 SMESHDS_Mesh * mesh = getMeshDS();
1355 SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
1357 THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);
1359 if ( mesh->MaxShapeIndex() < VertexID )
1360 THROW_SALOME_CORBA_EXCEPTION("Invalid VertexID", SALOME::BAD_PARAM);
1362 TopoDS_Shape shape = mesh->IndexToShape( VertexID );
1363 if ( shape.ShapeType() != TopAbs_VERTEX )
1364 THROW_SALOME_CORBA_EXCEPTION("Invalid VertexID", SALOME::BAD_PARAM);
1366 mesh->SetNodeOnVertex( node, VertexID );
1368 myMesh->SetIsModified( true );
1370 SMESH_CATCH( SMESH::throwCorbaException );
1373 //=============================================================================
1375 * \brief Store node position on an edge
1376 * \param NodeID - node ID
1377 * \param EdgeID - edge ID available through GEOM_Object.GetSubShapeIndices()[0]
1378 * \param paramOnEdge - parameter on edge where the node is located
1379 * \retval boolean - false if any parameter is invalid
1381 //=============================================================================
1383 void SMESH_MeshEditor_i::SetNodeOnEdge(CORBA::Long NodeID, CORBA::Long EdgeID,
1384 CORBA::Double paramOnEdge)
1385 throw (SALOME::SALOME_Exception)
1389 SMESHDS_Mesh * mesh = getMeshDS();
1390 SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
1392 THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);
1394 if ( mesh->MaxShapeIndex() < EdgeID )
1395 THROW_SALOME_CORBA_EXCEPTION("Invalid EdgeID", SALOME::BAD_PARAM);
1397 TopoDS_Shape shape = mesh->IndexToShape( EdgeID );
1398 if ( shape.ShapeType() != TopAbs_EDGE )
1399 THROW_SALOME_CORBA_EXCEPTION("Invalid EdgeID", SALOME::BAD_PARAM);
1402 BRep_Tool::Range( TopoDS::Edge( shape ), f,l);
1403 if ( paramOnEdge < f || paramOnEdge > l )
1404 THROW_SALOME_CORBA_EXCEPTION("Invalid paramOnEdge", SALOME::BAD_PARAM);
1406 mesh->SetNodeOnEdge( node, EdgeID, paramOnEdge );
1408 myMesh->SetIsModified( true );
1410 SMESH_CATCH( SMESH::throwCorbaException );
1413 //=============================================================================
1415 * \brief Store node position on a face
1416 * \param NodeID - node ID
1417 * \param FaceID - face ID available through GEOM_Object.GetSubShapeIndices()[0]
1418 * \param u - U parameter on face where the node is located
1419 * \param v - V parameter on face where the node is located
1420 * \retval boolean - false if any parameter is invalid
1422 //=============================================================================
1424 void SMESH_MeshEditor_i::SetNodeOnFace(CORBA::Long NodeID, CORBA::Long FaceID,
1425 CORBA::Double u, CORBA::Double v)
1426 throw (SALOME::SALOME_Exception)
1429 SMESHDS_Mesh * mesh = getMeshDS();
1430 SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
1432 THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);
1434 if ( mesh->MaxShapeIndex() < FaceID )
1435 THROW_SALOME_CORBA_EXCEPTION("Invalid FaceID", SALOME::BAD_PARAM);
1437 TopoDS_Shape shape = mesh->IndexToShape( FaceID );
1438 if ( shape.ShapeType() != TopAbs_FACE )
1439 THROW_SALOME_CORBA_EXCEPTION("Invalid FaceID", SALOME::BAD_PARAM);
1441 BRepAdaptor_Surface surf( TopoDS::Face( shape ));
1442 bool isOut = ( u < surf.FirstUParameter() ||
1443 u > surf.LastUParameter() ||
1444 v < surf.FirstVParameter() ||
1445 v > surf.LastVParameter() );
1449 MESSAGE ( "FACE " << FaceID << " (" << u << "," << v << ") out of "
1450 << " u( " << surf.FirstUParameter()
1451 << "," << surf.LastUParameter()
1452 << ") v( " << surf.FirstVParameter()
1453 << "," << surf.LastVParameter() << ")" );
1455 THROW_SALOME_CORBA_EXCEPTION("Invalid UV", SALOME::BAD_PARAM);
1458 mesh->SetNodeOnFace( node, FaceID, u, v );
1459 myMesh->SetIsModified( true );
1461 SMESH_CATCH( SMESH::throwCorbaException );
1464 //=============================================================================
1466 * \brief Bind a node to a solid
1467 * \param NodeID - node ID
1468 * \param SolidID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
1469 * \retval boolean - false if NodeID or SolidID is invalid
1471 //=============================================================================
1473 void SMESH_MeshEditor_i::SetNodeInVolume(CORBA::Long NodeID, CORBA::Long SolidID)
1474 throw (SALOME::SALOME_Exception)
1477 SMESHDS_Mesh * mesh = getMeshDS();
1478 SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
1480 THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);
1482 if ( mesh->MaxShapeIndex() < SolidID )
1483 THROW_SALOME_CORBA_EXCEPTION("Invalid SolidID", SALOME::BAD_PARAM);
1485 TopoDS_Shape shape = mesh->IndexToShape( SolidID );
1486 if ( shape.ShapeType() != TopAbs_SOLID &&
1487 shape.ShapeType() != TopAbs_SHELL)
1488 THROW_SALOME_CORBA_EXCEPTION("Invalid SolidID", SALOME::BAD_PARAM);
1490 mesh->SetNodeInVolume( node, SolidID );
1492 SMESH_CATCH( SMESH::throwCorbaException );
1495 //=============================================================================
1497 * \brief Bind an element to a shape
1498 * \param ElementID - element ID
1499 * \param ShapeID - shape ID available through GEOM_Object.GetSubShapeIndices()[0]
1501 //=============================================================================
1503 void SMESH_MeshEditor_i::SetMeshElementOnShape(CORBA::Long ElementID,
1504 CORBA::Long ShapeID)
1505 throw (SALOME::SALOME_Exception)
1508 SMESHDS_Mesh * mesh = getMeshDS();
1509 SMDS_MeshElement* elem = const_cast<SMDS_MeshElement*>(mesh->FindElement(ElementID));
1511 THROW_SALOME_CORBA_EXCEPTION("Invalid ElementID", SALOME::BAD_PARAM);
1513 if ( mesh->MaxShapeIndex() < ShapeID || ShapeID < 1 )
1514 THROW_SALOME_CORBA_EXCEPTION("Invalid ShapeID", SALOME::BAD_PARAM);
1516 TopoDS_Shape shape = mesh->IndexToShape( ShapeID );
1517 if ( shape.ShapeType() != TopAbs_EDGE &&
1518 shape.ShapeType() != TopAbs_FACE &&
1519 shape.ShapeType() != TopAbs_SOLID &&
1520 shape.ShapeType() != TopAbs_SHELL )
1521 THROW_SALOME_CORBA_EXCEPTION("Invalid shape type", SALOME::BAD_PARAM);
1523 mesh->SetMeshElementOnShape( elem, ShapeID );
1525 myMesh->SetIsModified( true );
1527 SMESH_CATCH( SMESH::throwCorbaException );
1530 //=============================================================================
1534 //=============================================================================
1536 CORBA::Boolean SMESH_MeshEditor_i::InverseDiag(CORBA::Long NodeID1,
1537 CORBA::Long NodeID2)
1538 throw (SALOME::SALOME_Exception)
1543 const SMDS_MeshNode * n1 = getMeshDS()->FindNode( NodeID1 );
1544 const SMDS_MeshNode * n2 = getMeshDS()->FindNode( NodeID2 );
1548 // Update Python script
1549 TPythonDump() << "isDone = " << this << ".InverseDiag( "
1550 << NodeID1 << ", " << NodeID2 << " )";
1552 int ret = getEditor().InverseDiag ( n1, n2 );
1554 declareMeshModified( /*isReComputeSafe=*/false );
1557 SMESH_CATCH( SMESH::throwCorbaException );
1561 //=============================================================================
1565 //=============================================================================
1567 CORBA::Boolean SMESH_MeshEditor_i::DeleteDiag(CORBA::Long NodeID1,
1568 CORBA::Long NodeID2)
1569 throw (SALOME::SALOME_Exception)
1574 const SMDS_MeshNode * n1 = getMeshDS()->FindNode( NodeID1 );
1575 const SMDS_MeshNode * n2 = getMeshDS()->FindNode( NodeID2 );
1579 // Update Python script
1580 TPythonDump() << "isDone = " << this << ".DeleteDiag( "
1581 << NodeID1 << ", " << NodeID2 << " )";
1584 bool stat = getEditor().DeleteDiag ( n1, n2 );
1586 declareMeshModified( /*isReComputeSafe=*/!stat );
1590 SMESH_CATCH( SMESH::throwCorbaException );
1594 //=============================================================================
1598 //=============================================================================
1600 CORBA::Boolean SMESH_MeshEditor_i::Reorient(const SMESH::long_array & IDsOfElements)
1601 throw (SALOME::SALOME_Exception)
1606 for (int i = 0; i < IDsOfElements.length(); i++)
1608 CORBA::Long index = IDsOfElements[i];
1609 const SMDS_MeshElement * elem = getMeshDS()->FindElement(index);
1611 getEditor().Reorient( elem );
1613 // Update Python script
1614 TPythonDump() << "isDone = " << this << ".Reorient( " << IDsOfElements << " )";
1616 declareMeshModified( /*isReComputeSafe=*/ IDsOfElements.length() == 0 );
1619 SMESH_CATCH( SMESH::throwCorbaException );
1623 //=============================================================================
1627 //=============================================================================
1629 CORBA::Boolean SMESH_MeshEditor_i::ReorientObject(SMESH::SMESH_IDSource_ptr theObject)
1630 throw (SALOME::SALOME_Exception)
1635 TPythonDump aTPythonDump; // suppress dump in Reorient()
1637 prepareIdSource( theObject );
1639 SMESH::long_array_var anElementsId = theObject->GetIDs();
1640 CORBA::Boolean isDone = Reorient(anElementsId);
1642 // Update Python script
1643 aTPythonDump << "isDone = " << this << ".ReorientObject( " << theObject << " )";
1645 declareMeshModified( /*isReComputeSafe=*/ anElementsId->length() == 0 );
1648 SMESH_CATCH( SMESH::throwCorbaException );
1652 //=======================================================================
1653 //function : Reorient2D
1654 //purpose : Reorient faces contained in \a the2Dgroup.
1655 // the2Dgroup - the mesh or its part to reorient
1656 // theDirection - desired direction of normal of \a theFace
1657 // theFace - ID of face whose orientation is checked.
1658 // It can be < 1 then \a thePoint is used to find a face.
1659 // thePoint - is used to find a face if \a theFace < 1.
1660 // return number of reoriented elements.
1661 //=======================================================================
1663 CORBA::Long SMESH_MeshEditor_i::Reorient2D(SMESH::SMESH_IDSource_ptr the2Dgroup,
1664 const SMESH::DirStruct& theDirection,
1665 CORBA::Long theFace,
1666 const SMESH::PointStruct& thePoint)
1667 throw (SALOME::SALOME_Exception)
1670 initData(/*deleteSearchers=*/false);
1672 TIDSortedElemSet elements;
1673 prepareIdSource( the2Dgroup );
1674 IDSource_Error error;
1675 idSourceToSet( the2Dgroup, getMeshDS(), elements, SMDSAbs_Face, /*emptyIfIsMesh=*/1, &error );
1676 if ( error == IDSource_EMPTY )
1678 if ( error == IDSource_INVALID )
1679 THROW_SALOME_CORBA_EXCEPTION("No faces in given group", SALOME::BAD_PARAM);
1682 const SMDS_MeshElement* face = 0;
1685 face = getMeshDS()->FindElement( theFace );
1687 THROW_SALOME_CORBA_EXCEPTION("Inexistent face given", SALOME::BAD_PARAM);
1688 if ( face->GetType() != SMDSAbs_Face )
1689 THROW_SALOME_CORBA_EXCEPTION("Wrong element type", SALOME::BAD_PARAM);
1693 // create theElementSearcher if needed
1694 theSearchersDeleter.Set( myMesh, getPartIOR( the2Dgroup, SMESH::FACE ));
1695 if ( !theElementSearcher )
1697 if ( elements.empty() ) // search in the whole mesh
1699 if ( myMesh->NbFaces() == 0 )
1700 THROW_SALOME_CORBA_EXCEPTION("No faces in the mesh", SALOME::BAD_PARAM);
1702 theElementSearcher = SMESH_MeshAlgos::GetElementSearcher( *getMeshDS() );
1706 typedef SMDS_SetIterator<const SMDS_MeshElement*, TIDSortedElemSet::const_iterator > TIter;
1707 SMDS_ElemIteratorPtr elemsIt( new TIter( elements.begin(), elements.end() ));
1709 theElementSearcher = SMESH_MeshAlgos::GetElementSearcher( *getMeshDS(), elemsIt);
1713 gp_Pnt p( thePoint.x, thePoint.y, thePoint.z );
1714 face = theElementSearcher->FindClosestTo( p, SMDSAbs_Face );
1717 THROW_SALOME_CORBA_EXCEPTION("No face found by point", SALOME::INTERNAL_ERROR );
1718 if ( !elements.empty() && !elements.count( face ))
1719 THROW_SALOME_CORBA_EXCEPTION("Found face is not in the group", SALOME::BAD_PARAM );
1722 const SMESH::PointStruct * P = &theDirection.PS;
1723 gp_Vec dirVec( P->x, P->y, P->z );
1724 if ( dirVec.Magnitude() < std::numeric_limits< double >::min() )
1725 THROW_SALOME_CORBA_EXCEPTION("Zero size vector", SALOME::BAD_PARAM);
1727 int nbReori = getEditor().Reorient2D( elements, dirVec, face );
1730 declareMeshModified( /*isReComputeSafe=*/false );
1732 TPythonDump() << this << ".Reorient2D( "
1733 << the2Dgroup << ", "
1734 << theDirection << ", "
1736 << thePoint << " )";
1740 SMESH_CATCH( SMESH::throwCorbaException );
1744 //=======================================================================
1745 //function : Reorient2DBy3D
1746 //purpose : Reorient faces basing on orientation of adjacent volumes.
1747 //=======================================================================
1749 CORBA::Long SMESH_MeshEditor_i::Reorient2DBy3D(const SMESH::ListOfIDSources& faceGroups,
1750 SMESH::SMESH_IDSource_ptr volumeGroup,
1751 CORBA::Boolean outsideNormal)
1752 throw (SALOME::SALOME_Exception)
1757 TIDSortedElemSet volumes;
1758 prepareIdSource( volumeGroup );
1759 IDSource_Error volsError;
1760 idSourceToSet( volumeGroup, getMeshDS(), volumes, SMDSAbs_Volume, /*emptyIfMesh=*/1, &volsError);
1763 for ( size_t i = 0; i < faceGroups.length(); ++i )
1765 SMESH::SMESH_IDSource_ptr faceGrp = faceGroups[i].in();
1766 prepareIdSource( faceGrp );
1768 TIDSortedElemSet faces;
1769 IDSource_Error error;
1770 idSourceToSet( faceGrp, getMeshDS(), faces, SMDSAbs_Face, /*emptyIfIsMesh=*/1, &error );
1771 if ( error == IDSource_INVALID && faceGroups.length() == 1 )
1772 THROW_SALOME_CORBA_EXCEPTION("No faces in a given object", SALOME::BAD_PARAM);
1773 if ( error == IDSource_OK && volsError != IDSource_OK )
1774 THROW_SALOME_CORBA_EXCEPTION("No volumes in a given object", SALOME::BAD_PARAM);
1776 nbReori += getEditor().Reorient2DBy3D( faces, volumes, outsideNormal );
1778 if ( error != IDSource_EMPTY && faces.empty() ) // all faces in the mesh treated
1783 declareMeshModified( /*isReComputeSafe=*/false );
1785 TPythonDump() << this << ".Reorient2DBy3D( "
1786 << faceGroups << ", "
1787 << volumeGroup << ", "
1788 << outsideNormal << " )";
1792 SMESH_CATCH( SMESH::throwCorbaException );
1796 //=============================================================================
1798 * \brief Fuse neighbour triangles into quadrangles.
1800 //=============================================================================
1802 CORBA::Boolean SMESH_MeshEditor_i::TriToQuad (const SMESH::long_array & IDsOfElements,
1803 SMESH::NumericalFunctor_ptr Criterion,
1804 CORBA::Double MaxAngle)
1805 throw (SALOME::SALOME_Exception)
1810 SMESHDS_Mesh* aMesh = getMeshDS();
1811 TIDSortedElemSet faces,copyFaces;
1812 SMDS_MeshElement::GeomFilter triaFilter(SMDSGeom_TRIANGLE);
1813 arrayToSet(IDsOfElements, aMesh, faces, SMDSAbs_Face, & triaFilter);
1814 TIDSortedElemSet* workElements = & faces;
1816 if ( myIsPreviewMode ) {
1817 SMDSAbs_ElementType select = SMDSAbs_Face;
1818 getPreviewMesh( SMDSAbs_Face )->Copy( faces, copyFaces, select );
1819 workElements = & copyFaces;
1822 SMESH::NumericalFunctor_i* aNumericalFunctor =
1823 dynamic_cast<SMESH::NumericalFunctor_i*>( SMESH_Gen_i::GetServant( Criterion ).in() );
1824 SMESH::Controls::NumericalFunctorPtr aCrit;
1825 if ( !aNumericalFunctor )
1826 aCrit.reset( new SMESH::Controls::MaxElementLength2D() );
1828 aCrit = aNumericalFunctor->GetNumericalFunctor();
1830 if ( !myIsPreviewMode ) {
1831 // Update Python script
1832 TPythonDump() << "isDone = " << this << ".TriToQuad( "
1833 << IDsOfElements << ", " << aNumericalFunctor << ", " << TVar( MaxAngle ) << " )";
1836 bool stat = getEditor().TriToQuad( *workElements, aCrit, MaxAngle );
1838 declareMeshModified( /*isReComputeSafe=*/!stat );
1841 SMESH_CATCH( SMESH::throwCorbaException );
1845 //=============================================================================
1847 * \brief Fuse neighbour triangles into quadrangles.
1849 //=============================================================================
1851 CORBA::Boolean SMESH_MeshEditor_i::TriToQuadObject (SMESH::SMESH_IDSource_ptr theObject,
1852 SMESH::NumericalFunctor_ptr Criterion,
1853 CORBA::Double MaxAngle)
1854 throw (SALOME::SALOME_Exception)
1859 TPythonDump aTPythonDump; // suppress dump in TriToQuad()
1861 prepareIdSource( theObject );
1862 SMESH::long_array_var anElementsId = theObject->GetIDs();
1863 CORBA::Boolean isDone = TriToQuad(anElementsId, Criterion, MaxAngle);
1865 if ( !myIsPreviewMode ) {
1866 SMESH::NumericalFunctor_i* aNumericalFunctor =
1867 SMESH::DownCast<SMESH::NumericalFunctor_i*>( Criterion );
1869 // Update Python script
1870 aTPythonDump << "isDone = " << this << ".TriToQuadObject("
1871 << theObject << ", " << aNumericalFunctor << ", " << TVar( MaxAngle ) << " )";
1876 SMESH_CATCH( SMESH::throwCorbaException );
1880 //=============================================================================
1882 * \brief Split quadrangles into triangles.
1884 //=============================================================================
1886 CORBA::Boolean SMESH_MeshEditor_i::QuadToTri (const SMESH::long_array & IDsOfElements,
1887 SMESH::NumericalFunctor_ptr Criterion)
1888 throw (SALOME::SALOME_Exception)
1893 SMESHDS_Mesh* aMesh = getMeshDS();
1894 TIDSortedElemSet faces;
1895 arrayToSet(IDsOfElements, aMesh, faces, SMDSAbs_Face);
1897 SMESH::NumericalFunctor_i* aNumericalFunctor =
1898 dynamic_cast<SMESH::NumericalFunctor_i*>( SMESH_Gen_i::GetServant( Criterion ).in() );
1899 SMESH::Controls::NumericalFunctorPtr aCrit;
1900 if ( !aNumericalFunctor )
1901 aCrit.reset( new SMESH::Controls::AspectRatio() );
1903 aCrit = aNumericalFunctor->GetNumericalFunctor();
1906 // Update Python script
1907 TPythonDump() << "isDone = " << this << ".QuadToTri( " << IDsOfElements << ", " << aNumericalFunctor << " )";
1909 CORBA::Boolean stat = getEditor().QuadToTri( faces, aCrit );
1911 declareMeshModified( /*isReComputeSafe=*/false );
1914 SMESH_CATCH( SMESH::throwCorbaException );
1918 //=============================================================================
1920 * \brief Split quadrangles into triangles.
1922 //=============================================================================
1924 CORBA::Boolean SMESH_MeshEditor_i::QuadToTriObject (SMESH::SMESH_IDSource_ptr theObject,
1925 SMESH::NumericalFunctor_ptr Criterion)
1926 throw (SALOME::SALOME_Exception)
1931 TPythonDump aTPythonDump; // suppress dump in QuadToTri()
1933 prepareIdSource( theObject );
1934 SMESH::long_array_var anElementsId = theObject->GetIDs();
1935 CORBA::Boolean isDone = QuadToTri(anElementsId, Criterion);
1937 SMESH::NumericalFunctor_i* aNumericalFunctor =
1938 SMESH::DownCast<SMESH::NumericalFunctor_i*>( Criterion );
1940 // Update Python script
1941 aTPythonDump << "isDone = " << this << ".QuadToTriObject( " << theObject << ", " << aNumericalFunctor << " )";
1943 declareMeshModified( /*isReComputeSafe=*/false );
1946 SMESH_CATCH( SMESH::throwCorbaException );
1950 //================================================================================
1952 * \brief Split each of quadrangles into 4 triangles.
1953 * \param [in] theObject - theQuads Container of quadrangles to split.
1955 //================================================================================
1957 void SMESH_MeshEditor_i::QuadTo4Tri (SMESH::SMESH_IDSource_ptr theObject)
1958 throw (SALOME::SALOME_Exception)
1963 TIDSortedElemSet faces;
1964 prepareIdSource( theObject );
1965 if ( !idSourceToSet( theObject, getMeshDS(), faces, SMDSAbs_Face, /*emptyIfIsMesh=*/true ) &&
1967 THROW_SALOME_CORBA_EXCEPTION("No faces given", SALOME::BAD_PARAM);
1969 getEditor().QuadTo4Tri( faces );
1970 TPythonDump() << this << ".QuadTo4Tri( " << theObject << " )";
1972 SMESH_CATCH( SMESH::throwCorbaException );
1975 //=============================================================================
1977 * \brief Split quadrangles into triangles.
1979 //=============================================================================
1981 CORBA::Boolean SMESH_MeshEditor_i::SplitQuad (const SMESH::long_array & IDsOfElements,
1982 CORBA::Boolean Diag13)
1983 throw (SALOME::SALOME_Exception)
1988 SMESHDS_Mesh* aMesh = getMeshDS();
1989 TIDSortedElemSet faces;
1990 arrayToSet(IDsOfElements, aMesh, faces, SMDSAbs_Face);
1992 // Update Python script
1993 TPythonDump() << "isDone = " << this << ".SplitQuad( "
1994 << IDsOfElements << ", " << Diag13 << " )";
1996 CORBA::Boolean stat = getEditor().QuadToTri( faces, Diag13 );
1998 declareMeshModified( /*isReComputeSafe=*/ !stat );
2001 SMESH_CATCH( SMESH::throwCorbaException );
2005 //=============================================================================
2007 * \brief Split quadrangles into triangles.
2009 //=============================================================================
2011 CORBA::Boolean SMESH_MeshEditor_i::SplitQuadObject (SMESH::SMESH_IDSource_ptr theObject,
2012 CORBA::Boolean Diag13)
2013 throw (SALOME::SALOME_Exception)
2018 TPythonDump aTPythonDump; // suppress dump in SplitQuad()
2020 prepareIdSource( theObject );
2021 SMESH::long_array_var anElementsId = theObject->GetIDs();
2022 CORBA::Boolean isDone = SplitQuad(anElementsId, Diag13);
2024 // Update Python script
2025 aTPythonDump << "isDone = " << this << ".SplitQuadObject( "
2026 << theObject << ", " << Diag13 << " )";
2028 declareMeshModified( /*isReComputeSafe=*/!isDone );
2031 SMESH_CATCH( SMESH::throwCorbaException );
2036 //=============================================================================
2038 * Find better splitting of the given quadrangle.
2039 * \param IDOfQuad ID of the quadrangle to be splitted.
2040 * \param Criterion A criterion to choose a diagonal for splitting.
2041 * \return 1 if 1-3 diagonal is better, 2 if 2-4
2042 * diagonal is better, 0 if error occurs.
2044 //=============================================================================
2046 CORBA::Long SMESH_MeshEditor_i::BestSplit (CORBA::Long IDOfQuad,
2047 SMESH::NumericalFunctor_ptr Criterion)
2048 throw (SALOME::SALOME_Exception)
2053 const SMDS_MeshElement* quad = getMeshDS()->FindElement(IDOfQuad);
2054 if (quad && quad->GetType() == SMDSAbs_Face && quad->NbNodes() == 4)
2056 SMESH::NumericalFunctor_i* aNumericalFunctor =
2057 dynamic_cast<SMESH::NumericalFunctor_i*>(SMESH_Gen_i::GetServant(Criterion).in());
2058 SMESH::Controls::NumericalFunctorPtr aCrit;
2059 if (aNumericalFunctor)
2060 aCrit = aNumericalFunctor->GetNumericalFunctor();
2062 aCrit.reset(new SMESH::Controls::AspectRatio());
2064 int id = getEditor().BestSplit(quad, aCrit);
2065 declareMeshModified( /*isReComputeSafe=*/ id < 1 );
2069 SMESH_CATCH( SMESH::throwCorbaException );
2073 //================================================================================
2075 * \brief Split volumic elements into tetrahedrons
2077 //================================================================================
2079 void SMESH_MeshEditor_i::SplitVolumesIntoTetra (SMESH::SMESH_IDSource_ptr elems,
2080 CORBA::Short methodFlags)
2081 throw (SALOME::SALOME_Exception)
2085 prepareIdSource( elems );
2087 ::SMESH_MeshEditor::TFacetOfElem elemSet;
2088 const int noneFacet = -1;
2089 SMDS_ElemIteratorPtr volIt = myMesh_i->GetElements( elems, SMESH::VOLUME );
2090 while( volIt->more() )
2091 elemSet.insert( elemSet.end(), make_pair( volIt->next(), noneFacet ));
2093 getEditor().SplitVolumes( elemSet, int( methodFlags ));
2094 declareMeshModified( /*isReComputeSafe=*/true ); // it does not influence Compute()
2096 TPythonDump() << this << ".SplitVolumesIntoTetra( "
2097 << elems << ", " << methodFlags << " )";
2099 SMESH_CATCH( SMESH::throwCorbaException );
2102 //================================================================================
2104 * \brief Split hexahedra into triangular prisms
2105 * \param elems - elements to split
2106 * \param facetToSplitNormal - normal used to find a facet of hexahedron
2107 * to split into triangles
2108 * \param methodFlags - flags passing splitting method:
2109 * 1 - split the hexahedron into 2 prisms
2110 * 2 - split the hexahedron into 4 prisms
2112 //================================================================================
2114 void SMESH_MeshEditor_i::SplitHexahedraIntoPrisms (SMESH::SMESH_IDSource_ptr elems,
2115 const SMESH::PointStruct & startHexPoint,
2116 const SMESH::DirStruct& facetToSplitNormal,
2117 CORBA::Short methodFlags,
2118 CORBA::Boolean allDomains)
2119 throw (SALOME::SALOME_Exception)
2123 prepareIdSource( elems );
2125 gp_Ax1 facetNorm( gp_Pnt( startHexPoint.x,
2128 gp_Dir( facetToSplitNormal.PS.x,
2129 facetToSplitNormal.PS.y,
2130 facetToSplitNormal.PS.z ));
2131 TIDSortedElemSet elemSet;
2132 SMESH::long_array_var anElementsId = elems->GetIDs();
2133 SMDS_MeshElement::GeomFilter filter( SMDSGeom_HEXA );
2134 arrayToSet( anElementsId, getMeshDS(), elemSet, SMDSAbs_Volume, &filter );
2136 ::SMESH_MeshEditor::TFacetOfElem elemFacets;
2137 while ( !elemSet.empty() )
2139 getEditor().GetHexaFacetsToSplit( elemSet, facetNorm, elemFacets );
2143 ::SMESH_MeshEditor::TFacetOfElem::iterator ef = elemFacets.begin();
2144 for ( ; ef != elemFacets.end(); ++ef )
2145 elemSet.erase( ef->first );
2148 if ( methodFlags == 2 )
2149 methodFlags = int( ::SMESH_MeshEditor::HEXA_TO_4_PRISMS );
2151 methodFlags = int( ::SMESH_MeshEditor::HEXA_TO_2_PRISMS );
2153 getEditor().SplitVolumes( elemFacets, int( methodFlags ));
2154 declareMeshModified( /*isReComputeSafe=*/true ); // it does not influence Compute()
2156 TPythonDump() << this << ".SplitHexahedraIntoPrisms( "
2158 << startHexPoint << ", "
2159 << facetToSplitNormal<< ", "
2160 << methodFlags<< ", "
2161 << allDomains << " )";
2163 SMESH_CATCH( SMESH::throwCorbaException );
2166 //=======================================================================
2169 //=======================================================================
2172 SMESH_MeshEditor_i::Smooth(const SMESH::long_array & IDsOfElements,
2173 const SMESH::long_array & IDsOfFixedNodes,
2174 CORBA::Long MaxNbOfIterations,
2175 CORBA::Double MaxAspectRatio,
2176 SMESH::SMESH_MeshEditor::Smooth_Method Method)
2177 throw (SALOME::SALOME_Exception)
2179 return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
2180 MaxAspectRatio, Method, false );
2184 //=======================================================================
2185 //function : SmoothParametric
2187 //=======================================================================
2190 SMESH_MeshEditor_i::SmoothParametric(const SMESH::long_array & IDsOfElements,
2191 const SMESH::long_array & IDsOfFixedNodes,
2192 CORBA::Long MaxNbOfIterations,
2193 CORBA::Double MaxAspectRatio,
2194 SMESH::SMESH_MeshEditor::Smooth_Method Method)
2195 throw (SALOME::SALOME_Exception)
2197 return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
2198 MaxAspectRatio, Method, true );
2202 //=======================================================================
2203 //function : SmoothObject
2205 //=======================================================================
2208 SMESH_MeshEditor_i::SmoothObject(SMESH::SMESH_IDSource_ptr theObject,
2209 const SMESH::long_array & IDsOfFixedNodes,
2210 CORBA::Long MaxNbOfIterations,
2211 CORBA::Double MaxAspectRatio,
2212 SMESH::SMESH_MeshEditor::Smooth_Method Method)
2213 throw (SALOME::SALOME_Exception)
2215 return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
2216 MaxAspectRatio, Method, false);
2220 //=======================================================================
2221 //function : SmoothParametricObject
2223 //=======================================================================
2226 SMESH_MeshEditor_i::SmoothParametricObject(SMESH::SMESH_IDSource_ptr theObject,
2227 const SMESH::long_array & IDsOfFixedNodes,
2228 CORBA::Long MaxNbOfIterations,
2229 CORBA::Double MaxAspectRatio,
2230 SMESH::SMESH_MeshEditor::Smooth_Method Method)
2231 throw (SALOME::SALOME_Exception)
2233 return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
2234 MaxAspectRatio, Method, true);
2238 //=============================================================================
2242 //=============================================================================
2245 SMESH_MeshEditor_i::smooth(const SMESH::long_array & IDsOfElements,
2246 const SMESH::long_array & IDsOfFixedNodes,
2247 CORBA::Long MaxNbOfIterations,
2248 CORBA::Double MaxAspectRatio,
2249 SMESH::SMESH_MeshEditor::Smooth_Method Method,
2251 throw (SALOME::SALOME_Exception)
2256 SMESHDS_Mesh* aMesh = getMeshDS();
2258 TIDSortedElemSet elements;
2259 arrayToSet(IDsOfElements, aMesh, elements, SMDSAbs_Face);
2261 set<const SMDS_MeshNode*> fixedNodes;
2262 for (int i = 0; i < IDsOfFixedNodes.length(); i++) {
2263 CORBA::Long index = IDsOfFixedNodes[i];
2264 const SMDS_MeshNode * node = aMesh->FindNode(index);
2266 fixedNodes.insert( node );
2268 ::SMESH_MeshEditor::SmoothMethod method = ::SMESH_MeshEditor::LAPLACIAN;
2269 if ( Method != SMESH::SMESH_MeshEditor::LAPLACIAN_SMOOTH )
2270 method = ::SMESH_MeshEditor::CENTROIDAL;
2272 getEditor().Smooth(elements, fixedNodes, method,
2273 MaxNbOfIterations, MaxAspectRatio, IsParametric );
2275 declareMeshModified( /*isReComputeSafe=*/true ); // does not prevent re-compute
2277 // Update Python script
2278 TPythonDump() << "isDone = " << this << "."
2279 << (IsParametric ? "SmoothParametric( " : "Smooth( ")
2280 << IDsOfElements << ", " << IDsOfFixedNodes << ", "
2281 << TVar( MaxNbOfIterations ) << ", " << TVar( MaxAspectRatio ) << ", "
2282 << "SMESH.SMESH_MeshEditor."
2283 << ( Method == SMESH::SMESH_MeshEditor::CENTROIDAL_SMOOTH ?
2284 "CENTROIDAL_SMOOTH )" : "LAPLACIAN_SMOOTH )");
2288 SMESH_CATCH( SMESH::throwCorbaException );
2292 //=============================================================================
2296 //=============================================================================
2299 SMESH_MeshEditor_i::smoothObject(SMESH::SMESH_IDSource_ptr theObject,
2300 const SMESH::long_array & IDsOfFixedNodes,
2301 CORBA::Long MaxNbOfIterations,
2302 CORBA::Double MaxAspectRatio,
2303 SMESH::SMESH_MeshEditor::Smooth_Method Method,
2305 throw (SALOME::SALOME_Exception)
2310 TPythonDump aTPythonDump; // suppress dump in smooth()
2312 prepareIdSource( theObject );
2313 SMESH::long_array_var anElementsId = theObject->GetIDs();
2314 CORBA::Boolean isDone = smooth (anElementsId, IDsOfFixedNodes, MaxNbOfIterations,
2315 MaxAspectRatio, Method, IsParametric);
2317 // Update Python script
2318 aTPythonDump << "isDone = " << this << "."
2319 << (IsParametric ? "SmoothParametricObject( " : "SmoothObject( ")
2320 << theObject << ", " << IDsOfFixedNodes << ", "
2321 << TVar( MaxNbOfIterations ) << ", " << TVar( MaxAspectRatio ) << ", "
2322 << "SMESH.SMESH_MeshEditor."
2323 << ( Method == SMESH::SMESH_MeshEditor::CENTROIDAL_SMOOTH ?
2324 "CENTROIDAL_SMOOTH )" : "LAPLACIAN_SMOOTH )");
2328 SMESH_CATCH( SMESH::throwCorbaException );
2332 //=============================================================================
2336 //=============================================================================
2338 void SMESH_MeshEditor_i::RenumberNodes()
2339 throw (SALOME::SALOME_Exception)
2342 // Update Python script
2343 TPythonDump() << this << ".RenumberNodes()";
2345 getMeshDS()->Renumber( true );
2347 SMESH_CATCH( SMESH::throwCorbaException );
2350 //=============================================================================
2354 //=============================================================================
2356 void SMESH_MeshEditor_i::RenumberElements()
2357 throw (SALOME::SALOME_Exception)
2360 // Update Python script
2361 TPythonDump() << this << ".RenumberElements()";
2363 getMeshDS()->Renumber( false );
2365 SMESH_CATCH( SMESH::throwCorbaException );
2368 //=======================================================================
2370 * \brief Return groups by their IDs
2372 //=======================================================================
2374 SMESH::ListOfGroups* SMESH_MeshEditor_i::getGroups(const std::list<int>* groupIDs)
2375 throw (SALOME::SALOME_Exception)
2380 myMesh_i->CreateGroupServants();
2381 return myMesh_i->GetGroups( *groupIDs );
2383 SMESH_CATCH( SMESH::throwCorbaException );
2387 //=======================================================================
2388 //function : rotationSweep
2390 //=======================================================================
2392 SMESH::ListOfGroups*
2393 SMESH_MeshEditor_i::rotationSweep(const SMESH::long_array & theIDsOfElements,
2394 const SMESH::AxisStruct & theAxis,
2395 CORBA::Double theAngleInRadians,
2396 CORBA::Long theNbOfSteps,
2397 CORBA::Double theTolerance,
2398 const bool theMakeGroups,
2399 const SMDSAbs_ElementType theElementType)
2400 throw (SALOME::SALOME_Exception)
2405 TIDSortedElemSet inElements, copyElements;
2406 arrayToSet(theIDsOfElements, getMeshDS(), inElements, theElementType);
2408 TIDSortedElemSet* workElements = & inElements;
2409 bool makeWalls=true;
2410 if ( myIsPreviewMode )
2412 SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
2413 getPreviewMesh( SMDSAbs_Face )->Copy( inElements, copyElements, select, avoid );
2414 workElements = & copyElements;
2415 //makeWalls = false;
2418 gp_Ax1 Ax1 (gp_Pnt( theAxis.x, theAxis.y, theAxis.z ),
2419 gp_Vec( theAxis.vx, theAxis.vy, theAxis.vz ));
2421 ::SMESH_MeshEditor::PGroupIDs groupIds =
2422 getEditor().RotationSweep (*workElements, Ax1, theAngleInRadians,
2423 theNbOfSteps, theTolerance, theMakeGroups, makeWalls);
2425 declareMeshModified( /*isReComputeSafe=*/true ); // does not influence Compute()
2427 return theMakeGroups ? getGroups(groupIds.get()) : 0;
2429 SMESH_CATCH( SMESH::throwCorbaException );
2433 //=======================================================================
2434 //function : RotationSweep
2436 //=======================================================================
2438 void SMESH_MeshEditor_i::RotationSweep(const SMESH::long_array & theIDsOfElements,
2439 const SMESH::AxisStruct & theAxis,
2440 CORBA::Double theAngleInRadians,
2441 CORBA::Long theNbOfSteps,
2442 CORBA::Double theTolerance)
2443 throw (SALOME::SALOME_Exception)
2445 if ( !myIsPreviewMode ) {
2446 TPythonDump() << this << ".RotationSweep( "
2447 << theIDsOfElements << ", "
2449 << TVar( theAngleInRadians ) << ", "
2450 << TVar( theNbOfSteps ) << ", "
2451 << TVar( theTolerance ) << " )";
2453 rotationSweep(theIDsOfElements,
2461 //=======================================================================
2462 //function : RotationSweepMakeGroups
2464 //=======================================================================
2466 SMESH::ListOfGroups*
2467 SMESH_MeshEditor_i::RotationSweepMakeGroups(const SMESH::long_array& theIDsOfElements,
2468 const SMESH::AxisStruct& theAxis,
2469 CORBA::Double theAngleInRadians,
2470 CORBA::Long theNbOfSteps,
2471 CORBA::Double theTolerance)
2472 throw (SALOME::SALOME_Exception)
2474 TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
2476 SMESH::ListOfGroups *aGroups = rotationSweep(theIDsOfElements,
2482 if (!myIsPreviewMode) {
2483 dumpGroupsList(aPythonDump, aGroups);
2484 aPythonDump << this << ".RotationSweepMakeGroups( "
2485 << theIDsOfElements << ", "
2487 << TVar( theAngleInRadians ) << ", "
2488 << TVar( theNbOfSteps ) << ", "
2489 << TVar( theTolerance ) << " )";
2494 //=======================================================================
2495 //function : RotationSweepObject
2497 //=======================================================================
2499 void SMESH_MeshEditor_i::RotationSweepObject(SMESH::SMESH_IDSource_ptr theObject,
2500 const SMESH::AxisStruct & theAxis,
2501 CORBA::Double theAngleInRadians,
2502 CORBA::Long theNbOfSteps,
2503 CORBA::Double theTolerance)
2504 throw (SALOME::SALOME_Exception)
2506 if ( !myIsPreviewMode ) {
2507 TPythonDump() << this << ".RotationSweepObject( "
2508 << theObject << ", "
2510 << theAngleInRadians << ", "
2511 << theNbOfSteps << ", "
2512 << theTolerance << " )";
2514 prepareIdSource( theObject );
2515 SMESH::long_array_var anElementsId = theObject->GetIDs();
2516 rotationSweep(anElementsId,
2524 //=======================================================================
2525 //function : RotationSweepObject1D
2527 //=======================================================================
2529 void SMESH_MeshEditor_i::RotationSweepObject1D(SMESH::SMESH_IDSource_ptr theObject,
2530 const SMESH::AxisStruct & theAxis,
2531 CORBA::Double theAngleInRadians,
2532 CORBA::Long theNbOfSteps,
2533 CORBA::Double theTolerance)
2534 throw (SALOME::SALOME_Exception)
2536 if ( !myIsPreviewMode ) {
2537 TPythonDump() << this << ".RotationSweepObject1D( "
2538 << theObject << ", "
2540 << TVar( theAngleInRadians ) << ", "
2541 << TVar( theNbOfSteps ) << ", "
2542 << TVar( theTolerance ) << " )";
2544 prepareIdSource( theObject );
2545 SMESH::long_array_var anElementsId = theObject->GetIDs();
2546 rotationSweep(anElementsId,
2555 //=======================================================================
2556 //function : RotationSweepObject2D
2558 //=======================================================================
2560 void SMESH_MeshEditor_i::RotationSweepObject2D(SMESH::SMESH_IDSource_ptr theObject,
2561 const SMESH::AxisStruct & theAxis,
2562 CORBA::Double theAngleInRadians,
2563 CORBA::Long theNbOfSteps,
2564 CORBA::Double theTolerance)
2565 throw (SALOME::SALOME_Exception)
2567 if ( !myIsPreviewMode ) {
2568 TPythonDump() << this << ".RotationSweepObject2D( "
2569 << theObject << ", "
2571 << TVar( theAngleInRadians ) << ", "
2572 << TVar( theNbOfSteps ) << ", "
2573 << TVar( theTolerance ) << " )";
2575 prepareIdSource( theObject );
2576 SMESH::long_array_var anElementsId = theObject->GetIDs();
2577 rotationSweep(anElementsId,
2586 //=======================================================================
2587 //function : RotationSweepObjectMakeGroups
2589 //=======================================================================
2591 SMESH::ListOfGroups*
2592 SMESH_MeshEditor_i::RotationSweepObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
2593 const SMESH::AxisStruct& theAxis,
2594 CORBA::Double theAngleInRadians,
2595 CORBA::Long theNbOfSteps,
2596 CORBA::Double theTolerance)
2597 throw (SALOME::SALOME_Exception)
2599 TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
2601 prepareIdSource( theObject );
2602 SMESH::long_array_var anElementsId = theObject->GetIDs();
2603 SMESH::ListOfGroups *aGroups = rotationSweep(anElementsId,
2609 if (!myIsPreviewMode) {
2610 dumpGroupsList(aPythonDump, aGroups);
2611 aPythonDump << this << ".RotationSweepObjectMakeGroups( "
2612 << theObject << ", "
2614 << theAngleInRadians << ", "
2615 << theNbOfSteps << ", "
2616 << theTolerance << " )";
2621 //=======================================================================
2622 //function : RotationSweepObject1DMakeGroups
2624 //=======================================================================
2626 SMESH::ListOfGroups*
2627 SMESH_MeshEditor_i::RotationSweepObject1DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
2628 const SMESH::AxisStruct& theAxis,
2629 CORBA::Double theAngleInRadians,
2630 CORBA::Long theNbOfSteps,
2631 CORBA::Double theTolerance)
2632 throw (SALOME::SALOME_Exception)
2634 TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
2636 prepareIdSource( theObject );
2637 SMESH::long_array_var anElementsId = theObject->GetIDs();
2638 SMESH::ListOfGroups *aGroups = rotationSweep(anElementsId,
2645 if (!myIsPreviewMode) {
2646 dumpGroupsList(aPythonDump, aGroups);
2647 aPythonDump << this << ".RotationSweepObject1DMakeGroups( "
2648 << theObject << ", "
2650 << TVar( theAngleInRadians ) << ", "
2651 << TVar( theNbOfSteps ) << ", "
2652 << TVar( theTolerance ) << " )";
2657 //=======================================================================
2658 //function : RotationSweepObject2DMakeGroups
2660 //=======================================================================
2662 SMESH::ListOfGroups*
2663 SMESH_MeshEditor_i::RotationSweepObject2DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
2664 const SMESH::AxisStruct& theAxis,
2665 CORBA::Double theAngleInRadians,
2666 CORBA::Long theNbOfSteps,
2667 CORBA::Double theTolerance)
2668 throw (SALOME::SALOME_Exception)
2670 TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
2672 prepareIdSource( theObject );
2673 SMESH::long_array_var anElementsId = theObject->GetIDs();
2674 SMESH::ListOfGroups *aGroups = rotationSweep(anElementsId,
2681 if (!myIsPreviewMode) {
2682 dumpGroupsList(aPythonDump, aGroups);
2683 aPythonDump << this << ".RotationSweepObject2DMakeGroups( "
2684 << theObject << ", "
2686 << TVar( theAngleInRadians ) << ", "
2687 << TVar( theNbOfSteps ) << ", "
2688 << TVar( theTolerance ) << " )";
2693 namespace MeshEditor_I
2696 * \brief Structure used to pass extrusion parameters to ::SMESH_MeshEditor
2698 struct ExtrusionParams : public ::SMESH_MeshEditor::ExtrusParam
2700 bool myIsExtrusionByNormal;
2702 static int makeFlags( CORBA::Boolean MakeGroups,
2703 CORBA::Boolean ByAverageNormal = false,
2704 CORBA::Boolean UseInputElemsOnly = false,
2705 CORBA::Long Flags = 0,
2706 CORBA::Boolean MakeBoundary = true )
2708 if ( MakeGroups ) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_GROUPS;
2709 if ( ByAverageNormal ) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_BY_AVG_NORMAL;
2710 if ( UseInputElemsOnly) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_USE_INPUT_ELEMS_ONLY;
2711 if ( MakeBoundary ) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_BOUNDARY;
2715 ExtrusionParams(const SMESH::DirStruct & theDir,
2716 CORBA::Long theNbOfSteps,
2717 CORBA::Boolean theMakeGroups):
2718 ::SMESH_MeshEditor::ExtrusParam ( gp_Vec( theDir.PS.x,
2722 makeFlags( theMakeGroups )),
2723 myIsExtrusionByNormal( false )
2727 ExtrusionParams(const SMESH::DirStruct & theDir,
2728 CORBA::Long theNbOfSteps,
2729 CORBA::Boolean theMakeGroups,
2730 CORBA::Long theExtrFlags,
2731 CORBA::Double theSewTolerance):
2732 ::SMESH_MeshEditor::ExtrusParam ( gp_Vec( theDir.PS.x,
2736 makeFlags( theMakeGroups, false, false,
2737 theExtrFlags, false ),
2739 myIsExtrusionByNormal( false )
2742 // params for extrusion by normal
2743 ExtrusionParams(CORBA::Double theStepSize,
2744 CORBA::Long theNbOfSteps,
2745 CORBA::Short theDim,
2746 CORBA::Boolean theUseInputElemsOnly,
2747 CORBA::Boolean theByAverageNormal,
2748 CORBA::Boolean theMakeGroups ):
2749 ::SMESH_MeshEditor::ExtrusParam ( theStepSize,
2751 makeFlags( theMakeGroups,
2752 theByAverageNormal, theUseInputElemsOnly ),
2754 myIsExtrusionByNormal( true )
2760 Flags() &= ~(::SMESH_MeshEditor::EXTRUSION_FLAG_GROUPS);
2765 //=======================================================================
2766 //function : extrusionSweep
2768 //=======================================================================
2770 SMESH::ListOfGroups*
2771 SMESH_MeshEditor_i::extrusionSweep(const SMESH::long_array & theIDsOfElements,
2772 MeshEditor_I::ExtrusionParams& theParams,
2773 const SMDSAbs_ElementType theElementType)
2774 throw (SALOME::SALOME_Exception)
2779 TIDSortedElemSet elements, copyElements;
2780 arrayToSet( theIDsOfElements, getMeshDS(), elements, theElementType );
2782 TIDSortedElemSet* workElements = & elements;
2784 if ( myIsPreviewMode )
2786 SMDSAbs_ElementType previewType = SMDSAbs_Face;
2787 if (theElementType == SMDSAbs_Node)
2788 previewType = SMDSAbs_Edge;
2790 SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
2791 getPreviewMesh( previewType )->Copy( elements, copyElements, select, avoid );
2792 workElements = & copyElements;
2793 theParams.SetNoGroups();
2795 if ( theParams.myIsExtrusionByNormal && !theParams.ToUseInpElemsOnly() )
2797 TIDSortedElemSet elemsAround, elemsAroundCopy;
2798 getElementsAround( elements, getMeshDS(), elemsAround );
2799 getPreviewMesh( previewType )->Copy( elemsAround, elemsAroundCopy, select, avoid );
2803 ::SMESH_MeshEditor::TTElemOfElemListMap aHystory;
2804 ::SMESH_MeshEditor::PGroupIDs groupIds =
2805 getEditor().ExtrusionSweep (*workElements, theParams, aHystory );
2807 declareMeshModified( /*isReComputeSafe=*/true ); // does not influence Compute()
2809 return theParams.ToMakeGroups() ? getGroups(groupIds.get()) : 0;
2811 SMESH_CATCH( SMESH::throwCorbaException );
2815 //=======================================================================
2816 //function : ExtrusionSweep
2818 //=======================================================================
2820 void SMESH_MeshEditor_i::ExtrusionSweep(const SMESH::long_array & theIDsOfElements,
2821 const SMESH::DirStruct & theStepVector,
2822 CORBA::Long theNbOfSteps)
2823 throw (SALOME::SALOME_Exception)
2825 ExtrusionParams params( theStepVector, theNbOfSteps, false );
2826 extrusionSweep( theIDsOfElements, params );
2827 if (!myIsPreviewMode) {
2828 TPythonDump() << this << ".ExtrusionSweep( "
2829 << theIDsOfElements << ", " << theStepVector <<", " << TVar(theNbOfSteps) << " )";
2833 //=======================================================================
2834 //function : ExtrusionSweep0D
2836 //=======================================================================
2838 void SMESH_MeshEditor_i::ExtrusionSweep0D(const SMESH::long_array & theIDsOfElements,
2839 const SMESH::DirStruct & theStepVector,
2840 CORBA::Long theNbOfSteps)
2841 throw (SALOME::SALOME_Exception)
2843 ExtrusionParams params( theStepVector, theNbOfSteps, false );
2844 extrusionSweep( theIDsOfElements, params, SMDSAbs_Node );
2845 if (!myIsPreviewMode) {
2846 TPythonDump() << this << ".ExtrusionSweep0D( "
2847 << theIDsOfElements << ", " << theStepVector <<", " << TVar(theNbOfSteps)<< " )";
2851 //=======================================================================
2852 //function : ExtrusionSweepObject
2854 //=======================================================================
2856 void SMESH_MeshEditor_i::ExtrusionSweepObject(SMESH::SMESH_IDSource_ptr theObject,
2857 const SMESH::DirStruct & theStepVector,
2858 CORBA::Long theNbOfSteps)
2859 throw (SALOME::SALOME_Exception)
2861 prepareIdSource( theObject );
2862 SMESH::long_array_var anElementsId = theObject->GetIDs();
2863 ExtrusionParams params( theStepVector, theNbOfSteps, false );
2864 extrusionSweep( anElementsId, params );
2865 if (!myIsPreviewMode) {
2866 TPythonDump() << this << ".ExtrusionSweepObject( "
2867 << theObject << ", " << theStepVector << ", " << theNbOfSteps << " )";
2871 //=======================================================================
2872 //function : ExtrusionSweepObject0D
2874 //=======================================================================
2876 void SMESH_MeshEditor_i::ExtrusionSweepObject0D(SMESH::SMESH_IDSource_ptr theObject,
2877 const SMESH::DirStruct & theStepVector,
2878 CORBA::Long theNbOfSteps)
2879 throw (SALOME::SALOME_Exception)
2881 prepareIdSource( theObject );
2882 SMESH::long_array_var anElementsId = theObject->GetIDs();
2883 if ( anElementsId->length() == 0 )
2884 if ( SMESH_Mesh_i* mesh = SMESH::DownCast<SMESH_Mesh_i*>( theObject ))
2885 anElementsId = mesh->GetNodesId();
2887 ExtrusionParams params( theStepVector, theNbOfSteps, false );
2888 extrusionSweep( anElementsId, params, SMDSAbs_Node );
2889 if ( !myIsPreviewMode ) {
2890 TPythonDump() << this << ".ExtrusionSweepObject0D( "
2891 << theObject << ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
2895 //=======================================================================
2896 //function : ExtrusionSweepObject1D
2898 //=======================================================================
2900 void SMESH_MeshEditor_i::ExtrusionSweepObject1D(SMESH::SMESH_IDSource_ptr theObject,
2901 const SMESH::DirStruct & theStepVector,
2902 CORBA::Long theNbOfSteps)
2903 throw (SALOME::SALOME_Exception)
2905 prepareIdSource( theObject );
2906 SMESH::long_array_var anElementsId = theObject->GetIDs();
2907 ExtrusionParams params( theStepVector, theNbOfSteps, false );
2908 extrusionSweep( anElementsId, params, SMDSAbs_Edge );
2909 if ( !myIsPreviewMode ) {
2910 TPythonDump() << this << ".ExtrusionSweepObject1D( "
2911 << theObject << ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
2915 //=======================================================================
2916 //function : ExtrusionSweepObject2D
2918 //=======================================================================
2920 void SMESH_MeshEditor_i::ExtrusionSweepObject2D(SMESH::SMESH_IDSource_ptr theObject,
2921 const SMESH::DirStruct & theStepVector,
2922 CORBA::Long theNbOfSteps)
2923 throw (SALOME::SALOME_Exception)
2925 prepareIdSource( theObject );
2926 SMESH::long_array_var anElementsId = theObject->GetIDs();
2927 ExtrusionParams params( theStepVector, theNbOfSteps, false );
2928 extrusionSweep( anElementsId, params, SMDSAbs_Face );
2929 if ( !myIsPreviewMode ) {
2930 TPythonDump() << this << ".ExtrusionSweepObject2D( "
2931 << theObject << ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
2935 //=======================================================================
2936 //function : ExtrusionSweepMakeGroups
2938 //=======================================================================
2940 SMESH::ListOfGroups*
2941 SMESH_MeshEditor_i::ExtrusionSweepMakeGroups(const SMESH::long_array& theIDsOfElements,
2942 const SMESH::DirStruct& theStepVector,
2943 CORBA::Long theNbOfSteps)
2944 throw (SALOME::SALOME_Exception)
2946 TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
2948 ExtrusionParams params( theStepVector, theNbOfSteps, true );
2949 SMESH::ListOfGroups* aGroups = extrusionSweep( theIDsOfElements, params );
2951 if (!myIsPreviewMode) {
2952 dumpGroupsList(aPythonDump, aGroups);
2953 aPythonDump << this << ".ExtrusionSweepMakeGroups( " << theIDsOfElements
2954 << ", " << theStepVector <<", " << TVar( theNbOfSteps ) << " )";
2959 //=======================================================================
2960 //function : ExtrusionSweepMakeGroups0D
2962 //=======================================================================
2964 SMESH::ListOfGroups*
2965 SMESH_MeshEditor_i::ExtrusionSweepMakeGroups0D(const SMESH::long_array& theIDsOfElements,
2966 const SMESH::DirStruct& theStepVector,
2967 CORBA::Long theNbOfSteps)
2968 throw (SALOME::SALOME_Exception)
2970 TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
2972 ExtrusionParams params( theStepVector, theNbOfSteps, true );
2973 SMESH::ListOfGroups* aGroups = extrusionSweep( theIDsOfElements, params, SMDSAbs_Node );
2975 if (!myIsPreviewMode) {
2976 dumpGroupsList(aPythonDump, aGroups);
2977 aPythonDump << this << ".ExtrusionSweepMakeGroups0D( " << theIDsOfElements
2978 << ", " << theStepVector <<", " << TVar( theNbOfSteps ) << " )";
2983 //=======================================================================
2984 //function : ExtrusionSweepObjectMakeGroups
2986 //=======================================================================
2988 SMESH::ListOfGroups*
2989 SMESH_MeshEditor_i::ExtrusionSweepObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
2990 const SMESH::DirStruct& theStepVector,
2991 CORBA::Long theNbOfSteps)
2992 throw (SALOME::SALOME_Exception)
2994 TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
2996 prepareIdSource( theObject );
2997 SMESH::long_array_var anElementsId = theObject->GetIDs();
2998 ExtrusionParams params( theStepVector, theNbOfSteps, true );
2999 SMESH::ListOfGroups* aGroups = extrusionSweep( anElementsId, params );
3001 if (!myIsPreviewMode) {
3002 dumpGroupsList(aPythonDump, aGroups);
3003 aPythonDump << this << ".ExtrusionSweepObjectMakeGroups( " << theObject
3004 << ", " << theStepVector << ", " << theNbOfSteps << " )";
3009 //=======================================================================
3010 //function : ExtrusionSweepObject0DMakeGroups
3012 //=======================================================================
3014 SMESH::ListOfGroups*
3015 SMESH_MeshEditor_i::ExtrusionSweepObject0DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
3016 const SMESH::DirStruct& theStepVector,
3017 CORBA::Long theNbOfSteps)
3018 throw (SALOME::SALOME_Exception)
3020 TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
3022 prepareIdSource( theObject );
3023 SMESH::long_array_var anElementsId = theObject->GetIDs();
3024 ExtrusionParams params( theStepVector, theNbOfSteps, true );
3025 SMESH::ListOfGroups* aGroups = extrusionSweep( anElementsId, params, SMDSAbs_Node );
3027 if (!myIsPreviewMode) {
3028 dumpGroupsList(aPythonDump, aGroups);
3029 aPythonDump << this << ".ExtrusionSweepObject0DMakeGroups( " << theObject
3030 << ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
3035 //=======================================================================
3036 //function : ExtrusionSweepObject1DMakeGroups
3038 //=======================================================================
3040 SMESH::ListOfGroups*
3041 SMESH_MeshEditor_i::ExtrusionSweepObject1DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
3042 const SMESH::DirStruct& theStepVector,
3043 CORBA::Long theNbOfSteps)
3044 throw (SALOME::SALOME_Exception)
3046 TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
3048 prepareIdSource( theObject );
3049 SMESH::long_array_var anElementsId = theObject->GetIDs();
3050 ExtrusionParams params( theStepVector, theNbOfSteps, true );
3051 SMESH::ListOfGroups* aGroups = extrusionSweep( anElementsId, params, SMDSAbs_Edge );
3053 if (!myIsPreviewMode) {
3054 dumpGroupsList(aPythonDump, aGroups);
3055 aPythonDump << this << ".ExtrusionSweepObject1DMakeGroups( " << theObject
3056 << ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
3061 //=======================================================================
3062 //function : ExtrusionSweepObject2DMakeGroups
3064 //=======================================================================
3066 SMESH::ListOfGroups*
3067 SMESH_MeshEditor_i::ExtrusionSweepObject2DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
3068 const SMESH::DirStruct& theStepVector,
3069 CORBA::Long theNbOfSteps)
3070 throw (SALOME::SALOME_Exception)
3072 TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
3074 prepareIdSource( theObject );
3075 SMESH::long_array_var anElementsId = theObject->GetIDs();
3076 ExtrusionParams params( theStepVector, theNbOfSteps, true );
3077 SMESH::ListOfGroups* aGroups = extrusionSweep( anElementsId, params, SMDSAbs_Face );
3079 if (!myIsPreviewMode) {
3080 dumpGroupsList(aPythonDump, aGroups);
3081 aPythonDump << this << ".ExtrusionSweepObject2DMakeGroups( " << theObject
3082 << ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
3087 //=======================================================================
3088 //function : ExtrusionByNormal
3090 //=======================================================================
3092 SMESH::ListOfGroups*
3093 SMESH_MeshEditor_i::ExtrusionByNormal(SMESH::SMESH_IDSource_ptr object,
3094 CORBA::Double stepSize,
3095 CORBA::Long nbOfSteps,
3096 CORBA::Boolean byAverageNormal,
3097 CORBA::Boolean useInputElemsOnly,
3098 CORBA::Boolean makeGroups,
3100 throw (SALOME::SALOME_Exception)
3102 TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
3104 ExtrusionParams params( stepSize, nbOfSteps, dim,
3105 byAverageNormal, useInputElemsOnly, makeGroups );
3107 SMDSAbs_ElementType elemType = ( dim == 1 ? SMDSAbs_Edge : SMDSAbs_Face );
3108 if ( !SMESH::DownCast<SMESH_Mesh_i*>( object ))
3110 SMESH::array_of_ElementType_var elemTypes = object->GetTypes();
3111 if (( elemTypes->length() == 1 ) &&
3112 ( elemTypes[0] == SMESH::EDGE || elemTypes[0] == SMESH::FACE ))
3113 elemType = ( SMDSAbs_ElementType ) elemTypes[0];
3115 prepareIdSource( object );
3116 SMESH::long_array_var anElementsId = object->GetIDs();
3117 SMESH::ListOfGroups* aGroups = extrusionSweep( anElementsId, params, elemType );
3119 if (!myIsPreviewMode) {
3120 dumpGroupsList(aPythonDump, aGroups);
3121 aPythonDump << this << ".ExtrusionByNormal( " << object
3122 << ", " << TVar( stepSize )
3123 << ", " << TVar( nbOfSteps )
3124 << ", " << byAverageNormal
3125 << ", " << makeGroups
3129 return aGroups ? aGroups : new SMESH::ListOfGroups;
3132 //=======================================================================
3133 //function : AdvancedExtrusion
3135 //=======================================================================
3137 void SMESH_MeshEditor_i::AdvancedExtrusion(const SMESH::long_array & theIDsOfElements,
3138 const SMESH::DirStruct & theStepVector,
3139 CORBA::Long theNbOfSteps,
3140 CORBA::Long theExtrFlags,
3141 CORBA::Double theSewTolerance)
3142 throw (SALOME::SALOME_Exception)
3144 ExtrusionParams params( theStepVector, theNbOfSteps, false, theExtrFlags, theSewTolerance);
3145 extrusionSweep( theIDsOfElements, params );
3147 if ( !myIsPreviewMode ) {
3148 TPythonDump() << "stepVector = " << theStepVector;
3149 TPythonDump() << this << ".AdvancedExtrusion("
3152 << theNbOfSteps << ","
3153 << theExtrFlags << ", "
3154 << theSewTolerance << " )";
3158 //=======================================================================
3159 //function : AdvancedExtrusionMakeGroups
3161 //=======================================================================
3162 SMESH::ListOfGroups*
3163 SMESH_MeshEditor_i::AdvancedExtrusionMakeGroups(const SMESH::long_array& theIDsOfElements,
3164 const SMESH::DirStruct& theStepVector,
3165 CORBA::Long theNbOfSteps,
3166 CORBA::Long theExtrFlags,
3167 CORBA::Double theSewTolerance)
3168 throw (SALOME::SALOME_Exception)
3170 if (!myIsPreviewMode) {
3171 TPythonDump() << "stepVector = " << theStepVector;
3173 TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
3175 ExtrusionParams params( theStepVector, theNbOfSteps, true, theExtrFlags, theSewTolerance);
3176 SMESH::ListOfGroups * aGroups = extrusionSweep( theIDsOfElements, params );
3178 if (!myIsPreviewMode) {
3179 dumpGroupsList(aPythonDump, aGroups);
3180 aPythonDump << this << ".AdvancedExtrusionMakeGroups("
3183 << theNbOfSteps << ","
3184 << theExtrFlags << ", "
3185 << theSewTolerance << " )";
3191 //================================================================================
3193 * \brief Convert extrusion error to IDL enum
3195 //================================================================================
3197 #define RETCASE(enm) case ::SMESH_MeshEditor::enm: return SMESH::SMESH_MeshEditor::enm;
3199 static SMESH::SMESH_MeshEditor::Extrusion_Error convExtrError( const::SMESH_MeshEditor::Extrusion_Error e )
3203 RETCASE( EXTR_NO_ELEMENTS );
3204 RETCASE( EXTR_PATH_NOT_EDGE );
3205 RETCASE( EXTR_BAD_PATH_SHAPE );
3206 RETCASE( EXTR_BAD_STARTING_NODE );
3207 RETCASE( EXTR_BAD_ANGLES_NUMBER );
3208 RETCASE( EXTR_CANT_GET_TANGENT );
3210 return SMESH::SMESH_MeshEditor::EXTR_OK;
3214 //=======================================================================
3215 //function : extrusionAlongPath
3217 //=======================================================================
3218 SMESH::ListOfGroups*
3219 SMESH_MeshEditor_i::extrusionAlongPath(const SMESH::long_array & theIDsOfElements,
3220 SMESH::SMESH_Mesh_ptr thePathMesh,
3221 GEOM::GEOM_Object_ptr thePathShape,
3222 CORBA::Long theNodeStart,
3223 CORBA::Boolean theHasAngles,
3224 const SMESH::double_array & theAngles,
3225 CORBA::Boolean theHasRefPoint,
3226 const SMESH::PointStruct & theRefPoint,
3227 const bool theMakeGroups,
3228 SMESH::SMESH_MeshEditor::Extrusion_Error & theError,
3229 const SMDSAbs_ElementType theElementType)
3230 throw (SALOME::SALOME_Exception)
3233 MESSAGE("extrusionAlongPath");
3236 if ( thePathMesh->_is_nil() || thePathShape->_is_nil() ) {
3237 theError = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
3240 SMESH_Mesh_i* aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( thePathMesh );
3242 TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( thePathShape );
3243 SMESH_subMesh* aSubMesh = aMeshImp->GetImpl().GetSubMesh( aShape );
3245 if ( !aSubMesh || !aSubMesh->GetSubMeshDS()) {
3246 theError = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
3250 SMDS_MeshNode* nodeStart = (SMDS_MeshNode*)aMeshImp->GetImpl().GetMeshDS()->FindNode(theNodeStart);
3252 theError = SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE;
3256 TIDSortedElemSet elements;
3257 arrayToSet(theIDsOfElements, getMeshDS(), elements, theElementType);
3259 list<double> angles;
3260 for (int i = 0; i < theAngles.length(); i++) {
3261 angles.push_back( theAngles[i] );
3264 gp_Pnt refPnt( theRefPoint.x, theRefPoint.y, theRefPoint.z );
3266 int nbOldGroups = myMesh->NbGroup();
3268 ::SMESH_MeshEditor::Extrusion_Error error =
3269 getEditor().ExtrusionAlongTrack( elements, aSubMesh, nodeStart,
3270 theHasAngles, angles, false,
3271 theHasRefPoint, refPnt, theMakeGroups );
3273 declareMeshModified( /*isReComputeSafe=*/true );
3274 theError = convExtrError( error );
3276 if ( theMakeGroups ) {
3277 list<int> groupIDs = myMesh->GetGroupIds();
3278 list<int>::iterator newBegin = groupIDs.begin();
3279 std::advance( newBegin, nbOldGroups ); // skip old groups
3280 groupIDs.erase( groupIDs.begin(), newBegin );
3281 return getGroups( & groupIDs );
3285 SMESH_CATCH( SMESH::throwCorbaException );
3289 //=======================================================================
3290 //function : extrusionAlongPathX
3292 //=======================================================================
3294 SMESH::ListOfGroups*
3295 SMESH_MeshEditor_i::extrusionAlongPathX(const SMESH::long_array & IDsOfElements,
3296 SMESH::SMESH_IDSource_ptr Path,
3297 CORBA::Long NodeStart,
3298 CORBA::Boolean HasAngles,
3299 const SMESH::double_array& Angles,
3300 CORBA::Boolean LinearVariation,
3301 CORBA::Boolean HasRefPoint,
3302 const SMESH::PointStruct& RefPoint,
3304 const SMDSAbs_ElementType ElementType,
3305 SMESH::SMESH_MeshEditor::Extrusion_Error & Error)
3306 throw (SALOME::SALOME_Exception)
3309 SMESH::ListOfGroups* EmptyGr = new SMESH::ListOfGroups;
3313 list<double> angles;
3314 for (int i = 0; i < Angles.length(); i++) {
3315 angles.push_back( Angles[i] );
3317 gp_Pnt refPnt( RefPoint.x, RefPoint.y, RefPoint.z );
3318 int nbOldGroups = myMesh->NbGroup();
3320 if ( Path->_is_nil() ) {
3321 Error = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
3325 TIDSortedElemSet elements, copyElements;
3326 arrayToSet(IDsOfElements, getMeshDS(), elements, ElementType);
3328 TIDSortedElemSet* workElements = &elements;
3330 if ( myIsPreviewMode )
3332 SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
3333 getPreviewMesh( SMDSAbs_Face )->Copy( elements, copyElements, select, avoid );
3334 workElements = & copyElements;
3338 ::SMESH_MeshEditor::Extrusion_Error error;
3340 if ( SMESH_Mesh_i* aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( Path ))
3343 SMDS_MeshNode* aNodeStart =
3344 (SMDS_MeshNode*)aMeshImp->GetImpl().GetMeshDS()->FindNode(NodeStart);
3345 if ( !aNodeStart ) {
3346 Error = SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE;
3349 error = getEditor().ExtrusionAlongTrack( *workElements, &(aMeshImp->GetImpl()), aNodeStart,
3350 HasAngles, angles, LinearVariation,
3351 HasRefPoint, refPnt, MakeGroups );
3352 declareMeshModified( /*isReComputeSafe=*/true );
3354 else if ( SMESH_subMesh_i* aSubMeshImp = SMESH::DownCast<SMESH_subMesh_i*>( Path ))
3357 SMESH::SMESH_Mesh_ptr aPathMesh = aSubMeshImp->GetFather();
3358 aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( aPathMesh );
3359 SMDS_MeshNode* aNodeStart =
3360 (SMDS_MeshNode*)aMeshImp->GetImpl().GetMeshDS()->FindNode(NodeStart);
3361 if ( !aNodeStart ) {
3362 Error = SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE;
3365 SMESH_subMesh* aSubMesh =
3366 aMeshImp->GetImpl().GetSubMeshContaining(aSubMeshImp->GetId());
3367 error = getEditor().ExtrusionAlongTrack( *workElements, aSubMesh, aNodeStart,
3368 HasAngles, angles, LinearVariation,
3369 HasRefPoint, refPnt, MakeGroups );
3370 declareMeshModified( /*isReComputeSafe=*/true );
3372 else if ( SMESH::DownCast<SMESH_Group_i*>( Path ))
3374 // path as group of 1D elements
3380 Error = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
3384 Error = convExtrError( error );
3387 list<int> groupIDs = myMesh->GetGroupIds();
3388 list<int>::iterator newBegin = groupIDs.begin();
3389 std::advance( newBegin, nbOldGroups ); // skip old groups
3390 groupIDs.erase( groupIDs.begin(), newBegin );
3391 return getGroups( & groupIDs );
3395 SMESH_CATCH( SMESH::throwCorbaException );
3399 //=======================================================================
3400 //function : ExtrusionAlongPath
3402 //=======================================================================
3404 SMESH::SMESH_MeshEditor::Extrusion_Error
3405 SMESH_MeshEditor_i::ExtrusionAlongPath(const SMESH::long_array & theIDsOfElements,
3406 SMESH::SMESH_Mesh_ptr thePathMesh,
3407 GEOM::GEOM_Object_ptr thePathShape,
3408 CORBA::Long theNodeStart,
3409 CORBA::Boolean theHasAngles,
3410 const SMESH::double_array & theAngles,
3411 CORBA::Boolean theHasRefPoint,
3412 const SMESH::PointStruct & theRefPoint)
3413 throw (SALOME::SALOME_Exception)
3415 MESSAGE("ExtrusionAlongPath");
3416 if ( !myIsPreviewMode ) {
3417 TPythonDump() << "error = " << this << ".ExtrusionAlongPath( "
3418 << theIDsOfElements << ", "
3419 << thePathMesh << ", "
3420 << thePathShape << ", "
3421 << theNodeStart << ", "
3422 << theHasAngles << ", "
3423 << theAngles << ", "
3424 << theHasRefPoint << ", "
3425 << "SMESH.PointStruct( "
3426 << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
3427 << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
3428 << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
3430 SMESH::SMESH_MeshEditor::Extrusion_Error anError;
3431 extrusionAlongPath( theIDsOfElements,
3444 //=======================================================================
3445 //function : ExtrusionAlongPathObject
3447 //=======================================================================
3449 SMESH::SMESH_MeshEditor::Extrusion_Error
3450 SMESH_MeshEditor_i::ExtrusionAlongPathObject(SMESH::SMESH_IDSource_ptr theObject,
3451 SMESH::SMESH_Mesh_ptr thePathMesh,
3452 GEOM::GEOM_Object_ptr thePathShape,
3453 CORBA::Long theNodeStart,
3454 CORBA::Boolean theHasAngles,
3455 const SMESH::double_array & theAngles,
3456 CORBA::Boolean theHasRefPoint,
3457 const SMESH::PointStruct & theRefPoint)
3458 throw (SALOME::SALOME_Exception)
3460 if ( !myIsPreviewMode ) {
3461 TPythonDump() << "error = " << this << ".ExtrusionAlongPathObject( "
3462 << theObject << ", "
3463 << thePathMesh << ", "
3464 << thePathShape << ", "
3465 << theNodeStart << ", "
3466 << theHasAngles << ", "
3467 << theAngles << ", "
3468 << theHasRefPoint << ", "
3469 << "SMESH.PointStruct( "
3470 << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
3471 << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
3472 << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
3474 SMESH::SMESH_MeshEditor::Extrusion_Error anError;
3475 prepareIdSource( theObject );
3476 SMESH::long_array_var anElementsId = theObject->GetIDs();
3477 extrusionAlongPath( anElementsId,
3490 //=======================================================================
3491 //function : ExtrusionAlongPathObject1D
3493 //=======================================================================
3495 SMESH::SMESH_MeshEditor::Extrusion_Error
3496 SMESH_MeshEditor_i::ExtrusionAlongPathObject1D(SMESH::SMESH_IDSource_ptr theObject,
3497 SMESH::SMESH_Mesh_ptr thePathMesh,
3498 GEOM::GEOM_Object_ptr thePathShape,
3499 CORBA::Long theNodeStart,
3500 CORBA::Boolean theHasAngles,
3501 const SMESH::double_array & theAngles,
3502 CORBA::Boolean theHasRefPoint,
3503 const SMESH::PointStruct & theRefPoint)
3504 throw (SALOME::SALOME_Exception)
3506 if ( !myIsPreviewMode ) {
3507 TPythonDump() << "error = " << this << ".ExtrusionAlongPathObject1D( "
3508 << theObject << ", "
3509 << thePathMesh << ", "
3510 << thePathShape << ", "
3511 << theNodeStart << ", "
3512 << theHasAngles << ", "
3513 << theAngles << ", "
3514 << theHasRefPoint << ", "
3515 << "SMESH.PointStruct( "
3516 << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
3517 << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
3518 << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
3520 SMESH::SMESH_MeshEditor::Extrusion_Error anError;
3521 prepareIdSource( theObject );
3522 SMESH::long_array_var anElementsId = theObject->GetIDs();
3523 extrusionAlongPath( anElementsId,
3537 //=======================================================================
3538 //function : ExtrusionAlongPathObject2D
3540 //=======================================================================
3542 SMESH::SMESH_MeshEditor::Extrusion_Error
3543 SMESH_MeshEditor_i::ExtrusionAlongPathObject2D(SMESH::SMESH_IDSource_ptr theObject,
3544 SMESH::SMESH_Mesh_ptr thePathMesh,
3545 GEOM::GEOM_Object_ptr thePathShape,
3546 CORBA::Long theNodeStart,
3547 CORBA::Boolean theHasAngles,
3548 const SMESH::double_array & theAngles,
3549 CORBA::Boolean theHasRefPoint,
3550 const SMESH::PointStruct & theRefPoint)
3551 throw (SALOME::SALOME_Exception)
3553 if ( !myIsPreviewMode ) {
3554 TPythonDump() << "error = " << this << ".ExtrusionAlongPathObject2D( "
3555 << theObject << ", "
3556 << thePathMesh << ", "
3557 << thePathShape << ", "
3558 << theNodeStart << ", "
3559 << theHasAngles << ", "
3560 << theAngles << ", "
3561 << theHasRefPoint << ", "
3562 << "SMESH.PointStruct( "
3563 << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
3564 << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
3565 << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
3567 SMESH::SMESH_MeshEditor::Extrusion_Error anError;
3568 prepareIdSource( theObject );
3569 SMESH::long_array_var anElementsId = theObject->GetIDs();
3570 extrusionAlongPath( anElementsId,
3585 //=======================================================================
3586 //function : ExtrusionAlongPathMakeGroups
3588 //=======================================================================
3590 SMESH::ListOfGroups*
3591 SMESH_MeshEditor_i::ExtrusionAlongPathMakeGroups(const SMESH::long_array& theIDsOfElements,
3592 SMESH::SMESH_Mesh_ptr thePathMesh,
3593 GEOM::GEOM_Object_ptr thePathShape,
3594 CORBA::Long theNodeStart,
3595 CORBA::Boolean theHasAngles,
3596 const SMESH::double_array& theAngles,
3597 CORBA::Boolean theHasRefPoint,
3598 const SMESH::PointStruct& theRefPoint,
3599 SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
3600 throw (SALOME::SALOME_Exception)
3602 TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
3604 SMESH::ListOfGroups * aGroups = extrusionAlongPath( theIDsOfElements,
3614 if (!myIsPreviewMode) {
3615 bool isDumpGroups = aGroups && aGroups->length() > 0;
3617 aPythonDump << "(" << aGroups << ", error)";
3619 aPythonDump <<"error";
3621 aPythonDump<<" = "<< this << ".ExtrusionAlongPathMakeGroups( "
3622 << theIDsOfElements << ", "
3623 << thePathMesh << ", "
3624 << thePathShape << ", "
3625 << theNodeStart << ", "
3626 << theHasAngles << ", "
3627 << theAngles << ", "
3628 << theHasRefPoint << ", "
3629 << "SMESH.PointStruct( "
3630 << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
3631 << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
3632 << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
3637 //=======================================================================
3638 //function : ExtrusionAlongPathObjectMakeGroups
3640 //=======================================================================
3642 SMESH::ListOfGroups* SMESH_MeshEditor_i::
3643 ExtrusionAlongPathObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
3644 SMESH::SMESH_Mesh_ptr thePathMesh,
3645 GEOM::GEOM_Object_ptr thePathShape,
3646 CORBA::Long theNodeStart,
3647 CORBA::Boolean theHasAngles,
3648 const SMESH::double_array& theAngles,
3649 CORBA::Boolean theHasRefPoint,
3650 const SMESH::PointStruct& theRefPoint,
3651 SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
3652 throw (SALOME::SALOME_Exception)
3654 TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
3656 prepareIdSource( theObject );
3657 SMESH::long_array_var anElementsId = theObject->GetIDs();
3658 SMESH::ListOfGroups * aGroups = extrusionAlongPath( anElementsId,
3669 if (!myIsPreviewMode) {
3670 bool isDumpGroups = aGroups && aGroups->length() > 0;
3672 aPythonDump << "(" << aGroups << ", error)";
3674 aPythonDump <<"error";
3676 aPythonDump << " = " << this << ".ExtrusionAlongPathObjectMakeGroups( "
3677 << theObject << ", "
3678 << thePathMesh << ", "
3679 << thePathShape << ", "
3680 << theNodeStart << ", "
3681 << theHasAngles << ", "
3682 << theAngles << ", "
3683 << theHasRefPoint << ", "
3684 << "SMESH.PointStruct( "
3685 << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
3686 << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
3687 << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
3692 //=======================================================================
3693 //function : ExtrusionAlongPathObject1DMakeGroups
3695 //=======================================================================
3697 SMESH::ListOfGroups* SMESH_MeshEditor_i::
3698 ExtrusionAlongPathObject1DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
3699 SMESH::SMESH_Mesh_ptr thePathMesh,
3700 GEOM::GEOM_Object_ptr thePathShape,
3701 CORBA::Long theNodeStart,
3702 CORBA::Boolean theHasAngles,
3703 const SMESH::double_array& theAngles,
3704 CORBA::Boolean theHasRefPoint,
3705 const SMESH::PointStruct& theRefPoint,
3706 SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
3707 throw (SALOME::SALOME_Exception)
3709 TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
3711 prepareIdSource( theObject );
3712 SMESH::long_array_var anElementsId = theObject->GetIDs();
3713 SMESH::ListOfGroups * aGroups = extrusionAlongPath( anElementsId,
3725 if (!myIsPreviewMode) {
3726 bool isDumpGroups = aGroups && aGroups->length() > 0;
3728 aPythonDump << "(" << aGroups << ", error)";
3730 aPythonDump << "error";
3732 aPythonDump << " = " << this << ".ExtrusionAlongPathObject1DMakeGroups( "
3733 << theObject << ", "
3734 << thePathMesh << ", "
3735 << thePathShape << ", "
3736 << theNodeStart << ", "
3737 << theHasAngles << ", "
3738 << theAngles << ", "
3739 << theHasRefPoint << ", "
3740 << "SMESH.PointStruct( "
3741 << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
3742 << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
3743 << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
3748 //=======================================================================
3749 //function : ExtrusionAlongPathObject2DMakeGroups
3751 //=======================================================================
3753 SMESH::ListOfGroups* SMESH_MeshEditor_i::
3754 ExtrusionAlongPathObject2DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
3755 SMESH::SMESH_Mesh_ptr thePathMesh,
3756 GEOM::GEOM_Object_ptr thePathShape,
3757 CORBA::Long theNodeStart,
3758 CORBA::Boolean theHasAngles,
3759 const SMESH::double_array& theAngles,
3760 CORBA::Boolean theHasRefPoint,
3761 const SMESH::PointStruct& theRefPoint,
3762 SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
3763 throw (SALOME::SALOME_Exception)
3765 TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
3767 prepareIdSource( theObject );
3768 SMESH::long_array_var anElementsId = theObject->GetIDs();
3769 SMESH::ListOfGroups * aGroups = extrusionAlongPath( anElementsId,
3781 if (!myIsPreviewMode) {
3782 bool isDumpGroups = aGroups && aGroups->length() > 0;
3784 aPythonDump << "(" << aGroups << ", error)";
3786 aPythonDump << "error";
3788 aPythonDump << " = " << this << ".ExtrusionAlongPathObject2DMakeGroups( "
3789 << theObject << ", "
3790 << thePathMesh << ", "
3791 << thePathShape << ", "
3792 << theNodeStart << ", "
3793 << theHasAngles << ", "
3794 << theAngles << ", "
3795 << theHasRefPoint << ", "
3796 << "SMESH.PointStruct( "
3797 << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
3798 << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
3799 << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
3804 //=======================================================================
3805 //function : ExtrusionAlongPathObjX
3807 //=======================================================================
3809 SMESH::ListOfGroups* SMESH_MeshEditor_i::
3810 ExtrusionAlongPathObjX(SMESH::SMESH_IDSource_ptr Object,
3811 SMESH::SMESH_IDSource_ptr Path,
3812 CORBA::Long NodeStart,
3813 CORBA::Boolean HasAngles,
3814 const SMESH::double_array& Angles,
3815 CORBA::Boolean LinearVariation,
3816 CORBA::Boolean HasRefPoint,
3817 const SMESH::PointStruct& RefPoint,
3818 CORBA::Boolean MakeGroups,
3819 SMESH::ElementType ElemType,
3820 SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
3821 throw (SALOME::SALOME_Exception)
3823 TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
3825 prepareIdSource( Object );
3826 SMESH::long_array_var anElementsId = Object->GetIDs();
3827 SMESH::ListOfGroups * aGroups = extrusionAlongPathX(anElementsId,
3836 (SMDSAbs_ElementType)ElemType,
3839 if (!myIsPreviewMode) {
3840 bool isDumpGroups = aGroups && aGroups->length() > 0;
3842 aPythonDump << "(" << *aGroups << ", error)";
3844 aPythonDump << "error";
3846 aPythonDump << " = " << this << ".ExtrusionAlongPathObjX( "
3849 << NodeStart << ", "
3850 << HasAngles << ", "
3851 << TVar( Angles ) << ", "
3852 << LinearVariation << ", "
3853 << HasRefPoint << ", "
3854 << "SMESH.PointStruct( "
3855 << TVar( HasRefPoint ? RefPoint.x : 0 ) << ", "
3856 << TVar( HasRefPoint ? RefPoint.y : 0 ) << ", "
3857 << TVar( HasRefPoint ? RefPoint.z : 0 ) << " ), "
3858 << MakeGroups << ", "
3859 << ElemType << " )";
3864 //=======================================================================
3865 //function : ExtrusionAlongPathX
3867 //=======================================================================
3869 SMESH::ListOfGroups* SMESH_MeshEditor_i::
3870 ExtrusionAlongPathX(const SMESH::long_array& IDsOfElements,
3871 SMESH::SMESH_IDSource_ptr Path,
3872 CORBA::Long NodeStart,
3873 CORBA::Boolean HasAngles,
3874 const SMESH::double_array& Angles,
3875 CORBA::Boolean LinearVariation,
3876 CORBA::Boolean HasRefPoint,
3877 const SMESH::PointStruct& RefPoint,
3878 CORBA::Boolean MakeGroups,
3879 SMESH::ElementType ElemType,
3880 SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
3881 throw (SALOME::SALOME_Exception)
3883 TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
3885 SMESH::ListOfGroups * aGroups = extrusionAlongPathX(IDsOfElements,
3894 (SMDSAbs_ElementType)ElemType,
3897 if (!myIsPreviewMode) {
3898 bool isDumpGroups = aGroups && aGroups->length() > 0;
3900 aPythonDump << "(" << *aGroups << ", error)";
3902 aPythonDump <<"error";
3904 aPythonDump << " = " << this << ".ExtrusionAlongPathX( "
3905 << IDsOfElements << ", "
3907 << NodeStart << ", "
3908 << HasAngles << ", "
3909 << TVar( Angles ) << ", "
3910 << LinearVariation << ", "
3911 << HasRefPoint << ", "
3912 << "SMESH.PointStruct( "
3913 << TVar( HasRefPoint ? RefPoint.x : 0 ) << ", "
3914 << TVar( HasRefPoint ? RefPoint.y : 0 ) << ", "
3915 << TVar( HasRefPoint ? RefPoint.z : 0 ) << " ), "
3916 << MakeGroups << ", "
3917 << ElemType << " )";
3922 //================================================================================
3924 * \brief Compute rotation angles for ExtrusionAlongPath as linear variation
3925 * of given angles along path steps
3926 * \param PathMesh mesh containing a 1D sub-mesh on the edge, along
3927 * which proceeds the extrusion
3928 * \param PathShape is shape(edge); as the mesh can be complex, the edge
3929 * is used to define the sub-mesh for the path
3931 //================================================================================
3933 SMESH::double_array*
3934 SMESH_MeshEditor_i::LinearAnglesVariation(SMESH::SMESH_Mesh_ptr thePathMesh,
3935 GEOM::GEOM_Object_ptr thePathShape,
3936 const SMESH::double_array & theAngles)
3938 SMESH::double_array_var aResult = new SMESH::double_array();
3939 int nbAngles = theAngles.length();
3940 if ( nbAngles > 0 && !thePathMesh->_is_nil() && !thePathShape->_is_nil() )
3942 SMESH_Mesh_i* aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( thePathMesh );
3943 TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( thePathShape );
3944 SMESH_subMesh* aSubMesh = aMeshImp->GetImpl().GetSubMesh( aShape );
3945 if ( !aSubMesh || !aSubMesh->GetSubMeshDS())
3946 return aResult._retn();
3947 int nbSteps = aSubMesh->GetSubMeshDS()->NbElements();
3948 if ( nbSteps == nbAngles )
3950 aResult.inout() = theAngles;
3954 aResult->length( nbSteps );
3955 double rAn2St = double( nbAngles ) / double( nbSteps );
3956 double angPrev = 0, angle;
3957 for ( int iSt = 0; iSt < nbSteps; ++iSt )
3959 double angCur = rAn2St * ( iSt+1 );
3960 double angCurFloor = floor( angCur );
3961 double angPrevFloor = floor( angPrev );
3962 if ( angPrevFloor == angCurFloor )
3963 angle = rAn2St * theAngles[ int( angCurFloor ) ];
3966 int iP = int( angPrevFloor );
3967 double angPrevCeil = ceil(angPrev);
3968 angle = ( angPrevCeil - angPrev ) * theAngles[ iP ];
3970 int iC = int( angCurFloor );
3971 if ( iC < nbAngles )
3972 angle += ( angCur - angCurFloor ) * theAngles[ iC ];
3974 iP = int( angPrevCeil );
3976 angle += theAngles[ iC ];
3978 aResult[ iSt ] = angle;
3983 // Update Python script
3984 TPythonDump() << "rotAngles = " << theAngles;
3985 TPythonDump() << "rotAngles = " << this << ".LinearAnglesVariation( "
3986 << thePathMesh << ", "
3987 << thePathShape << ", "
3990 return aResult._retn();
3993 //=======================================================================
3996 //=======================================================================
3998 SMESH::ListOfGroups*
3999 SMESH_MeshEditor_i::mirror(TIDSortedElemSet & theElements,
4000 const SMESH::AxisStruct & theAxis,
4001 SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
4002 CORBA::Boolean theCopy,
4004 ::SMESH_Mesh* theTargetMesh)
4005 throw (SALOME::SALOME_Exception)
4010 gp_Pnt P ( theAxis.x, theAxis.y, theAxis.z );
4011 gp_Vec V ( theAxis.vx, theAxis.vy, theAxis.vz );
4013 if ( theTargetMesh )
4017 switch ( theMirrorType ) {
4018 case SMESH::SMESH_MeshEditor::POINT:
4019 aTrsf.SetMirror( P );
4021 case SMESH::SMESH_MeshEditor::AXIS:
4022 aTrsf.SetMirror( gp_Ax1( P, V ));
4025 aTrsf.SetMirror( gp_Ax2( P, V ));
4028 TIDSortedElemSet copyElements;
4029 TIDSortedElemSet* workElements = & theElements;
4031 if ( myIsPreviewMode )
4033 TPreviewMesh * tmpMesh = getPreviewMesh();
4034 tmpMesh->Copy( theElements, copyElements);
4035 if ( !theCopy && !theTargetMesh )
4037 TIDSortedElemSet elemsAround, elemsAroundCopy;
4038 getElementsAround( theElements, getMeshDS(), elemsAround );
4039 tmpMesh->Copy( elemsAround, elemsAroundCopy);
4041 workElements = & copyElements;
4042 theMakeGroups = false;
4045 ::SMESH_MeshEditor::PGroupIDs groupIds =
4046 getEditor().Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
4048 if ( theCopy && !myIsPreviewMode)
4050 if ( theTargetMesh )
4052 theTargetMesh->GetMeshDS()->Modified();
4056 declareMeshModified( /*isReComputeSafe=*/false );
4059 return theMakeGroups ? getGroups(groupIds.get()) : 0;
4061 SMESH_CATCH( SMESH::throwCorbaException );
4065 //=======================================================================
4068 //=======================================================================
4070 void SMESH_MeshEditor_i::Mirror(const SMESH::long_array & theIDsOfElements,
4071 const SMESH::AxisStruct & theAxis,
4072 SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
4073 CORBA::Boolean theCopy)
4074 throw (SALOME::SALOME_Exception)
4076 if ( !myIsPreviewMode ) {
4077 TPythonDump() << this << ".Mirror( "
4078 << theIDsOfElements << ", "
4080 << mirrorTypeName(theMirrorType) << ", "
4083 if ( theIDsOfElements.length() > 0 )
4085 TIDSortedElemSet elements;
4086 arrayToSet(theIDsOfElements, getMeshDS(), elements);
4087 mirror(elements, theAxis, theMirrorType, theCopy, false);
4092 //=======================================================================
4093 //function : MirrorObject
4095 //=======================================================================
4097 void SMESH_MeshEditor_i::MirrorObject(SMESH::SMESH_IDSource_ptr theObject,
4098 const SMESH::AxisStruct & theAxis,
4099 SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
4100 CORBA::Boolean theCopy)
4101 throw (SALOME::SALOME_Exception)
4103 if ( !myIsPreviewMode ) {
4104 TPythonDump() << this << ".MirrorObject( "
4105 << theObject << ", "
4107 << mirrorTypeName(theMirrorType) << ", "
4110 TIDSortedElemSet elements;
4112 bool emptyIfIsMesh = myIsPreviewMode ? false : true;
4114 prepareIdSource( theObject );
4115 if (idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
4116 mirror(elements, theAxis, theMirrorType, theCopy, false);
4119 //=======================================================================
4120 //function : MirrorMakeGroups
4122 //=======================================================================
4124 SMESH::ListOfGroups*
4125 SMESH_MeshEditor_i::MirrorMakeGroups(const SMESH::long_array& theIDsOfElements,
4126 const SMESH::AxisStruct& theMirror,
4127 SMESH::SMESH_MeshEditor::MirrorType theMirrorType)
4128 throw (SALOME::SALOME_Exception)
4130 TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
4132 SMESH::ListOfGroups * aGroups = 0;
4133 if ( theIDsOfElements.length() > 0 )
4135 TIDSortedElemSet elements;
4136 arrayToSet(theIDsOfElements, getMeshDS(), elements);
4137 aGroups = mirror(elements, theMirror, theMirrorType, true, true);
4139 if (!myIsPreviewMode) {
4140 dumpGroupsList(aPythonDump, aGroups);
4141 aPythonDump << this << ".MirrorMakeGroups( "
4142 << theIDsOfElements << ", "
4143 << theMirror << ", "
4144 << mirrorTypeName(theMirrorType) << " )";
4149 //=======================================================================
4150 //function : MirrorObjectMakeGroups
4152 //=======================================================================
4154 SMESH::ListOfGroups*
4155 SMESH_MeshEditor_i::MirrorObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
4156 const SMESH::AxisStruct& theMirror,
4157 SMESH::SMESH_MeshEditor::MirrorType theMirrorType)
4158 throw (SALOME::SALOME_Exception)
4160 TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
4162 SMESH::ListOfGroups * aGroups = 0;
4163 TIDSortedElemSet elements;
4164 prepareIdSource( theObject );
4165 if ( idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
4166 aGroups = mirror(elements, theMirror, theMirrorType, true, true);
4168 if (!myIsPreviewMode)
4170 dumpGroupsList(aPythonDump,aGroups);
4171 aPythonDump << this << ".MirrorObjectMakeGroups( "
4172 << theObject << ", "
4173 << theMirror << ", "
4174 << mirrorTypeName(theMirrorType) << " )";
4179 //=======================================================================
4180 //function : MirrorMakeMesh
4182 //=======================================================================
4184 SMESH::SMESH_Mesh_ptr
4185 SMESH_MeshEditor_i::MirrorMakeMesh(const SMESH::long_array& theIDsOfElements,
4186 const SMESH::AxisStruct& theMirror,
4187 SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
4188 CORBA::Boolean theCopyGroups,
4189 const char* theMeshName)
4190 throw (SALOME::SALOME_Exception)
4192 SMESH_Mesh_i* mesh_i;
4193 SMESH::SMESH_Mesh_var mesh;
4194 { // open new scope to dump "MakeMesh" command
4195 // and then "GetGroups" using SMESH_Mesh::GetGroups()
4197 TPythonDump pydump; // to prevent dump at mesh creation
4199 mesh = makeMesh( theMeshName );
4200 mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
4201 if (mesh_i && theIDsOfElements.length() > 0 )
4203 TIDSortedElemSet elements;
4204 arrayToSet(theIDsOfElements, getMeshDS(), elements);
4205 mirror(elements, theMirror, theMirrorType,
4206 false, theCopyGroups, & mesh_i->GetImpl());
4207 mesh_i->CreateGroupServants();
4210 if (!myIsPreviewMode) {
4211 pydump << mesh << " = " << this << ".MirrorMakeMesh( "
4212 << theIDsOfElements << ", "
4213 << theMirror << ", "
4214 << mirrorTypeName(theMirrorType) << ", "
4215 << theCopyGroups << ", '"
4216 << theMeshName << "' )";
4221 if (!myIsPreviewMode && mesh_i)
4222 mesh_i->GetGroups();
4224 return mesh._retn();
4227 //=======================================================================
4228 //function : MirrorObjectMakeMesh
4230 //=======================================================================
4232 SMESH::SMESH_Mesh_ptr
4233 SMESH_MeshEditor_i::MirrorObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject,
4234 const SMESH::AxisStruct& theMirror,
4235 SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
4236 CORBA::Boolean theCopyGroups,
4237 const char* theMeshName)
4238 throw (SALOME::SALOME_Exception)
4240 SMESH_Mesh_i* mesh_i;
4241 SMESH::SMESH_Mesh_var mesh;
4242 { // open new scope to dump "MakeMesh" command
4243 // and then "GetGroups" using SMESH_Mesh::GetGroups()
4245 TPythonDump pydump; // to prevent dump at mesh creation
4247 mesh = makeMesh( theMeshName );
4248 mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
4249 TIDSortedElemSet elements;
4250 prepareIdSource( theObject );
4252 idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
4254 mirror(elements, theMirror, theMirrorType,
4255 false, theCopyGroups, & mesh_i->GetImpl());
4256 mesh_i->CreateGroupServants();
4258 if (!myIsPreviewMode) {
4259 pydump << mesh << " = " << this << ".MirrorObjectMakeMesh( "
4260 << theObject << ", "
4261 << theMirror << ", "
4262 << mirrorTypeName(theMirrorType) << ", "
4263 << theCopyGroups << ", '"
4264 << theMeshName << "' )";
4269 if (!myIsPreviewMode && mesh_i)
4270 mesh_i->GetGroups();
4272 return mesh._retn();
4275 //=======================================================================
4276 //function : translate
4278 //=======================================================================
4280 SMESH::ListOfGroups*
4281 SMESH_MeshEditor_i::translate(TIDSortedElemSet & theElements,
4282 const SMESH::DirStruct & theVector,
4283 CORBA::Boolean theCopy,
4285 ::SMESH_Mesh* theTargetMesh)
4286 throw (SALOME::SALOME_Exception)
4291 if ( theTargetMesh )
4295 const SMESH::PointStruct * P = &theVector.PS;
4296 aTrsf.SetTranslation( gp_Vec( P->x, P->y, P->z ));
4298 TIDSortedElemSet copyElements;
4299 TIDSortedElemSet* workElements = &theElements;
4301 if ( myIsPreviewMode )
4303 TPreviewMesh * tmpMesh = getPreviewMesh();
4304 tmpMesh->Copy( theElements, copyElements);
4305 if ( !theCopy && !theTargetMesh )
4307 TIDSortedElemSet elemsAround, elemsAroundCopy;
4308 getElementsAround( theElements, getMeshDS(), elemsAround );
4309 tmpMesh->Copy( elemsAround, elemsAroundCopy);
4311 workElements = & copyElements;
4312 theMakeGroups = false;
4315 ::SMESH_MeshEditor::PGroupIDs groupIds =
4316 getEditor().Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
4318 if ( theCopy && !myIsPreviewMode )
4320 if ( theTargetMesh )
4322 theTargetMesh->GetMeshDS()->Modified();
4326 declareMeshModified( /*isReComputeSafe=*/false );
4330 return theMakeGroups ? getGroups(groupIds.get()) : 0;
4332 SMESH_CATCH( SMESH::throwCorbaException );
4336 //=======================================================================
4337 //function : Translate
4339 //=======================================================================
4341 void SMESH_MeshEditor_i::Translate(const SMESH::long_array & theIDsOfElements,
4342 const SMESH::DirStruct & theVector,
4343 CORBA::Boolean theCopy)
4344 throw (SALOME::SALOME_Exception)
4346 if (!myIsPreviewMode) {
4347 TPythonDump() << this << ".Translate( "
4348 << theIDsOfElements << ", "
4349 << theVector << ", "
4352 if (theIDsOfElements.length()) {
4353 TIDSortedElemSet elements;
4354 arrayToSet(theIDsOfElements, getMeshDS(), elements);
4355 translate(elements, theVector, theCopy, false);
4359 //=======================================================================
4360 //function : TranslateObject
4362 //=======================================================================
4364 void SMESH_MeshEditor_i::TranslateObject(SMESH::SMESH_IDSource_ptr theObject,
4365 const SMESH::DirStruct & theVector,
4366 CORBA::Boolean theCopy)
4367 throw (SALOME::SALOME_Exception)
4369 if (!myIsPreviewMode) {
4370 TPythonDump() << this << ".TranslateObject( "
4371 << theObject << ", "
4372 << theVector << ", "
4375 TIDSortedElemSet elements;
4377 bool emptyIfIsMesh = myIsPreviewMode ? false : true;
4379 prepareIdSource( theObject );
4380 if (idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
4381 translate(elements, theVector, theCopy, false);
4384 //=======================================================================
4385 //function : TranslateMakeGroups
4387 //=======================================================================
4389 SMESH::ListOfGroups*
4390 SMESH_MeshEditor_i::TranslateMakeGroups(const SMESH::long_array& theIDsOfElements,
4391 const SMESH::DirStruct& theVector)
4392 throw (SALOME::SALOME_Exception)
4394 TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
4396 SMESH::ListOfGroups * aGroups = 0;
4397 if (theIDsOfElements.length()) {
4398 TIDSortedElemSet elements;
4399 arrayToSet(theIDsOfElements, getMeshDS(), elements);
4400 aGroups = translate(elements,theVector,true,true);
4402 if (!myIsPreviewMode) {
4403 dumpGroupsList(aPythonDump, aGroups);
4404 aPythonDump << this << ".TranslateMakeGroups( "
4405 << theIDsOfElements << ", "
4406 << theVector << " )";
4411 //=======================================================================
4412 //function : TranslateObjectMakeGroups
4414 //=======================================================================
4416 SMESH::ListOfGroups*
4417 SMESH_MeshEditor_i::TranslateObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
4418 const SMESH::DirStruct& theVector)
4419 throw (SALOME::SALOME_Exception)
4421 TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
4423 SMESH::ListOfGroups * aGroups = 0;
4424 TIDSortedElemSet elements;
4425 prepareIdSource( theObject );
4426 if (idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
4427 aGroups = translate(elements, theVector, true, true);
4429 if (!myIsPreviewMode) {
4430 dumpGroupsList(aPythonDump, aGroups);
4431 aPythonDump << this << ".TranslateObjectMakeGroups( "
4432 << theObject << ", "
4433 << theVector << " )";
4438 //=======================================================================
4439 //function : TranslateMakeMesh
4441 //=======================================================================
4443 SMESH::SMESH_Mesh_ptr
4444 SMESH_MeshEditor_i::TranslateMakeMesh(const SMESH::long_array& theIDsOfElements,
4445 const SMESH::DirStruct& theVector,
4446 CORBA::Boolean theCopyGroups,
4447 const char* theMeshName)
4448 throw (SALOME::SALOME_Exception)
4450 SMESH_Mesh_i* mesh_i;
4451 SMESH::SMESH_Mesh_var mesh;
4453 { // open new scope to dump "MakeMesh" command
4454 // and then "GetGroups" using SMESH_Mesh::GetGroups()
4456 TPythonDump pydump; // to prevent dump at mesh creation
4458 mesh = makeMesh( theMeshName );
4459 mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
4461 if ( mesh_i && theIDsOfElements.length() )
4463 TIDSortedElemSet elements;
4464 arrayToSet(theIDsOfElements, getMeshDS(), elements);
4465 translate(elements, theVector, false, theCopyGroups, & mesh_i->GetImpl());
4466 mesh_i->CreateGroupServants();
4469 if ( !myIsPreviewMode ) {
4470 pydump << mesh << " = " << this << ".TranslateMakeMesh( "
4471 << theIDsOfElements << ", "
4472 << theVector << ", "
4473 << theCopyGroups << ", '"
4474 << theMeshName << "' )";
4479 if (!myIsPreviewMode && mesh_i)
4480 mesh_i->GetGroups();
4482 return mesh._retn();
4485 //=======================================================================
4486 //function : TranslateObjectMakeMesh
4488 //=======================================================================
4490 SMESH::SMESH_Mesh_ptr
4491 SMESH_MeshEditor_i::TranslateObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject,
4492 const SMESH::DirStruct& theVector,
4493 CORBA::Boolean theCopyGroups,
4494 const char* theMeshName)
4495 throw (SALOME::SALOME_Exception)
4498 SMESH_Mesh_i* mesh_i;
4499 SMESH::SMESH_Mesh_var mesh;
4500 { // open new scope to dump "MakeMesh" command
4501 // and then "GetGroups" using SMESH_Mesh::GetGroups()
4503 TPythonDump pydump; // to prevent dump at mesh creation
4504 mesh = makeMesh( theMeshName );
4505 mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
4507 TIDSortedElemSet elements;
4508 prepareIdSource( theObject );
4510 idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
4512 translate(elements, theVector,false, theCopyGroups, & mesh_i->GetImpl());
4513 mesh_i->CreateGroupServants();
4515 if ( !myIsPreviewMode ) {
4516 pydump << mesh << " = " << this << ".TranslateObjectMakeMesh( "
4517 << theObject << ", "
4518 << theVector << ", "
4519 << theCopyGroups << ", '"
4520 << theMeshName << "' )";
4525 if (!myIsPreviewMode && mesh_i)
4526 mesh_i->GetGroups();
4528 return mesh._retn();
4530 SMESH_CATCH( SMESH::throwCorbaException );
4534 //=======================================================================
4537 //=======================================================================
4539 SMESH::ListOfGroups*
4540 SMESH_MeshEditor_i::rotate(TIDSortedElemSet & theElements,
4541 const SMESH::AxisStruct & theAxis,
4542 CORBA::Double theAngle,
4543 CORBA::Boolean theCopy,
4545 ::SMESH_Mesh* theTargetMesh)
4546 throw (SALOME::SALOME_Exception)
4551 if ( theTargetMesh )
4554 gp_Pnt P ( theAxis.x, theAxis.y, theAxis.z );
4555 gp_Vec V ( theAxis.vx, theAxis.vy, theAxis.vz );
4558 aTrsf.SetRotation( gp_Ax1( P, V ), theAngle);
4560 TIDSortedElemSet copyElements;
4561 TIDSortedElemSet* workElements = &theElements;
4562 if ( myIsPreviewMode ) {
4563 TPreviewMesh * tmpMesh = getPreviewMesh();
4564 tmpMesh->Copy( theElements, copyElements );
4565 if ( !theCopy && !theTargetMesh )
4567 TIDSortedElemSet elemsAround, elemsAroundCopy;
4568 getElementsAround( theElements, getMeshDS(), elemsAround );
4569 tmpMesh->Copy( elemsAround, elemsAroundCopy);
4571 workElements = ©Elements;
4572 theMakeGroups = false;
4575 ::SMESH_MeshEditor::PGroupIDs groupIds =
4576 getEditor().Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
4578 if ( theCopy && !myIsPreviewMode)
4580 if ( theTargetMesh ) theTargetMesh->GetMeshDS()->Modified();
4581 else declareMeshModified( /*isReComputeSafe=*/false );
4584 return theMakeGroups ? getGroups(groupIds.get()) : 0;
4586 SMESH_CATCH( SMESH::throwCorbaException );
4590 //=======================================================================
4593 //=======================================================================
4595 void SMESH_MeshEditor_i::Rotate(const SMESH::long_array & theIDsOfElements,
4596 const SMESH::AxisStruct & theAxis,
4597 CORBA::Double theAngle,
4598 CORBA::Boolean theCopy)
4599 throw (SALOME::SALOME_Exception)
4601 if (!myIsPreviewMode) {
4602 TPythonDump() << this << ".Rotate( "
4603 << theIDsOfElements << ", "
4605 << TVar( theAngle ) << ", "
4608 if (theIDsOfElements.length() > 0)
4610 TIDSortedElemSet elements;
4611 arrayToSet(theIDsOfElements, getMeshDS(), elements);
4612 rotate(elements,theAxis,theAngle,theCopy,false);
4616 //=======================================================================
4617 //function : RotateObject
4619 //=======================================================================
4621 void SMESH_MeshEditor_i::RotateObject(SMESH::SMESH_IDSource_ptr theObject,
4622 const SMESH::AxisStruct & theAxis,
4623 CORBA::Double theAngle,
4624 CORBA::Boolean theCopy)
4625 throw (SALOME::SALOME_Exception)
4627 if ( !myIsPreviewMode ) {
4628 TPythonDump() << this << ".RotateObject( "
4629 << theObject << ", "
4631 << TVar( theAngle ) << ", "
4634 TIDSortedElemSet elements;
4635 bool emptyIfIsMesh = myIsPreviewMode ? false : true;
4636 prepareIdSource( theObject );
4637 if (idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
4638 rotate(elements,theAxis,theAngle,theCopy,false);
4641 //=======================================================================
4642 //function : RotateMakeGroups
4644 //=======================================================================
4646 SMESH::ListOfGroups*
4647 SMESH_MeshEditor_i::RotateMakeGroups(const SMESH::long_array& theIDsOfElements,
4648 const SMESH::AxisStruct& theAxis,
4649 CORBA::Double theAngle)
4650 throw (SALOME::SALOME_Exception)
4652 TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
4654 SMESH::ListOfGroups * aGroups = 0;
4655 if (theIDsOfElements.length() > 0)
4657 TIDSortedElemSet elements;
4658 arrayToSet(theIDsOfElements, getMeshDS(), elements);
4659 aGroups = rotate(elements,theAxis,theAngle,true,true);
4661 if (!myIsPreviewMode) {
4662 dumpGroupsList(aPythonDump, aGroups);
4663 aPythonDump << this << ".RotateMakeGroups( "
4664 << theIDsOfElements << ", "
4666 << TVar( theAngle ) << " )";
4671 //=======================================================================
4672 //function : RotateObjectMakeGroups
4674 //=======================================================================
4676 SMESH::ListOfGroups*
4677 SMESH_MeshEditor_i::RotateObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
4678 const SMESH::AxisStruct& theAxis,
4679 CORBA::Double theAngle)
4680 throw (SALOME::SALOME_Exception)
4682 TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
4684 SMESH::ListOfGroups * aGroups = 0;
4685 TIDSortedElemSet elements;
4686 prepareIdSource( theObject );
4687 if (idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
4688 aGroups = rotate(elements, theAxis, theAngle, true, true);
4690 if (!myIsPreviewMode) {
4691 dumpGroupsList(aPythonDump, aGroups);
4692 aPythonDump << this << ".RotateObjectMakeGroups( "
4693 << theObject << ", "
4695 << TVar( theAngle ) << " )";
4700 //=======================================================================
4701 //function : RotateMakeMesh
4703 //=======================================================================
4705 SMESH::SMESH_Mesh_ptr
4706 SMESH_MeshEditor_i::RotateMakeMesh(const SMESH::long_array& theIDsOfElements,
4707 const SMESH::AxisStruct& theAxis,
4708 CORBA::Double theAngleInRadians,
4709 CORBA::Boolean theCopyGroups,
4710 const char* theMeshName)
4711 throw (SALOME::SALOME_Exception)
4714 SMESH::SMESH_Mesh_var mesh;
4715 SMESH_Mesh_i* mesh_i;
4717 { // open new scope to dump "MakeMesh" command
4718 // and then "GetGroups" using SMESH_Mesh::GetGroups()
4720 TPythonDump pydump; // to prevent dump at mesh creation
4722 mesh = makeMesh( theMeshName );
4723 mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
4725 if ( mesh_i && theIDsOfElements.length() > 0 )
4727 TIDSortedElemSet elements;
4728 arrayToSet(theIDsOfElements, getMeshDS(), elements);
4729 rotate(elements, theAxis, theAngleInRadians,
4730 false, theCopyGroups, & mesh_i->GetImpl());
4731 mesh_i->CreateGroupServants();
4733 if ( !myIsPreviewMode ) {
4734 pydump << mesh << " = " << this << ".RotateMakeMesh( "
4735 << theIDsOfElements << ", "
4737 << TVar( theAngleInRadians ) << ", "
4738 << theCopyGroups << ", '"
4739 << theMeshName << "' )";
4744 if (!myIsPreviewMode && mesh_i && theIDsOfElements.length() > 0 )
4745 mesh_i->GetGroups();
4747 return mesh._retn();
4749 SMESH_CATCH( SMESH::throwCorbaException );
4753 //=======================================================================
4754 //function : RotateObjectMakeMesh
4756 //=======================================================================
4758 SMESH::SMESH_Mesh_ptr
4759 SMESH_MeshEditor_i::RotateObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject,
4760 const SMESH::AxisStruct& theAxis,
4761 CORBA::Double theAngleInRadians,
4762 CORBA::Boolean theCopyGroups,
4763 const char* theMeshName)
4764 throw (SALOME::SALOME_Exception)
4767 SMESH::SMESH_Mesh_var mesh;
4768 SMESH_Mesh_i* mesh_i;
4770 {// open new scope to dump "MakeMesh" command
4771 // and then "GetGroups" using SMESH_Mesh::GetGroups()
4773 TPythonDump pydump; // to prevent dump at mesh creation
4774 mesh = makeMesh( theMeshName );
4775 mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
4777 TIDSortedElemSet elements;
4778 prepareIdSource( theObject );
4780 idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
4782 rotate(elements, theAxis, theAngleInRadians,
4783 false, theCopyGroups, & mesh_i->GetImpl());
4784 mesh_i->CreateGroupServants();
4786 if ( !myIsPreviewMode ) {
4787 pydump << mesh << " = " << this << ".RotateObjectMakeMesh( "
4788 << theObject << ", "
4790 << TVar( theAngleInRadians ) << ", "
4791 << theCopyGroups << ", '"
4792 << theMeshName << "' )";
4797 if (!myIsPreviewMode && mesh_i)
4798 mesh_i->GetGroups();
4800 return mesh._retn();
4802 SMESH_CATCH( SMESH::throwCorbaException );
4806 //=======================================================================
4809 //=======================================================================
4811 SMESH::ListOfGroups*
4812 SMESH_MeshEditor_i::scale(SMESH::SMESH_IDSource_ptr theObject,
4813 const SMESH::PointStruct& thePoint,
4814 const SMESH::double_array& theScaleFact,
4815 CORBA::Boolean theCopy,
4817 ::SMESH_Mesh* theTargetMesh)
4818 throw (SALOME::SALOME_Exception)
4822 if ( theScaleFact.length() < 1 )
4823 THROW_SALOME_CORBA_EXCEPTION("Scale factor not given", SALOME::BAD_PARAM);
4824 if ( theScaleFact.length() == 2 )
4825 THROW_SALOME_CORBA_EXCEPTION("Invalid nb of scale factors : 2", SALOME::BAD_PARAM);
4827 if ( theTargetMesh )
4830 TIDSortedElemSet elements;
4831 prepareIdSource( theObject );
4832 bool emptyIfIsMesh = myIsPreviewMode ? false : true;
4833 if ( !idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
4838 (theScaleFact.length() == 1) ? theScaleFact[0] : theScaleFact[1],
4839 (theScaleFact.length() == 1) ? theScaleFact[0] : theScaleFact[2],
4841 double tol = std::numeric_limits<double>::max();
4844 #if OCC_VERSION_LARGE > 0x06070100
4845 // fight against ortagonalization
4846 // aTrsf.SetValues( S[0], 0, 0, thePoint.x * (1-S[0]),
4847 // 0, S[1], 0, thePoint.y * (1-S[1]),
4848 // 0, 0, S[2], thePoint.z * (1-S[2]) );
4849 aTrsf.SetTranslation( gp_Vec( thePoint.x * (1-S[0]),
4850 thePoint.y * (1-S[1]),
4851 thePoint.z * (1-S[2])));
4852 gp_Mat & M = ( gp_Mat& ) aTrsf.HVectorialPart();
4853 M.SetDiagonal( S[0], S[1], S[2] );
4856 aTrsf.SetValues( S[0], 0, 0, thePoint.x * (1-S[0]),
4857 0, S[1], 0, thePoint.y * (1-S[1]),
4858 0, 0, S[2], thePoint.z * (1-S[2]), tol, tol);
4861 TIDSortedElemSet copyElements;
4862 TIDSortedElemSet* workElements = &elements;
4863 if ( myIsPreviewMode )
4865 TPreviewMesh * tmpMesh = getPreviewMesh();
4866 tmpMesh->Copy( elements, copyElements);
4867 if ( !theCopy && !theTargetMesh )
4869 TIDSortedElemSet elemsAround, elemsAroundCopy;
4870 getElementsAround( elements, getMeshDS(), elemsAround );
4871 tmpMesh->Copy( elemsAround, elemsAroundCopy);
4873 workElements = & copyElements;
4874 theMakeGroups = false;
4877 ::SMESH_MeshEditor::PGroupIDs groupIds =
4878 getEditor().Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
4880 if ( theCopy && !myIsPreviewMode )
4882 if ( theTargetMesh ) theTargetMesh->GetMeshDS()->Modified();
4883 else declareMeshModified( /*isReComputeSafe=*/false );
4885 return theMakeGroups ? getGroups(groupIds.get()) : 0;
4887 SMESH_CATCH( SMESH::throwCorbaException );
4891 //=======================================================================
4894 //=======================================================================
4896 void SMESH_MeshEditor_i::Scale(SMESH::SMESH_IDSource_ptr theObject,
4897 const SMESH::PointStruct& thePoint,
4898 const SMESH::double_array& theScaleFact,
4899 CORBA::Boolean theCopy)
4900 throw (SALOME::SALOME_Exception)
4902 if ( !myIsPreviewMode ) {
4903 TPythonDump() << this << ".Scale( "
4904 << theObject << ", "
4906 << TVar( theScaleFact ) << ", "
4909 scale(theObject, thePoint, theScaleFact, theCopy, false);
4913 //=======================================================================
4914 //function : ScaleMakeGroups
4916 //=======================================================================
4918 SMESH::ListOfGroups*
4919 SMESH_MeshEditor_i::ScaleMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
4920 const SMESH::PointStruct& thePoint,
4921 const SMESH::double_array& theScaleFact)
4922 throw (SALOME::SALOME_Exception)
4924 TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
4926 SMESH::ListOfGroups * aGroups = scale(theObject, thePoint, theScaleFact, true, true);
4927 if (!myIsPreviewMode) {
4928 dumpGroupsList(aPythonDump, aGroups);
4929 aPythonDump << this << ".Scale("
4932 << TVar( theScaleFact ) << ",True,True)";
4938 //=======================================================================
4939 //function : ScaleMakeMesh
4941 //=======================================================================
4943 SMESH::SMESH_Mesh_ptr
4944 SMESH_MeshEditor_i::ScaleMakeMesh(SMESH::SMESH_IDSource_ptr theObject,
4945 const SMESH::PointStruct& thePoint,
4946 const SMESH::double_array& theScaleFact,
4947 CORBA::Boolean theCopyGroups,
4948 const char* theMeshName)
4949 throw (SALOME::SALOME_Exception)
4951 SMESH_Mesh_i* mesh_i;
4952 SMESH::SMESH_Mesh_var mesh;
4953 { // open new scope to dump "MakeMesh" command
4954 // and then "GetGroups" using SMESH_Mesh::GetGroups()
4956 TPythonDump pydump; // to prevent dump at mesh creation
4957 mesh = makeMesh( theMeshName );
4958 mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
4962 scale(theObject, thePoint, theScaleFact,false, theCopyGroups, & mesh_i->GetImpl());
4963 mesh_i->CreateGroupServants();
4965 if ( !myIsPreviewMode )
4966 pydump << mesh << " = " << this << ".ScaleMakeMesh( "
4967 << theObject << ", "
4969 << TVar( theScaleFact ) << ", "
4970 << theCopyGroups << ", '"
4971 << theMeshName << "' )";
4975 if (!myIsPreviewMode && mesh_i)
4976 mesh_i->GetGroups();
4978 return mesh._retn();
4982 //=======================================================================
4983 //function : FindCoincidentNodes
4985 //=======================================================================
4987 void SMESH_MeshEditor_i::FindCoincidentNodes (CORBA::Double Tolerance,
4988 SMESH::array_of_long_array_out GroupsOfNodes)
4989 throw (SALOME::SALOME_Exception)
4994 ::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
4995 TIDSortedNodeSet nodes; // no input nodes
4996 getEditor().FindCoincidentNodes( nodes, Tolerance, aListOfListOfNodes );
4998 GroupsOfNodes = new SMESH::array_of_long_array;
4999 GroupsOfNodes->length( aListOfListOfNodes.size() );
5000 ::SMESH_MeshEditor::TListOfListOfNodes::iterator llIt = aListOfListOfNodes.begin();
5001 for ( CORBA::Long i = 0; llIt != aListOfListOfNodes.end(); llIt++, i++ ) {
5002 list< const SMDS_MeshNode* >& aListOfNodes = *llIt;
5003 list< const SMDS_MeshNode* >::iterator lIt = aListOfNodes.begin();;
5004 SMESH::long_array& aGroup = (*GroupsOfNodes)[ i ];
5005 aGroup.length( aListOfNodes.size() );
5006 for ( int j = 0; lIt != aListOfNodes.end(); lIt++, j++ )
5007 aGroup[ j ] = (*lIt)->GetID();
5009 TPythonDump() << "coincident_nodes = " << this << ".FindCoincidentNodes( "
5010 << Tolerance << " )";
5012 SMESH_CATCH( SMESH::throwCorbaException );
5015 //=======================================================================
5016 //function : FindCoincidentNodesOnPart
5018 //=======================================================================
5020 void SMESH_MeshEditor_i::FindCoincidentNodesOnPart(SMESH::SMESH_IDSource_ptr theObject,
5021 CORBA::Double Tolerance,
5022 SMESH::array_of_long_array_out GroupsOfNodes)
5023 throw (SALOME::SALOME_Exception)
5028 TIDSortedNodeSet nodes;
5029 prepareIdSource( theObject );
5030 idSourceToNodeSet( theObject, getMeshDS(), nodes );
5032 ::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
5034 getEditor().FindCoincidentNodes( nodes, Tolerance, aListOfListOfNodes );
5036 GroupsOfNodes = new SMESH::array_of_long_array;
5037 GroupsOfNodes->length( aListOfListOfNodes.size() );
5038 ::SMESH_MeshEditor::TListOfListOfNodes::iterator llIt = aListOfListOfNodes.begin();
5039 for ( CORBA::Long i = 0; llIt != aListOfListOfNodes.end(); llIt++, i++ )
5041 list< const SMDS_MeshNode* >& aListOfNodes = *llIt;
5042 list< const SMDS_MeshNode* >::iterator lIt = aListOfNodes.begin();;
5043 SMESH::long_array& aGroup = (*GroupsOfNodes)[ i ];
5044 aGroup.length( aListOfNodes.size() );
5045 for ( int j = 0; lIt != aListOfNodes.end(); lIt++, j++ )
5046 aGroup[ j ] = (*lIt)->GetID();
5048 TPythonDump() << "coincident_nodes_on_part = " << this << ".FindCoincidentNodesOnPart( "
5050 << Tolerance << " )";
5052 SMESH_CATCH( SMESH::throwCorbaException );
5055 //================================================================================
5057 * \brief Finds nodes coinsident with Tolerance within Object excluding nodes within
5058 * ExceptSubMeshOrGroups
5060 //================================================================================
5062 void SMESH_MeshEditor_i::
5063 FindCoincidentNodesOnPartBut(SMESH::SMESH_IDSource_ptr theObject,
5064 CORBA::Double theTolerance,
5065 SMESH::array_of_long_array_out theGroupsOfNodes,
5066 const SMESH::ListOfIDSources& theExceptSubMeshOrGroups)
5067 throw (SALOME::SALOME_Exception)
5072 TIDSortedNodeSet nodes;
5073 prepareIdSource( theObject );
5074 idSourceToNodeSet( theObject, getMeshDS(), nodes );
5076 for ( int i = 0; i < theExceptSubMeshOrGroups.length(); ++i )
5078 TIDSortedNodeSet exceptNodes;
5079 idSourceToNodeSet( theExceptSubMeshOrGroups[i], getMeshDS(), exceptNodes );
5080 TIDSortedNodeSet::iterator avoidNode = exceptNodes.begin();
5081 for ( ; avoidNode != exceptNodes.end(); ++avoidNode)
5082 nodes.erase( *avoidNode );
5084 ::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
5086 getEditor().FindCoincidentNodes( nodes, theTolerance, aListOfListOfNodes );
5088 theGroupsOfNodes = new SMESH::array_of_long_array;
5089 theGroupsOfNodes->length( aListOfListOfNodes.size() );
5090 ::SMESH_MeshEditor::TListOfListOfNodes::iterator llIt = aListOfListOfNodes.begin();
5091 for ( CORBA::Long i = 0; llIt != aListOfListOfNodes.end(); llIt++, i++ )
5093 list< const SMDS_MeshNode* >& aListOfNodes = *llIt;
5094 list< const SMDS_MeshNode* >::iterator lIt = aListOfNodes.begin();;
5095 SMESH::long_array& aGroup = (*theGroupsOfNodes)[ i ];
5096 aGroup.length( aListOfNodes.size() );
5097 for ( int j = 0; lIt != aListOfNodes.end(); lIt++, j++ )
5098 aGroup[ j ] = (*lIt)->GetID();
5100 TPythonDump() << "coincident_nodes_on_part = " << this << ".FindCoincidentNodesOnPartBut( "
5102 << theTolerance << ", "
5103 << theExceptSubMeshOrGroups << " )";
5105 SMESH_CATCH( SMESH::throwCorbaException );
5108 //=======================================================================
5109 //function : MergeNodes
5111 //=======================================================================
5113 void SMESH_MeshEditor_i::MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes)
5114 throw (SALOME::SALOME_Exception)
5119 SMESHDS_Mesh* aMesh = getMeshDS();
5121 TPythonDump aTPythonDump;
5122 aTPythonDump << this << ".MergeNodes([";
5123 ::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
5124 for (int i = 0; i < GroupsOfNodes.length(); i++)
5126 const SMESH::long_array& aNodeGroup = GroupsOfNodes[ i ];
5127 aListOfListOfNodes.push_back( list< const SMDS_MeshNode* >() );
5128 list< const SMDS_MeshNode* >& aListOfNodes = aListOfListOfNodes.back();
5129 for ( int j = 0; j < aNodeGroup.length(); j++ )
5131 CORBA::Long index = aNodeGroup[ j ];
5132 const SMDS_MeshNode * node = aMesh->FindNode(index);
5134 aListOfNodes.push_back( node );
5136 if ( aListOfNodes.size() < 2 )
5137 aListOfListOfNodes.pop_back();
5139 if ( i > 0 ) aTPythonDump << ", ";
5140 aTPythonDump << aNodeGroup;
5142 getEditor().MergeNodes( aListOfListOfNodes );
5144 aTPythonDump << "])";
5146 declareMeshModified( /*isReComputeSafe=*/false );
5148 SMESH_CATCH( SMESH::throwCorbaException );
5151 //=======================================================================
5152 //function : FindEqualElements
5154 //=======================================================================
5156 void SMESH_MeshEditor_i::FindEqualElements(SMESH::SMESH_IDSource_ptr theObject,
5157 SMESH::array_of_long_array_out GroupsOfElementsID)
5158 throw (SALOME::SALOME_Exception)
5163 SMESH::SMESH_GroupBase_var group = SMESH::SMESH_GroupBase::_narrow(theObject);
5164 if ( !(!group->_is_nil() && group->GetType() == SMESH::NODE) )
5166 TIDSortedElemSet elems;
5167 prepareIdSource( theObject );
5168 idSourceToSet( theObject, getMeshDS(), elems, SMDSAbs_All, /*emptyIfIsMesh=*/true);
5170 ::SMESH_MeshEditor::TListOfListOfElementsID aListOfListOfElementsID;
5171 getEditor().FindEqualElements( elems, aListOfListOfElementsID );
5173 GroupsOfElementsID = new SMESH::array_of_long_array;
5174 GroupsOfElementsID->length( aListOfListOfElementsID.size() );
5176 ::SMESH_MeshEditor::TListOfListOfElementsID::iterator arraysIt =
5177 aListOfListOfElementsID.begin();
5178 for (CORBA::Long j = 0; arraysIt != aListOfListOfElementsID.end(); ++arraysIt, ++j)
5180 SMESH::long_array& aGroup = (*GroupsOfElementsID)[ j ];
5181 list<int>& listOfIDs = *arraysIt;
5182 aGroup.length( listOfIDs.size() );
5183 list<int>::iterator idIt = listOfIDs.begin();
5184 for (int k = 0; idIt != listOfIDs.end(); ++idIt, ++k )
5185 aGroup[ k ] = *idIt;
5188 TPythonDump() << "equal_elements = " << this << ".FindEqualElements( "
5192 SMESH_CATCH( SMESH::throwCorbaException );
5195 //=======================================================================
5196 //function : MergeElements
5198 //=======================================================================
5200 void SMESH_MeshEditor_i::MergeElements(const SMESH::array_of_long_array& GroupsOfElementsID)
5201 throw (SALOME::SALOME_Exception)
5206 TPythonDump aTPythonDump;
5207 aTPythonDump << this << ".MergeElements( [";
5209 ::SMESH_MeshEditor::TListOfListOfElementsID aListOfListOfElementsID;
5211 for (int i = 0; i < GroupsOfElementsID.length(); i++) {
5212 const SMESH::long_array& anElemsIDGroup = GroupsOfElementsID[ i ];
5213 aListOfListOfElementsID.push_back( list< int >() );
5214 list< int >& aListOfElemsID = aListOfListOfElementsID.back();
5215 for ( int j = 0; j < anElemsIDGroup.length(); j++ ) {
5216 CORBA::Long id = anElemsIDGroup[ j ];
5217 aListOfElemsID.push_back( id );
5219 if ( aListOfElemsID.size() < 2 )
5220 aListOfListOfElementsID.pop_back();
5221 if ( i > 0 ) aTPythonDump << ", ";
5222 aTPythonDump << anElemsIDGroup;
5225 getEditor().MergeElements(aListOfListOfElementsID);
5227 declareMeshModified( /*isReComputeSafe=*/true );
5229 aTPythonDump << "] )";
5231 SMESH_CATCH( SMESH::throwCorbaException );
5234 //=======================================================================
5235 //function : MergeEqualElements
5237 //=======================================================================
5239 void SMESH_MeshEditor_i::MergeEqualElements()
5240 throw (SALOME::SALOME_Exception)
5245 getEditor().MergeEqualElements();
5247 declareMeshModified( /*isReComputeSafe=*/true );
5249 TPythonDump() << this << ".MergeEqualElements()";
5251 SMESH_CATCH( SMESH::throwCorbaException );
5254 //=============================================================================
5256 * Move the node to a given point
5258 //=============================================================================
5260 CORBA::Boolean SMESH_MeshEditor_i::MoveNode(CORBA::Long NodeID,
5264 throw (SALOME::SALOME_Exception)
5267 initData(/*deleteSearchers=*/false);
5269 const SMDS_MeshNode * node = getMeshDS()->FindNode( NodeID );
5273 if ( theNodeSearcher )
5274 theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other
5276 if ( myIsPreviewMode ) // make preview data
5278 // in a preview mesh, make edges linked to a node
5279 TPreviewMesh& tmpMesh = *getPreviewMesh();
5280 TIDSortedElemSet linkedNodes;
5281 ::SMESH_MeshEditor::GetLinkedNodes( node, linkedNodes );
5282 TIDSortedElemSet::iterator nIt = linkedNodes.begin();
5283 SMDS_MeshNode *nodeCpy1 = tmpMesh.Copy(node);
5284 for ( ; nIt != linkedNodes.end(); ++nIt )
5286 SMDS_MeshNode *nodeCpy2 = tmpMesh.Copy ( cast2Node( *nIt ));
5287 tmpMesh.GetMeshDS()->AddEdge(nodeCpy1, nodeCpy2);
5291 tmpMesh.GetMeshDS()->MoveNode(nodeCpy1, x, y, z);
5292 // fill preview data
5294 else if ( theNodeSearcher ) // move node and update theNodeSearcher data accordingly
5295 theNodeSearcher->MoveNode(node, gp_Pnt( x,y,z ));
5297 getMeshDS()->MoveNode(node, x, y, z);
5299 if ( !myIsPreviewMode )
5301 // Update Python script
5302 TPythonDump() << "isDone = " << this << ".MoveNode( "
5303 << NodeID << ", " << TVar(x) << ", " << TVar(y) << ", " << TVar(z) << " )";
5304 declareMeshModified( /*isReComputeSafe=*/false );
5307 SMESH_CATCH( SMESH::throwCorbaException );
5312 //================================================================================
5314 * \brief Return ID of node closest to a given point
5316 //================================================================================
5318 CORBA::Long SMESH_MeshEditor_i::FindNodeClosestTo(CORBA::Double x,
5321 throw (SALOME::SALOME_Exception)
5324 theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other
5326 if ( !theNodeSearcher ) {
5327 theNodeSearcher = SMESH_MeshAlgos::GetNodeSearcher( *getMeshDS() );
5330 if ( const SMDS_MeshNode* node = theNodeSearcher->FindClosestTo( p ))
5331 return node->GetID();
5333 SMESH_CATCH( SMESH::throwCorbaException );
5337 //================================================================================
5339 * \brief If the given ID is a valid node ID (nodeID > 0), just move this node, else
5340 * move the node closest to the point to point's location and return ID of the node
5342 //================================================================================
5344 CORBA::Long SMESH_MeshEditor_i::MoveClosestNodeToPoint(CORBA::Double x,
5347 CORBA::Long theNodeID)
5348 throw (SALOME::SALOME_Exception)
5351 // We keep theNodeSearcher until any mesh modification:
5352 // 1) initData() deletes theNodeSearcher at any edition,
5353 // 2) TSearchersDeleter - at any mesh compute event and mesh change
5355 initData(/*deleteSearchers=*/false);
5357 theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other
5359 int nodeID = theNodeID;
5360 const SMDS_MeshNode* node = getMeshDS()->FindNode( nodeID );
5361 if ( !node ) // preview moving node
5363 if ( !theNodeSearcher ) {
5364 theNodeSearcher = SMESH_MeshAlgos::GetNodeSearcher( *getMeshDS() );
5367 node = theNodeSearcher->FindClosestTo( p );
5370 nodeID = node->GetID();
5371 if ( myIsPreviewMode ) // make preview data
5373 // in a preview mesh, make edges linked to a node
5374 TPreviewMesh tmpMesh = *getPreviewMesh();
5375 TIDSortedElemSet linkedNodes;
5376 ::SMESH_MeshEditor::GetLinkedNodes( node, linkedNodes );
5377 TIDSortedElemSet::iterator nIt = linkedNodes.begin();
5378 for ( ; nIt != linkedNodes.end(); ++nIt )
5380 SMDS_LinearEdge edge( node, cast2Node( *nIt ));
5381 tmpMesh.Copy( &edge );
5384 node = tmpMesh.GetMeshDS()->FindNode( nodeID );
5386 tmpMesh.GetMeshDS()->MoveNode(node, x, y, z);
5387 // fill preview data
5389 else if ( theNodeSearcher ) // move node and update theNodeSearcher data accordingly
5391 theNodeSearcher->MoveNode(node, gp_Pnt( x,y,z ));
5395 getMeshDS()->MoveNode(node, x, y, z);
5399 if ( !myIsPreviewMode )
5401 TPythonDump() << "nodeID = " << this
5402 << ".MoveClosestNodeToPoint( "<< x << ", " << y << ", " << z
5403 << ", " << nodeID << " )";
5405 declareMeshModified( /*isReComputeSafe=*/false );
5410 SMESH_CATCH( SMESH::throwCorbaException );
5414 //=======================================================================
5416 * Return elements of given type where the given point is IN or ON.
5418 * 'ALL' type means elements of any type excluding nodes
5420 //=======================================================================
5422 SMESH::long_array* SMESH_MeshEditor_i::FindElementsByPoint(CORBA::Double x,
5425 SMESH::ElementType type)
5426 throw (SALOME::SALOME_Exception)
5429 SMESH::long_array_var res = new SMESH::long_array;
5430 vector< const SMDS_MeshElement* > foundElems;
5432 theSearchersDeleter.Set( myMesh );
5433 if ( !theElementSearcher ) {
5434 theElementSearcher = SMESH_MeshAlgos::GetElementSearcher( *getMeshDS() );
5436 theElementSearcher->FindElementsByPoint( gp_Pnt( x,y,z ),
5437 SMDSAbs_ElementType( type ),
5439 res->length( foundElems.size() );
5440 for ( int i = 0; i < foundElems.size(); ++i )
5441 res[i] = foundElems[i]->GetID();
5445 SMESH_CATCH( SMESH::throwCorbaException );
5449 //=======================================================================
5450 //function : FindAmongElementsByPoint
5451 //purpose : Searching among the given elements, return elements of given type
5452 // where the given point is IN or ON.
5453 // 'ALL' type means elements of any type excluding nodes
5454 //=======================================================================
5457 SMESH_MeshEditor_i::FindAmongElementsByPoint(SMESH::SMESH_IDSource_ptr elementIDs,
5461 SMESH::ElementType type)
5462 throw (SALOME::SALOME_Exception)
5465 SMESH::long_array_var res = new SMESH::long_array;
5467 SMESH::array_of_ElementType_var types = elementIDs->GetTypes();
5468 if ( types->length() == 1 && // a part contains only nodes or 0D elements
5469 ( types[0] == SMESH::NODE || types[0] == SMESH::ELEM0D || types[0] == SMESH::BALL) &&
5470 type != types[0] ) // but search of elements of dim > 0
5473 if ( SMESH::DownCast<SMESH_Mesh_i*>( elementIDs )) // elementIDs is the whole mesh
5474 return FindElementsByPoint( x,y,z, type );
5476 TIDSortedElemSet elements; // elems should live until FindElementsByPoint() finishes
5478 theSearchersDeleter.Set( myMesh, getPartIOR( elementIDs, type ));
5479 if ( !theElementSearcher )
5481 // create a searcher from elementIDs
5482 SMESH::SMESH_Mesh_var mesh = elementIDs->GetMesh();
5483 SMESHDS_Mesh* meshDS = SMESH::DownCast<SMESH_Mesh_i*>( mesh )->GetImpl().GetMeshDS();
5485 if ( !idSourceToSet( elementIDs, meshDS, elements,
5486 SMDSAbs_ElementType(type), /*emptyIfIsMesh=*/true))
5489 typedef SMDS_SetIterator<const SMDS_MeshElement*, TIDSortedElemSet::const_iterator > TIter;
5490 SMDS_ElemIteratorPtr elemsIt( new TIter( elements.begin(), elements.end() ));
5492 theElementSearcher = SMESH_MeshAlgos::GetElementSearcher( *getMeshDS(), elemsIt );
5495 vector< const SMDS_MeshElement* > foundElems;
5497 theElementSearcher->FindElementsByPoint( gp_Pnt( x,y,z ),
5498 SMDSAbs_ElementType( type ),
5500 res->length( foundElems.size() );
5501 for ( int i = 0; i < foundElems.size(); ++i )
5502 res[i] = foundElems[i]->GetID();
5506 SMESH_CATCH( SMESH::throwCorbaException );
5510 //=======================================================================
5511 //function : GetPointState
5512 //purpose : Return point state in a closed 2D mesh in terms of TopAbs_State enumeration.
5513 // TopAbs_UNKNOWN state means that either mesh is wrong or the analysis fails.
5514 //=======================================================================
5516 CORBA::Short SMESH_MeshEditor_i::GetPointState(CORBA::Double x,
5519 throw (SALOME::SALOME_Exception)
5522 theSearchersDeleter.Set( myMesh );
5523 if ( !theElementSearcher ) {
5524 theElementSearcher = SMESH_MeshAlgos::GetElementSearcher( *getMeshDS() );
5526 return CORBA::Short( theElementSearcher->GetPointState( gp_Pnt( x,y,z )));
5528 SMESH_CATCH( SMESH::throwCorbaException );
5532 //=======================================================================
5533 //function : convError
5535 //=======================================================================
5537 #define RETCASE(enm) case ::SMESH_MeshEditor::enm: return SMESH::SMESH_MeshEditor::enm;
5539 static SMESH::SMESH_MeshEditor::Sew_Error convError( const::SMESH_MeshEditor::Sew_Error e )
5543 RETCASE( SEW_BORDER1_NOT_FOUND );
5544 RETCASE( SEW_BORDER2_NOT_FOUND );
5545 RETCASE( SEW_BOTH_BORDERS_NOT_FOUND );
5546 RETCASE( SEW_BAD_SIDE_NODES );
5547 RETCASE( SEW_VOLUMES_TO_SPLIT );
5548 RETCASE( SEW_DIFF_NB_OF_ELEMENTS );
5549 RETCASE( SEW_TOPO_DIFF_SETS_OF_ELEMENTS );
5550 RETCASE( SEW_BAD_SIDE1_NODES );
5551 RETCASE( SEW_BAD_SIDE2_NODES );
5553 return SMESH::SMESH_MeshEditor::SEW_OK;
5556 //=======================================================================
5557 //function : SewFreeBorders
5559 //=======================================================================
5561 SMESH::SMESH_MeshEditor::Sew_Error
5562 SMESH_MeshEditor_i::SewFreeBorders(CORBA::Long FirstNodeID1,
5563 CORBA::Long SecondNodeID1,
5564 CORBA::Long LastNodeID1,
5565 CORBA::Long FirstNodeID2,
5566 CORBA::Long SecondNodeID2,
5567 CORBA::Long LastNodeID2,
5568 CORBA::Boolean CreatePolygons,
5569 CORBA::Boolean CreatePolyedrs)
5570 throw (SALOME::SALOME_Exception)
5575 SMESHDS_Mesh* aMesh = getMeshDS();
5577 const SMDS_MeshNode* aBorderFirstNode = aMesh->FindNode( FirstNodeID1 );
5578 const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeID1 );
5579 const SMDS_MeshNode* aBorderLastNode = aMesh->FindNode( LastNodeID1 );
5580 const SMDS_MeshNode* aSide2FirstNode = aMesh->FindNode( FirstNodeID2 );
5581 const SMDS_MeshNode* aSide2SecondNode = aMesh->FindNode( SecondNodeID2 );
5582 const SMDS_MeshNode* aSide2ThirdNode = aMesh->FindNode( LastNodeID2 );
5584 if (!aBorderFirstNode ||
5585 !aBorderSecondNode||
5587 return SMESH::SMESH_MeshEditor::SEW_BORDER1_NOT_FOUND;
5588 if (!aSide2FirstNode ||
5589 !aSide2SecondNode ||
5591 return SMESH::SMESH_MeshEditor::SEW_BORDER2_NOT_FOUND;
5593 TPythonDump() << "error = " << this << ".SewFreeBorders( "
5594 << FirstNodeID1 << ", "
5595 << SecondNodeID1 << ", "
5596 << LastNodeID1 << ", "
5597 << FirstNodeID2 << ", "
5598 << SecondNodeID2 << ", "
5599 << LastNodeID2 << ", "
5600 << CreatePolygons<< ", "
5601 << CreatePolyedrs<< " )";
5603 SMESH::SMESH_MeshEditor::Sew_Error error =
5604 convError( getEditor().SewFreeBorder (aBorderFirstNode,
5615 declareMeshModified( /*isReComputeSafe=*/false );
5618 SMESH_CATCH( SMESH::throwCorbaException );
5619 return SMESH::SMESH_MeshEditor::Sew_Error(0);
5623 //=======================================================================
5624 //function : SewConformFreeBorders
5626 //=======================================================================
5628 SMESH::SMESH_MeshEditor::Sew_Error
5629 SMESH_MeshEditor_i::SewConformFreeBorders(CORBA::Long FirstNodeID1,
5630 CORBA::Long SecondNodeID1,
5631 CORBA::Long LastNodeID1,
5632 CORBA::Long FirstNodeID2,
5633 CORBA::Long SecondNodeID2)
5634 throw (SALOME::SALOME_Exception)
5639 SMESHDS_Mesh* aMesh = getMeshDS();
5641 const SMDS_MeshNode* aBorderFirstNode = aMesh->FindNode( FirstNodeID1 );
5642 const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeID1 );
5643 const SMDS_MeshNode* aBorderLastNode = aMesh->FindNode( LastNodeID1 );
5644 const SMDS_MeshNode* aSide2FirstNode = aMesh->FindNode( FirstNodeID2 );
5645 const SMDS_MeshNode* aSide2SecondNode = aMesh->FindNode( SecondNodeID2 );
5646 const SMDS_MeshNode* aSide2ThirdNode = 0;
5648 if (!aBorderFirstNode ||
5649 !aBorderSecondNode||
5651 return SMESH::SMESH_MeshEditor::SEW_BORDER1_NOT_FOUND;
5652 if (!aSide2FirstNode ||
5654 return SMESH::SMESH_MeshEditor::SEW_BORDER2_NOT_FOUND;
5656 TPythonDump() << "error = " << this << ".SewConformFreeBorders( "
5657 << FirstNodeID1 << ", "
5658 << SecondNodeID1 << ", "
5659 << LastNodeID1 << ", "
5660 << FirstNodeID2 << ", "
5661 << SecondNodeID2 << " )";
5663 SMESH::SMESH_MeshEditor::Sew_Error error =
5664 convError( getEditor().SewFreeBorder (aBorderFirstNode,
5673 declareMeshModified( /*isReComputeSafe=*/false );
5676 SMESH_CATCH( SMESH::throwCorbaException );
5677 return SMESH::SMESH_MeshEditor::Sew_Error(0);
5681 //=======================================================================
5682 //function : SewBorderToSide
5684 //=======================================================================
5686 SMESH::SMESH_MeshEditor::Sew_Error
5687 SMESH_MeshEditor_i::SewBorderToSide(CORBA::Long FirstNodeIDOnFreeBorder,
5688 CORBA::Long SecondNodeIDOnFreeBorder,
5689 CORBA::Long LastNodeIDOnFreeBorder,
5690 CORBA::Long FirstNodeIDOnSide,
5691 CORBA::Long LastNodeIDOnSide,
5692 CORBA::Boolean CreatePolygons,
5693 CORBA::Boolean CreatePolyedrs)
5694 throw (SALOME::SALOME_Exception)
5699 SMESHDS_Mesh* aMesh = getMeshDS();
5701 const SMDS_MeshNode* aBorderFirstNode = aMesh->FindNode( FirstNodeIDOnFreeBorder );
5702 const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeIDOnFreeBorder );
5703 const SMDS_MeshNode* aBorderLastNode = aMesh->FindNode( LastNodeIDOnFreeBorder );
5704 const SMDS_MeshNode* aSide2FirstNode = aMesh->FindNode( FirstNodeIDOnSide );
5705 const SMDS_MeshNode* aSide2SecondNode = aMesh->FindNode( LastNodeIDOnSide );
5706 const SMDS_MeshNode* aSide2ThirdNode = 0;
5708 if (!aBorderFirstNode ||
5709 !aBorderSecondNode||
5711 return SMESH::SMESH_MeshEditor::SEW_BORDER1_NOT_FOUND;
5712 if (!aSide2FirstNode ||
5714 return SMESH::SMESH_MeshEditor::SEW_BAD_SIDE_NODES;
5716 TPythonDump() << "error = " << this << ".SewBorderToSide( "
5717 << FirstNodeIDOnFreeBorder << ", "
5718 << SecondNodeIDOnFreeBorder << ", "
5719 << LastNodeIDOnFreeBorder << ", "
5720 << FirstNodeIDOnSide << ", "
5721 << LastNodeIDOnSide << ", "
5722 << CreatePolygons << ", "
5723 << CreatePolyedrs << ") ";
5725 SMESH::SMESH_MeshEditor::Sew_Error error =
5726 convError( getEditor().SewFreeBorder (aBorderFirstNode,
5736 declareMeshModified( /*isReComputeSafe=*/false );
5739 SMESH_CATCH( SMESH::throwCorbaException );
5740 return SMESH::SMESH_MeshEditor::Sew_Error(0);
5744 //=======================================================================
5745 //function : SewSideElements
5747 //=======================================================================
5749 SMESH::SMESH_MeshEditor::Sew_Error
5750 SMESH_MeshEditor_i::SewSideElements(const SMESH::long_array& IDsOfSide1Elements,
5751 const SMESH::long_array& IDsOfSide2Elements,
5752 CORBA::Long NodeID1OfSide1ToMerge,
5753 CORBA::Long NodeID1OfSide2ToMerge,
5754 CORBA::Long NodeID2OfSide1ToMerge,
5755 CORBA::Long NodeID2OfSide2ToMerge)
5756 throw (SALOME::SALOME_Exception)
5761 SMESHDS_Mesh* aMesh = getMeshDS();
5763 const SMDS_MeshNode* aFirstNode1ToMerge = aMesh->FindNode( NodeID1OfSide1ToMerge );
5764 const SMDS_MeshNode* aFirstNode2ToMerge = aMesh->FindNode( NodeID1OfSide2ToMerge );
5765 const SMDS_MeshNode* aSecondNode1ToMerge = aMesh->FindNode( NodeID2OfSide1ToMerge );
5766 const SMDS_MeshNode* aSecondNode2ToMerge = aMesh->FindNode( NodeID2OfSide2ToMerge );
5768 if (!aFirstNode1ToMerge ||
5769 !aFirstNode2ToMerge )
5770 return SMESH::SMESH_MeshEditor::SEW_BAD_SIDE1_NODES;
5771 if (!aSecondNode1ToMerge||
5772 !aSecondNode2ToMerge)
5773 return SMESH::SMESH_MeshEditor::SEW_BAD_SIDE2_NODES;
5775 TIDSortedElemSet aSide1Elems, aSide2Elems;
5776 arrayToSet(IDsOfSide1Elements, aMesh, aSide1Elems);
5777 arrayToSet(IDsOfSide2Elements, aMesh, aSide2Elems);
5779 TPythonDump() << "error = " << this << ".SewSideElements( "
5780 << IDsOfSide1Elements << ", "
5781 << IDsOfSide2Elements << ", "
5782 << NodeID1OfSide1ToMerge << ", "
5783 << NodeID1OfSide2ToMerge << ", "
5784 << NodeID2OfSide1ToMerge << ", "
5785 << NodeID2OfSide2ToMerge << ")";
5787 SMESH::SMESH_MeshEditor::Sew_Error error =
5788 convError( getEditor().SewSideElements (aSide1Elems, aSide2Elems,
5791 aSecondNode1ToMerge,
5792 aSecondNode2ToMerge));
5794 declareMeshModified( /*isReComputeSafe=*/false );
5797 SMESH_CATCH( SMESH::throwCorbaException );
5798 return SMESH::SMESH_MeshEditor::Sew_Error(0);
5801 //================================================================================
5803 * \brief Set new nodes for given element
5804 * \param ide - element id
5805 * \param newIDs - new node ids
5806 * \retval CORBA::Boolean - true if result is OK
5808 //================================================================================
5810 CORBA::Boolean SMESH_MeshEditor_i::ChangeElemNodes(CORBA::Long ide,
5811 const SMESH::long_array& newIDs)
5812 throw (SALOME::SALOME_Exception)
5817 const SMDS_MeshElement* elem = getMeshDS()->FindElement(ide);
5818 if(!elem) return false;
5820 int nbn = newIDs.length();
5822 vector<const SMDS_MeshNode*> aNodes(nbn);
5825 const SMDS_MeshNode* aNode = getMeshDS()->FindNode(newIDs[i]);
5828 aNodes[nbn1] = aNode;
5831 TPythonDump() << "isDone = " << this << ".ChangeElemNodes( "
5832 << ide << ", " << newIDs << " )";
5834 MESSAGE("ChangeElementNodes");
5835 bool res = getMeshDS()->ChangeElementNodes( elem, & aNodes[0], nbn1+1 );
5837 declareMeshModified( /*isReComputeSafe=*/ !res );
5841 SMESH_CATCH( SMESH::throwCorbaException );
5845 //=======================================================================
5847 * \brief Makes a part of the mesh quadratic or bi-quadratic
5849 //=======================================================================
5851 void SMESH_MeshEditor_i::convertToQuadratic(CORBA::Boolean theForce3d,
5852 CORBA::Boolean theToBiQuad,
5853 SMESH::SMESH_IDSource_ptr theObject)
5854 throw (SALOME::SALOME_Exception)
5857 TIDSortedElemSet elems;
5859 if ( !( elemsOK = CORBA::is_nil( theObject )))
5861 prepareIdSource( theObject );
5862 elemsOK = idSourceToSet( theObject, getMeshDS(), elems,
5863 SMDSAbs_All, /*emptyIfIsMesh=*/true );
5867 if ( !elems.empty() && (*elems.begin())->GetType() == SMDSAbs_Node )
5868 THROW_SALOME_CORBA_EXCEPTION("Group of nodes is not allowed", SALOME::BAD_PARAM);
5870 if ( elems.empty() ) getEditor().ConvertToQuadratic(theForce3d, theToBiQuad);
5871 else getEditor().ConvertToQuadratic(theForce3d, elems, theToBiQuad);
5873 declareMeshModified( /*isReComputeSafe=*/false );
5876 SMESH_CATCH( SMESH::throwCorbaException );
5879 //=======================================================================
5880 //function : ConvertFromQuadratic
5882 //=======================================================================
5884 CORBA::Boolean SMESH_MeshEditor_i::ConvertFromQuadratic()
5885 throw (SALOME::SALOME_Exception)
5887 CORBA::Boolean isDone = getEditor().ConvertFromQuadratic();
5888 TPythonDump() << this << ".ConvertFromQuadratic()";
5889 declareMeshModified( /*isReComputeSafe=*/!isDone );
5893 //=======================================================================
5894 //function : ConvertToQuadratic
5896 //=======================================================================
5898 void SMESH_MeshEditor_i::ConvertToQuadratic(CORBA::Boolean theForce3d)
5899 throw (SALOME::SALOME_Exception)
5901 convertToQuadratic( theForce3d, false );
5902 TPythonDump() << this << ".ConvertToQuadratic("<<theForce3d<<")";
5905 //================================================================================
5907 * \brief Makes a part of the mesh quadratic
5909 //================================================================================
5911 void SMESH_MeshEditor_i::ConvertToQuadraticObject(CORBA::Boolean theForce3d,
5912 SMESH::SMESH_IDSource_ptr theObject)
5913 throw (SALOME::SALOME_Exception)
5915 convertToQuadratic( theForce3d, false, theObject );
5916 TPythonDump() << this << ".ConvertToQuadraticObject("<<theForce3d<<", "<<theObject<<")";
5919 //================================================================================
5921 * \brief Makes a part of the mesh bi-quadratic
5923 //================================================================================
5925 void SMESH_MeshEditor_i::ConvertToBiQuadratic(CORBA::Boolean theForce3d,
5926 SMESH::SMESH_IDSource_ptr theObject)
5927 throw (SALOME::SALOME_Exception)
5929 convertToQuadratic( theForce3d, true, theObject );
5930 TPythonDump() << this << ".ConvertToBiQuadratic("<<theForce3d<<", "<<theObject<<")";
5933 //================================================================================
5935 * \brief Makes a part of the mesh linear
5937 //================================================================================
5939 void SMESH_MeshEditor_i::ConvertFromQuadraticObject(SMESH::SMESH_IDSource_ptr theObject)
5940 throw (SALOME::SALOME_Exception)
5946 TIDSortedElemSet elems;
5947 prepareIdSource( theObject );
5948 if ( idSourceToSet( theObject, getMeshDS(), elems, SMDSAbs_All, /*emptyIfIsMesh=*/true ))
5950 if ( elems.empty() )
5952 ConvertFromQuadratic();
5954 else if ( (*elems.begin())->GetType() == SMDSAbs_Node )
5956 THROW_SALOME_CORBA_EXCEPTION("Group of nodes is not allowed", SALOME::BAD_PARAM);
5960 getEditor().ConvertFromQuadratic(elems);
5963 declareMeshModified( /*isReComputeSafe=*/false );
5965 pyDump << this << ".ConvertFromQuadraticObject( "<<theObject<<" )";
5967 SMESH_CATCH( SMESH::throwCorbaException );
5970 //=======================================================================
5971 //function : makeMesh
5972 //purpose : create a named imported mesh
5973 //=======================================================================
5975 SMESH::SMESH_Mesh_ptr SMESH_MeshEditor_i::makeMesh(const char* theMeshName)
5977 SMESH_Gen_i* gen = SMESH_Gen_i::GetSMESHGen();
5978 SMESH::SMESH_Mesh_var mesh = gen->CreateEmptyMesh();
5979 SALOMEDS::Study_var study = gen->GetCurrentStudy();
5980 SALOMEDS::SObject_wrap meshSO = gen->ObjectToSObject( study, mesh );
5981 gen->SetName( meshSO, theMeshName, "Mesh" );
5982 gen->SetPixMap( meshSO, "ICON_SMESH_TREE_MESH_IMPORTED");
5984 return mesh._retn();
5987 //=======================================================================
5988 //function : dumpGroupsList
5990 //=======================================================================
5992 void SMESH_MeshEditor_i::dumpGroupsList(TPythonDump & theDumpPython,
5993 const SMESH::ListOfGroups * theGroupList)
5995 bool isDumpGroupList = ( theGroupList && theGroupList->length() > 0 );
5996 if ( isDumpGroupList )
5997 theDumpPython << theGroupList << " = ";
6000 //================================================================================
6002 \brief Generates the unique group name.
6003 \param thePrefix name prefix
6006 //================================================================================
6008 string SMESH_MeshEditor_i::generateGroupName(const string& thePrefix)
6010 SMESH::ListOfGroups_var groups = myMesh_i->GetGroups();
6011 set<string> groupNames;
6013 // Get existing group names
6014 for (int i = 0, nbGroups = groups->length(); i < nbGroups; i++ ) {
6015 SMESH::SMESH_GroupBase_var aGroup = groups[i];
6016 if (CORBA::is_nil(aGroup))
6019 CORBA::String_var name = aGroup->GetName();
6020 groupNames.insert( name.in() );
6024 string name = thePrefix;
6027 while (!groupNames.insert(name).second)
6028 name = SMESH_Comment( thePrefix ) << "_" << index++;
6033 //================================================================================
6035 * \brief Prepare SMESH_IDSource for work
6037 //================================================================================
6039 void SMESH_MeshEditor_i::prepareIdSource(SMESH::SMESH_IDSource_ptr theObject)
6041 if ( SMESH::Filter_i* filter = SMESH::DownCast<SMESH::Filter_i*>( theObject ))
6043 SMESH::SMESH_Mesh_var mesh = myMesh_i->_this();
6044 filter->SetMesh( mesh );
6048 //================================================================================
6050 * \brief Duplicates given elements, i.e. creates new elements based on the
6051 * same nodes as the given ones.
6052 * \param theElements - container of elements to duplicate.
6053 * \param theGroupName - a name of group to contain the generated elements.
6054 * If a group with such a name already exists, the new elements
6055 * are added to the existng group, else a new group is created.
6056 * If \a theGroupName is empty, new elements are not added
6058 * \return a group where the new elements are added. NULL if theGroupName == "".
6061 //================================================================================
6063 SMESH::SMESH_Group_ptr
6064 SMESH_MeshEditor_i::DoubleElements(SMESH::SMESH_IDSource_ptr theElements,
6065 const char* theGroupName)
6066 throw (SALOME::SALOME_Exception)
6068 SMESH::SMESH_Group_var newGroup;
6075 TIDSortedElemSet elems;
6076 prepareIdSource( theElements );
6077 if ( idSourceToSet( theElements, getMeshDS(), elems, SMDSAbs_All, /*emptyIfIsMesh=*/true))
6079 getEditor().DoubleElements( elems );
6081 if ( strlen( theGroupName ) && !getEditor().GetLastCreatedElems().IsEmpty() )
6084 SMESH::ElementType type =
6085 SMESH::ElementType( getEditor().GetLastCreatedElems().Value(1)->GetType() );
6086 // find existing group
6087 SMESH::ListOfGroups_var groups = myMesh_i->GetGroups();
6088 for ( size_t i = 0; i < groups->length(); ++i )
6089 if ( groups[i]->GetType() == type )
6091 CORBA::String_var name = groups[i]->GetName();
6092 if ( strcmp( name, theGroupName ) == 0 ) {
6093 newGroup = SMESH::SMESH_Group::_narrow( groups[i] );
6097 // create a new group
6098 if ( newGroup->_is_nil() )
6099 newGroup = myMesh_i->CreateGroup( type, theGroupName );
6101 if ( SMESH_Group_i* group_i = SMESH::DownCast< SMESH_Group_i* >( newGroup ))
6103 SMESHDS_Group* groupDS = static_cast< SMESHDS_Group* >( group_i->GetGroupDS() );
6104 const SMESH_SequenceOfElemPtr& aSeq = getEditor().GetLastCreatedElems();
6105 for ( int i = 1; i <= aSeq.Length(); i++ )
6106 groupDS->SMDSGroup().Add( aSeq(i) );
6111 if ( !newGroup->_is_nil() )
6112 pyDump << newGroup << " = ";
6113 pyDump << this << ".DoubleElements( "
6114 << theElements << ", " << "'" << theGroupName <<"')";
6116 SMESH_CATCH( SMESH::throwCorbaException );
6118 return newGroup._retn();
6121 //================================================================================
6123 \brief Creates a hole in a mesh by doubling the nodes of some particular elements
6124 \param theNodes - identifiers of nodes to be doubled
6125 \param theModifiedElems - identifiers of elements to be updated by the new (doubled)
6126 nodes. If list of element identifiers is empty then nodes are doubled but
6127 they not assigned to elements
6128 \return TRUE if operation has been completed successfully, FALSE otherwise
6129 \sa DoubleNode(), DoubleNodeGroup(), DoubleNodeGroups()
6131 //================================================================================
6133 CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theNodes,
6134 const SMESH::long_array& theModifiedElems )
6135 throw (SALOME::SALOME_Exception)
6140 list< int > aListOfNodes;
6142 for ( i = 0, n = theNodes.length(); i < n; i++ )
6143 aListOfNodes.push_back( theNodes[ i ] );
6145 list< int > aListOfElems;
6146 for ( i = 0, n = theModifiedElems.length(); i < n; i++ )
6147 aListOfElems.push_back( theModifiedElems[ i ] );
6149 bool aResult = getEditor().DoubleNodes( aListOfNodes, aListOfElems );
6151 declareMeshModified( /*isReComputeSafe=*/ !aResult );
6153 // Update Python script
6154 TPythonDump() << this << ".DoubleNodes( " << theNodes << ", "<< theModifiedElems << " )";
6158 SMESH_CATCH( SMESH::throwCorbaException );
6162 //================================================================================
6164 \brief Creates a hole in a mesh by doubling the nodes of some particular elements
6165 This method provided for convenience works as DoubleNodes() described above.
6166 \param theNodeId - identifier of node to be doubled.
6167 \param theModifiedElems - identifiers of elements to be updated.
6168 \return TRUE if operation has been completed successfully, FALSE otherwise
6169 \sa DoubleNodes(), DoubleNodeGroup(), DoubleNodeGroups()
6171 //================================================================================
6173 CORBA::Boolean SMESH_MeshEditor_i::DoubleNode( CORBA::Long theNodeId,
6174 const SMESH::long_array& theModifiedElems )
6175 throw (SALOME::SALOME_Exception)
6178 SMESH::long_array_var aNodes = new SMESH::long_array;
6179 aNodes->length( 1 );
6180 aNodes[ 0 ] = theNodeId;
6182 TPythonDump pyDump; // suppress dump by the next line
6184 CORBA::Boolean done = DoubleNodes( aNodes, theModifiedElems );
6186 pyDump << this << ".DoubleNode( " << theNodeId << ", " << theModifiedElems << " )";
6190 SMESH_CATCH( SMESH::throwCorbaException );
6194 //================================================================================
6196 \brief Creates a hole in a mesh by doubling the nodes of some particular elements
6197 This method provided for convenience works as DoubleNodes() described above.
6198 \param theNodes - group of nodes to be doubled.
6199 \param theModifiedElems - group of elements to be updated.
6200 \return TRUE if operation has been completed successfully, FALSE otherwise
6201 \sa DoubleNode(), DoubleNodes(), DoubleNodeGroups()
6203 //================================================================================
6205 CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroup(SMESH::SMESH_GroupBase_ptr theNodes,
6206 SMESH::SMESH_GroupBase_ptr theModifiedElems )
6207 throw (SALOME::SALOME_Exception)
6210 if ( CORBA::is_nil( theNodes ) && theNodes->GetType() != SMESH::NODE )
6213 SMESH::long_array_var aNodes = theNodes->GetListOfID();
6214 SMESH::long_array_var aModifiedElems;
6215 if ( !CORBA::is_nil( theModifiedElems ) )
6216 aModifiedElems = theModifiedElems->GetListOfID();
6219 aModifiedElems = new SMESH::long_array;
6220 aModifiedElems->length( 0 );
6223 TPythonDump pyDump; // suppress dump by the next line
6225 bool done = DoubleNodes( aNodes, aModifiedElems );
6227 pyDump << this << ".DoubleNodeGroup( " << theNodes << ", " << theModifiedElems << " )";
6231 SMESH_CATCH( SMESH::throwCorbaException );
6235 //================================================================================
6237 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
6238 * Works as DoubleNodeGroup(), but returns a new group with newly created nodes.
6239 * \param theNodes - group of nodes to be doubled.
6240 * \param theModifiedElems - group of elements to be updated.
6241 * \return a new group with newly created nodes
6242 * \sa DoubleNodeGroup()
6244 //================================================================================
6246 SMESH::SMESH_Group_ptr
6247 SMESH_MeshEditor_i::DoubleNodeGroupNew( SMESH::SMESH_GroupBase_ptr theNodes,
6248 SMESH::SMESH_GroupBase_ptr theModifiedElems )
6249 throw (SALOME::SALOME_Exception)
6252 SMESH::SMESH_Group_var aNewGroup;
6254 if ( CORBA::is_nil( theNodes ) && theNodes->GetType() != SMESH::NODE )
6255 return aNewGroup._retn();
6258 SMESH::long_array_var aNodes = theNodes->GetListOfID();
6259 SMESH::long_array_var aModifiedElems;
6260 if ( !CORBA::is_nil( theModifiedElems ) )
6261 aModifiedElems = theModifiedElems->GetListOfID();
6263 aModifiedElems = new SMESH::long_array;
6264 aModifiedElems->length( 0 );
6267 TPythonDump pyDump; // suppress dump by the next line
6269 bool aResult = DoubleNodes( aNodes, aModifiedElems );
6272 // Create group with newly created nodes
6273 SMESH::long_array_var anIds = GetLastCreatedNodes();
6274 if (anIds->length() > 0) {
6275 string anUnindexedName (theNodes->GetName());
6276 string aNewName = generateGroupName(anUnindexedName + "_double");
6277 aNewGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
6278 aNewGroup->Add(anIds);
6279 pyDump << aNewGroup << " = ";
6283 pyDump << this << ".DoubleNodeGroupNew( " << theNodes << ", "
6284 << theModifiedElems << " )";
6286 return aNewGroup._retn();
6288 SMESH_CATCH( SMESH::throwCorbaException );
6292 //================================================================================
6294 \brief Creates a hole in a mesh by doubling the nodes of some particular elements
6295 This method provided for convenience works as DoubleNodes() described above.
6296 \param theNodes - list of groups of nodes to be doubled
6297 \param theModifiedElems - list of groups of elements to be updated.
6298 \return TRUE if operation has been completed successfully, FALSE otherwise
6299 \sa DoubleNode(), DoubleNodeGroup(), DoubleNodes()
6301 //================================================================================
6303 CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups(const SMESH::ListOfGroups& theNodes,
6304 const SMESH::ListOfGroups& theModifiedElems )
6305 throw (SALOME::SALOME_Exception)
6310 std::list< int > aNodes;
6312 for ( i = 0, n = theNodes.length(); i < n; i++ )
6314 SMESH::SMESH_GroupBase_var aGrp = theNodes[ i ];
6315 if ( !CORBA::is_nil( aGrp ) && aGrp->GetType() == SMESH::NODE )
6317 SMESH::long_array_var aCurr = aGrp->GetListOfID();
6318 for ( j = 0, m = aCurr->length(); j < m; j++ )
6319 aNodes.push_back( aCurr[ j ] );
6323 std::list< int > anElems;
6324 for ( i = 0, n = theModifiedElems.length(); i < n; i++ )
6326 SMESH::SMESH_GroupBase_var aGrp = theModifiedElems[ i ];
6327 if ( !CORBA::is_nil( aGrp ) && aGrp->GetType() != SMESH::NODE )
6329 SMESH::long_array_var aCurr = aGrp->GetListOfID();
6330 for ( j = 0, m = aCurr->length(); j < m; j++ )
6331 anElems.push_back( aCurr[ j ] );
6335 bool aResult = getEditor().DoubleNodes( aNodes, anElems );
6337 declareMeshModified( /*isReComputeSafe=*/false );
6339 TPythonDump() << this << ".DoubleNodeGroups( " << theNodes << ", " << theModifiedElems << " )";
6343 SMESH_CATCH( SMESH::throwCorbaException );
6347 //================================================================================
6349 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
6350 * Works as DoubleNodeGroups(), but returns a new group with newly created nodes.
6351 * \param theNodes - group of nodes to be doubled.
6352 * \param theModifiedElems - group of elements to be updated.
6353 * \return a new group with newly created nodes
6354 * \sa DoubleNodeGroups()
6356 //================================================================================
6358 SMESH::SMESH_Group_ptr
6359 SMESH_MeshEditor_i::DoubleNodeGroupsNew( const SMESH::ListOfGroups& theNodes,
6360 const SMESH::ListOfGroups& theModifiedElems )
6361 throw (SALOME::SALOME_Exception)
6363 SMESH::SMESH_Group_var aNewGroup;
6365 TPythonDump pyDump; // suppress dump by the next line
6367 bool aResult = DoubleNodeGroups( theNodes, theModifiedElems );
6371 // Create group with newly created nodes
6372 SMESH::long_array_var anIds = GetLastCreatedNodes();
6373 if (anIds->length() > 0) {
6374 string anUnindexedName (theNodes[0]->GetName());
6375 string aNewName = generateGroupName(anUnindexedName + "_double");
6376 aNewGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
6377 aNewGroup->Add(anIds);
6378 pyDump << aNewGroup << " = ";
6382 pyDump << this << ".DoubleNodeGroupsNew( " << theNodes << ", "
6383 << theModifiedElems << " )";
6385 return aNewGroup._retn();
6389 //================================================================================
6391 \brief Creates a hole in a mesh by doubling the nodes of some particular elements
6392 \param theElems - the list of elements (edges or faces) to be replicated
6393 The nodes for duplication could be found from these elements
6394 \param theNodesNot - list of nodes to NOT replicate
6395 \param theAffectedElems - the list of elements (cells and edges) to which the
6396 replicated nodes should be associated to.
6397 \return TRUE if operation has been completed successfully, FALSE otherwise
6398 \sa DoubleNodeGroup(), DoubleNodeGroups()
6400 //================================================================================
6402 CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElem( const SMESH::long_array& theElems,
6403 const SMESH::long_array& theNodesNot,
6404 const SMESH::long_array& theAffectedElems )
6405 throw (SALOME::SALOME_Exception)
6410 SMESHDS_Mesh* aMeshDS = getMeshDS();
6411 TIDSortedElemSet anElems, aNodes, anAffected;
6412 arrayToSet(theElems, aMeshDS, anElems, SMDSAbs_All);
6413 arrayToSet(theNodesNot, aMeshDS, aNodes, SMDSAbs_Node);
6414 arrayToSet(theAffectedElems, aMeshDS, anAffected, SMDSAbs_All);
6416 bool aResult = getEditor().DoubleNodes( anElems, aNodes, anAffected );
6418 // Update Python script
6419 TPythonDump() << this << ".DoubleNodeElem( " << theElems << ", "
6420 << theNodesNot << ", " << theAffectedElems << " )";
6422 declareMeshModified( /*isReComputeSafe=*/false );
6425 SMESH_CATCH( SMESH::throwCorbaException );
6429 //================================================================================
6431 \brief Creates a hole in a mesh by doubling the nodes of some particular elements
6432 \param theElems - the list of elements (edges or faces) to be replicated
6433 The nodes for duplication could be found from these elements
6434 \param theNodesNot - list of nodes to NOT replicate
6435 \param theShape - shape to detect affected elements (element which geometric center
6436 located on or inside shape).
6437 The replicated nodes should be associated to affected elements.
6438 \return TRUE if operation has been completed successfully, FALSE otherwise
6439 \sa DoubleNodeGroupInRegion(), DoubleNodeGroupsInRegion()
6441 //================================================================================
6443 CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemInRegion ( const SMESH::long_array& theElems,
6444 const SMESH::long_array& theNodesNot,
6445 GEOM::GEOM_Object_ptr theShape )
6446 throw (SALOME::SALOME_Exception)
6452 SMESHDS_Mesh* aMeshDS = getMeshDS();
6453 TIDSortedElemSet anElems, aNodes;
6454 arrayToSet(theElems, aMeshDS, anElems, SMDSAbs_All);
6455 arrayToSet(theNodesNot, aMeshDS, aNodes, SMDSAbs_Node);
6457 TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape );
6458 bool aResult = getEditor().DoubleNodesInRegion( anElems, aNodes, aShape );
6460 // Update Python script
6461 TPythonDump() << "isDone = " << this << ".DoubleNodeElemInRegion( " << theElems << ", "
6462 << theNodesNot << ", " << theShape << " )";
6464 declareMeshModified( /*isReComputeSafe=*/false );
6467 SMESH_CATCH( SMESH::throwCorbaException );
6471 //================================================================================
6473 \brief Creates a hole in a mesh by doubling the nodes of some particular elements
6474 \param theElems - group of of elements (edges or faces) to be replicated
6475 \param theNodesNot - group of nodes not to replicated
6476 \param theAffectedElems - group of elements to which the replicated nodes
6477 should be associated to.
6478 \return TRUE if operation has been completed successfully, FALSE otherwise
6479 \sa DoubleNodes(), DoubleNodeGroups()
6481 //================================================================================
6484 SMESH_MeshEditor_i::DoubleNodeElemGroup(SMESH::SMESH_GroupBase_ptr theElems,
6485 SMESH::SMESH_GroupBase_ptr theNodesNot,
6486 SMESH::SMESH_GroupBase_ptr theAffectedElems)
6487 throw (SALOME::SALOME_Exception)
6490 if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE )
6496 SMESHDS_Mesh* aMeshDS = getMeshDS();
6497 TIDSortedElemSet anElems, aNodes, anAffected;
6498 idSourceToSet( theElems, aMeshDS, anElems, SMDSAbs_All );
6499 idSourceToSet( theNodesNot, aMeshDS, aNodes, SMDSAbs_Node );
6500 idSourceToSet( theAffectedElems, aMeshDS, anAffected, SMDSAbs_All );
6502 bool aResult = getEditor().DoubleNodes( anElems, aNodes, anAffected );
6504 // Update Python script
6505 TPythonDump() << "isDone = " << this << ".DoubleNodeElemGroup( " << theElems << ", "
6506 << theNodesNot << ", " << theAffectedElems << " )";
6508 declareMeshModified( /*isReComputeSafe=*/false );
6511 SMESH_CATCH( SMESH::throwCorbaException );
6515 //================================================================================
6517 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
6518 * Works as DoubleNodeElemGroup(), but returns a new group with newly created elements.
6519 * \param theElems - group of of elements (edges or faces) to be replicated
6520 * \param theNodesNot - group of nodes not to replicated
6521 * \param theAffectedElems - group of elements to which the replicated nodes
6522 * should be associated to.
6523 * \return a new group with newly created elements
6524 * \sa DoubleNodeElemGroup()
6526 //================================================================================
6528 SMESH::SMESH_Group_ptr
6529 SMESH_MeshEditor_i::DoubleNodeElemGroupNew(SMESH::SMESH_GroupBase_ptr theElems,
6530 SMESH::SMESH_GroupBase_ptr theNodesNot,
6531 SMESH::SMESH_GroupBase_ptr theAffectedElems)
6532 throw (SALOME::SALOME_Exception)
6535 SMESH::ListOfGroups_var twoGroups = DoubleNodeElemGroup2New( theElems,
6539 SMESH::SMESH_GroupBase_var baseGroup = twoGroups[0].in();
6540 SMESH::SMESH_Group_var elemGroup = SMESH::SMESH_Group::_narrow( baseGroup );
6542 pyDump << elemGroup << " = " << this << ".DoubleNodeElemGroupNew( "
6544 << theNodesNot << ", "
6545 << theAffectedElems << " )";
6547 return elemGroup._retn();
6550 //================================================================================
6552 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
6553 * Works as DoubleNodeElemGroup(), but returns a new group with newly created elements.
6554 * \param theElems - group of of elements (edges or faces) to be replicated
6555 * \param theNodesNot - group of nodes not to replicated
6556 * \param theAffectedElems - group of elements to which the replicated nodes
6557 * should be associated to.
6558 * \return a new group with newly created elements
6559 * \sa DoubleNodeElemGroup()
6561 //================================================================================
6563 SMESH::ListOfGroups*
6564 SMESH_MeshEditor_i::DoubleNodeElemGroup2New(SMESH::SMESH_GroupBase_ptr theElems,
6565 SMESH::SMESH_GroupBase_ptr theNodesNot,
6566 SMESH::SMESH_GroupBase_ptr theAffectedElems,
6567 CORBA::Boolean theElemGroupNeeded,
6568 CORBA::Boolean theNodeGroupNeeded)
6569 throw (SALOME::SALOME_Exception)
6572 SMESH::SMESH_Group_var aNewElemGroup, aNewNodeGroup;
6573 SMESH::ListOfGroups_var aTwoGroups = new SMESH::ListOfGroups();
6574 aTwoGroups->length( 2 );
6576 if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE )
6577 return aTwoGroups._retn();
6582 SMESHDS_Mesh* aMeshDS = getMeshDS();
6583 TIDSortedElemSet anElems, aNodes, anAffected;
6584 idSourceToSet( theElems, aMeshDS, anElems, SMDSAbs_All );
6585 idSourceToSet( theNodesNot, aMeshDS, aNodes, SMDSAbs_Node );
6586 idSourceToSet( theAffectedElems, aMeshDS, anAffected, SMDSAbs_All );
6589 bool aResult = getEditor().DoubleNodes( anElems, aNodes, anAffected );
6591 declareMeshModified( /*isReComputeSafe=*/ !aResult );
6597 // Create group with newly created elements
6598 CORBA::String_var elemGroupName = theElems->GetName();
6599 string aNewName = generateGroupName( string(elemGroupName.in()) + "_double");
6600 if ( !getEditor().GetLastCreatedElems().IsEmpty() && theElemGroupNeeded )
6602 SMESH::long_array_var anIds = GetLastCreatedElems();
6603 SMESH::ElementType aGroupType = myMesh_i->GetElementType(anIds[0], true);
6604 aNewElemGroup = myMesh_i->CreateGroup(aGroupType, aNewName.c_str());
6605 aNewElemGroup->Add(anIds);
6607 if ( !getEditor().GetLastCreatedNodes().IsEmpty() && theNodeGroupNeeded )
6609 SMESH::long_array_var anIds = GetLastCreatedNodes();
6610 aNewNodeGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
6611 aNewNodeGroup->Add(anIds);
6615 // Update Python script
6618 if ( aNewElemGroup->_is_nil() ) pyDump << "nothing, ";
6619 else pyDump << aNewElemGroup << ", ";
6620 if ( aNewNodeGroup->_is_nil() ) pyDump << "nothing ] = ";
6621 else pyDump << aNewNodeGroup << " ] = ";
6623 pyDump << this << ".DoubleNodeElemGroup2New( " << theElems << ", "
6624 << theNodesNot << ", "
6625 << theAffectedElems << ", "
6626 << theElemGroupNeeded << ", "
6627 << theNodeGroupNeeded <<" )";
6629 aTwoGroups[0] = aNewElemGroup._retn();
6630 aTwoGroups[1] = aNewNodeGroup._retn();
6631 return aTwoGroups._retn();
6633 SMESH_CATCH( SMESH::throwCorbaException );
6637 //================================================================================
6639 \brief Creates a hole in a mesh by doubling the nodes of some particular elements
6640 \param theElems - group of of elements (edges or faces) to be replicated
6641 \param theNodesNot - group of nodes not to replicated
6642 \param theShape - shape to detect affected elements (element which geometric center
6643 located on or inside shape).
6644 The replicated nodes should be associated to affected elements.
6645 \return TRUE if operation has been completed successfully, FALSE otherwise
6646 \sa DoubleNodesInRegion(), DoubleNodeGroupsInRegion()
6648 //================================================================================
6651 SMESH_MeshEditor_i::DoubleNodeElemGroupInRegion(SMESH::SMESH_GroupBase_ptr theElems,
6652 SMESH::SMESH_GroupBase_ptr theNodesNot,
6653 GEOM::GEOM_Object_ptr theShape )
6654 throw (SALOME::SALOME_Exception)
6657 if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE )
6663 SMESHDS_Mesh* aMeshDS = getMeshDS();
6664 TIDSortedElemSet anElems, aNodes, anAffected;
6665 idSourceToSet( theElems, aMeshDS, anElems, SMDSAbs_All );
6666 idSourceToSet( theNodesNot, aMeshDS, aNodes, SMDSAbs_Node );
6668 TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape );
6669 bool aResult = getEditor().DoubleNodesInRegion( anElems, aNodes, aShape );
6672 declareMeshModified( /*isReComputeSafe=*/ !aResult );
6674 // Update Python script
6675 TPythonDump() << "isDone = " << this << ".DoubleNodeElemGroupInRegion( " << theElems << ", "
6676 << theNodesNot << ", " << theShape << " )";
6679 SMESH_CATCH( SMESH::throwCorbaException );
6683 //================================================================================
6685 * \brief Re-load elements from a list of groups into a TIDSortedElemSet
6686 * \param [in] theGrpList - groups
6687 * \param [in] theMeshDS - mesh
6688 * \param [out] theElemSet - set of elements
6689 * \param [in] theIsNodeGrp - is \a theGrpList includes goups of nodes
6691 //================================================================================
6693 static void listOfGroupToSet(const SMESH::ListOfGroups& theGrpList,
6694 SMESHDS_Mesh* theMeshDS,
6695 TIDSortedElemSet& theElemSet,
6696 const bool theIsNodeGrp)
6698 for ( int i = 0, n = theGrpList.length(); i < n; i++ )
6700 SMESH::SMESH_GroupBase_var aGrp = theGrpList[ i ];
6701 if ( !CORBA::is_nil( aGrp ) && (theIsNodeGrp ? aGrp->GetType() == SMESH::NODE
6702 : aGrp->GetType() != SMESH::NODE ) )
6704 SMESH::long_array_var anIDs = aGrp->GetIDs();
6705 arrayToSet( anIDs, theMeshDS, theElemSet, theIsNodeGrp ? SMDSAbs_Node : SMDSAbs_All );
6710 //================================================================================
6712 \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
6713 This method provided for convenience works as DoubleNodes() described above.
6714 \param theElems - list of groups of elements (edges or faces) to be replicated
6715 \param theNodesNot - list of groups of nodes not to replicated
6716 \param theAffectedElems - group of elements to which the replicated nodes
6717 should be associated to.
6718 \return TRUE if operation has been completed successfully, FALSE otherwise
6719 \sa DoubleNodeGroup(), DoubleNodes(), DoubleNodeElemGroupsNew()
6721 //================================================================================
6724 SMESH_MeshEditor_i::DoubleNodeElemGroups(const SMESH::ListOfGroups& theElems,
6725 const SMESH::ListOfGroups& theNodesNot,
6726 const SMESH::ListOfGroups& theAffectedElems)
6727 throw (SALOME::SALOME_Exception)
6733 SMESHDS_Mesh* aMeshDS = getMeshDS();
6734 TIDSortedElemSet anElems, aNodes, anAffected;
6735 listOfGroupToSet(theElems, aMeshDS, anElems, false );
6736 listOfGroupToSet(theNodesNot, aMeshDS, aNodes, true );
6737 listOfGroupToSet(theAffectedElems, aMeshDS, anAffected, false );
6739 bool aResult = getEditor().DoubleNodes( anElems, aNodes, anAffected );
6741 // Update Python script
6742 TPythonDump() << "isDone = " << this << ".DoubleNodeElemGroups( " << &theElems << ", "
6743 << &theNodesNot << ", " << &theAffectedElems << " )";
6745 declareMeshModified( /*isReComputeSafe=*/false );
6748 SMESH_CATCH( SMESH::throwCorbaException );
6752 //================================================================================
6754 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
6755 * Works as DoubleNodeElemGroups(), but returns a new group with newly created elements.
6756 \param theElems - list of groups of elements (edges or faces) to be replicated
6757 \param theNodesNot - list of groups of nodes not to replicated
6758 \param theAffectedElems - group of elements to which the replicated nodes
6759 should be associated to.
6760 * \return a new group with newly created elements
6761 * \sa DoubleNodeElemGroups()
6763 //================================================================================
6765 SMESH::SMESH_Group_ptr
6766 SMESH_MeshEditor_i::DoubleNodeElemGroupsNew(const SMESH::ListOfGroups& theElems,
6767 const SMESH::ListOfGroups& theNodesNot,
6768 const SMESH::ListOfGroups& theAffectedElems)
6769 throw (SALOME::SALOME_Exception)
6772 SMESH::ListOfGroups_var twoGroups = DoubleNodeElemGroups2New( theElems,
6776 SMESH::SMESH_GroupBase_var baseGroup = twoGroups[0].in();
6777 SMESH::SMESH_Group_var elemGroup = SMESH::SMESH_Group::_narrow( baseGroup );
6779 pyDump << elemGroup << " = " << this << ".DoubleNodeElemGroupsNew( "
6781 << theNodesNot << ", "
6782 << theAffectedElems << " )";
6784 return elemGroup._retn();
6787 //================================================================================
6789 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
6790 * Works as DoubleNodeElemGroups(), but returns a new group with newly created elements.
6791 \param theElems - list of groups of elements (edges or faces) to be replicated
6792 \param theNodesNot - list of groups of nodes not to replicated
6793 \param theAffectedElems - group of elements to which the replicated nodes
6794 should be associated to.
6795 * \return a new group with newly created elements
6796 * \sa DoubleNodeElemGroups()
6798 //================================================================================
6800 SMESH::ListOfGroups*
6801 SMESH_MeshEditor_i::DoubleNodeElemGroups2New(const SMESH::ListOfGroups& theElems,
6802 const SMESH::ListOfGroups& theNodesNot,
6803 const SMESH::ListOfGroups& theAffectedElems,
6804 CORBA::Boolean theElemGroupNeeded,
6805 CORBA::Boolean theNodeGroupNeeded)
6806 throw (SALOME::SALOME_Exception)
6809 SMESH::SMESH_Group_var aNewElemGroup, aNewNodeGroup;
6810 SMESH::ListOfGroups_var aTwoGroups = new SMESH::ListOfGroups();
6811 aTwoGroups->length( 2 );
6816 SMESHDS_Mesh* aMeshDS = getMeshDS();
6817 TIDSortedElemSet anElems, aNodes, anAffected;
6818 listOfGroupToSet(theElems, aMeshDS, anElems, false );
6819 listOfGroupToSet(theNodesNot, aMeshDS, aNodes, true );
6820 listOfGroupToSet(theAffectedElems, aMeshDS, anAffected, false );
6822 bool aResult = getEditor().DoubleNodes( anElems, aNodes, anAffected );
6824 declareMeshModified( /*isReComputeSafe=*/ !aResult );
6829 // Create group with newly created elements
6830 CORBA::String_var elemGroupName = theElems[0]->GetName();
6831 string aNewName = generateGroupName( string(elemGroupName.in()) + "_double");
6832 if ( !getEditor().GetLastCreatedElems().IsEmpty() && theElemGroupNeeded )
6834 SMESH::long_array_var anIds = GetLastCreatedElems();
6835 SMESH::ElementType aGroupType = myMesh_i->GetElementType(anIds[0], true);
6836 aNewElemGroup = myMesh_i->CreateGroup(aGroupType, aNewName.c_str());
6837 aNewElemGroup->Add(anIds);
6839 if ( !getEditor().GetLastCreatedNodes().IsEmpty() && theNodeGroupNeeded )
6841 SMESH::long_array_var anIds = GetLastCreatedNodes();
6842 aNewNodeGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
6843 aNewNodeGroup->Add(anIds);
6847 // Update Python script
6850 if ( aNewElemGroup->_is_nil() ) pyDump << "nothing, ";
6851 else pyDump << aNewElemGroup << ", ";
6852 if ( aNewNodeGroup->_is_nil() ) pyDump << "nothing ] = ";
6853 else pyDump << aNewNodeGroup << " ] = ";
6855 pyDump << this << ".DoubleNodeElemGroups2New( " << &theElems << ", "
6856 << &theNodesNot << ", "
6857 << &theAffectedElems << ", "
6858 << theElemGroupNeeded << ", "
6859 << theNodeGroupNeeded << " )";
6861 aTwoGroups[0] = aNewElemGroup._retn();
6862 aTwoGroups[1] = aNewNodeGroup._retn();
6863 return aTwoGroups._retn();
6865 SMESH_CATCH( SMESH::throwCorbaException );
6869 //================================================================================
6871 \brief Creates a hole in a mesh by doubling the nodes of some particular elements
6872 This method provided for convenience works as DoubleNodes() described above.
6873 \param theElems - list of groups of elements (edges or faces) to be replicated
6874 \param theNodesNot - list of groups of nodes not to replicated
6875 \param theShape - shape to detect affected elements (element which geometric center
6876 located on or inside shape).
6877 The replicated nodes should be associated to affected elements.
6878 \return TRUE if operation has been completed successfully, FALSE otherwise
6879 \sa DoubleNodeGroupInRegion(), DoubleNodesInRegion()
6881 //================================================================================
6884 SMESH_MeshEditor_i::DoubleNodeElemGroupsInRegion(const SMESH::ListOfGroups& theElems,
6885 const SMESH::ListOfGroups& theNodesNot,
6886 GEOM::GEOM_Object_ptr theShape )
6887 throw (SALOME::SALOME_Exception)
6893 SMESHDS_Mesh* aMeshDS = getMeshDS();
6894 TIDSortedElemSet anElems, aNodes;
6895 listOfGroupToSet(theElems, aMeshDS, anElems,false );
6896 listOfGroupToSet(theNodesNot, aMeshDS, aNodes, true );
6898 TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape );
6899 bool aResult = getEditor().DoubleNodesInRegion( anElems, aNodes, aShape );
6901 // Update Python script
6902 TPythonDump() << "isDone = " << this << ".DoubleNodeElemGroupsInRegion( " << &theElems << ", "
6903 << &theNodesNot << ", " << theShape << " )";
6905 declareMeshModified( /*isReComputeSafe=*/ !aResult );
6908 SMESH_CATCH( SMESH::throwCorbaException );
6912 //================================================================================
6914 \brief Identify the elements that will be affected by node duplication (actual
6915 duplication is not performed.
6916 This method is the first step of DoubleNodeElemGroupsInRegion.
6917 \param theElems - list of groups of elements (edges or faces) to be replicated
6918 \param theNodesNot - list of groups of nodes not to replicated
6919 \param theShape - shape to detect affected elements (element which geometric center
6920 located on or inside shape).
6921 The replicated nodes should be associated to affected elements.
6922 \return groups of affected elements
6923 \sa DoubleNodeElemGroupsInRegion()
6925 //================================================================================
6926 SMESH::ListOfGroups*
6927 SMESH_MeshEditor_i::AffectedElemGroupsInRegion( const SMESH::ListOfGroups& theElems,
6928 const SMESH::ListOfGroups& theNodesNot,
6929 GEOM::GEOM_Object_ptr theShape )
6930 throw (SALOME::SALOME_Exception)
6933 MESSAGE("AffectedElemGroupsInRegion");
6934 SMESH::ListOfGroups_var aListOfGroups = new SMESH::ListOfGroups();
6935 bool isEdgeGroup = false;
6936 bool isFaceGroup = false;
6937 bool isVolumeGroup = false;
6938 SMESH::SMESH_Group_var aNewEdgeGroup = myMesh_i->CreateGroup(SMESH::EDGE, "affectedEdges");
6939 SMESH::SMESH_Group_var aNewFaceGroup = myMesh_i->CreateGroup(SMESH::FACE, "affectedFaces");
6940 SMESH::SMESH_Group_var aNewVolumeGroup = myMesh_i->CreateGroup(SMESH::VOLUME, "affectedVolumes");
6944 ::SMESH_MeshEditor aMeshEditor(myMesh);
6946 SMESHDS_Mesh* aMeshDS = getMeshDS();
6947 TIDSortedElemSet anElems, aNodes;
6948 listOfGroupToSet(theElems, aMeshDS, anElems, false);
6949 listOfGroupToSet(theNodesNot, aMeshDS, aNodes, true);
6951 TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape(theShape);
6952 TIDSortedElemSet anAffected;
6953 bool aResult = aMeshEditor.AffectedElemGroupsInRegion(anElems, aNodes, aShape, anAffected);
6956 declareMeshModified( /*isReComputeSafe=*/ !aResult );
6961 int lg = anAffected.size();
6962 MESSAGE("lg="<< lg);
6963 SMESH::long_array_var volumeIds = new SMESH::long_array;
6964 volumeIds->length(lg);
6965 SMESH::long_array_var faceIds = new SMESH::long_array;
6966 faceIds->length(lg);
6967 SMESH::long_array_var edgeIds = new SMESH::long_array;
6968 edgeIds->length(lg);
6973 TIDSortedElemSet::const_iterator eIt = anAffected.begin();
6974 for (; eIt != anAffected.end(); ++eIt)
6976 const SMDS_MeshElement* anElem = *eIt;
6979 int elemId = anElem->GetID();
6980 if (myMesh->GetElementType(elemId, true) == SMDSAbs_Volume)
6981 volumeIds[ivol++] = elemId;
6982 else if (myMesh->GetElementType(elemId, true) == SMDSAbs_Face)
6983 faceIds[iface++] = elemId;
6984 else if (myMesh->GetElementType(elemId, true) == SMDSAbs_Edge)
6985 edgeIds[iedge++] = elemId;
6987 volumeIds->length(ivol);
6988 faceIds->length(iface);
6989 edgeIds->length(iedge);
6991 aNewVolumeGroup->Add(volumeIds);
6992 aNewFaceGroup->Add(faceIds);
6993 aNewEdgeGroup->Add(edgeIds);
6994 isVolumeGroup = (aNewVolumeGroup->Size() > 0);
6995 isFaceGroup = (aNewFaceGroup->Size() > 0);
6996 isEdgeGroup = (aNewEdgeGroup->Size() > 0);
7000 if (isEdgeGroup) nbGroups++;
7001 if (isFaceGroup) nbGroups++;
7002 if (isVolumeGroup) nbGroups++;
7003 aListOfGroups->length(nbGroups);
7006 if (isEdgeGroup) aListOfGroups[i++] = aNewEdgeGroup._retn();
7007 if (isFaceGroup) aListOfGroups[i++] = aNewFaceGroup._retn();
7008 if (isVolumeGroup) aListOfGroups[i++] = aNewVolumeGroup._retn();
7010 // Update Python script
7013 if (isEdgeGroup) pyDump << aNewEdgeGroup << ", ";
7014 if (isFaceGroup) pyDump << aNewFaceGroup << ", ";
7015 if (isVolumeGroup) pyDump << aNewVolumeGroup << ", ";
7017 pyDump << this << ".AffectedElemGroupsInRegion( "
7018 << &theElems << ", " << &theNodesNot << ", " << theShape << " )";
7020 return aListOfGroups._retn();
7022 SMESH_CATCH( SMESH::throwCorbaException );
7026 //================================================================================
7028 \brief Generated skin mesh (containing 2D cells) from 3D mesh
7029 The created 2D mesh elements based on nodes of free faces of boundary volumes
7030 \return TRUE if operation has been completed successfully, FALSE otherwise
7032 //================================================================================
7034 CORBA::Boolean SMESH_MeshEditor_i::Make2DMeshFrom3D()
7035 throw (SALOME::SALOME_Exception)
7040 bool aResult = getEditor().Make2DMeshFrom3D();
7042 TPythonDump() << "isDone = " << this << ".Make2DMeshFrom3D()";
7044 declareMeshModified( /*isReComputeSafe=*/ !aResult );
7047 SMESH_CATCH( SMESH::throwCorbaException );
7051 //================================================================================
7053 * \brief Double nodes on shared faces between groups of volumes and create flat elements on demand.
7054 * The list of groups must contain at least two groups. The groups have to be disjoint:
7055 * no common element into two different groups.
7056 * The nodes of the internal faces at the boundaries of the groups are doubled.
7057 * Optionally, the internal faces are replaced by flat elements.
7058 * Triangles are transformed into prisms, and quadrangles into hexahedrons.
7059 * The flat elements are stored in groups of volumes.
7060 * These groups are named according to the position of the group in the list:
7061 * the group j_n_p is the group of the flat elements that are built between the group #n and the group #p in the list.
7062 * If there is no shared faces between the group #n and the group #p in the list, the group j_n_p is not created.
7063 * All the flat elements are gathered into the group named "joints3D" (or "joints2D" in 2D situation).
7064 * The flat element of the multiple junctions between the simple junction are stored in a group named "jointsMultiples".
7065 * \param theDomains - list of groups of volumes
7066 * \param createJointElems - if TRUE, create the elements
7067 * \param onAllBoundaries - if TRUE, the nodes and elements are also created on
7068 * the boundary between \a theDomains and the rest mesh
7069 * \return TRUE if operation has been completed successfully, FALSE otherwise
7071 //================================================================================
7074 SMESH_MeshEditor_i::DoubleNodesOnGroupBoundaries( const SMESH::ListOfGroups& theDomains,
7075 CORBA::Boolean createJointElems,
7076 CORBA::Boolean onAllBoundaries )
7077 throw (SALOME::SALOME_Exception)
7084 SMESHDS_Mesh* aMeshDS = getMeshDS();
7086 // MESSAGE("theDomains.length = "<<theDomains.length());
7087 if ( theDomains.length() <= 1 && !onAllBoundaries )
7088 THROW_SALOME_CORBA_EXCEPTION("At least 2 groups are required.", SALOME::BAD_PARAM);
7090 vector<TIDSortedElemSet> domains;
7091 domains.resize( theDomains.length() );
7093 for ( int i = 0, n = theDomains.length(); i < n; i++ )
7095 SMESH::SMESH_GroupBase_var aGrp = theDomains[ i ];
7096 if ( !CORBA::is_nil( aGrp ) /*&& ( aGrp->GetType() != SMESH::NODE )*/ )
7098 // if ( aGrp->GetType() != SMESH::VOLUME )
7099 // THROW_SALOME_CORBA_EXCEPTION("Not a volume group", SALOME::BAD_PARAM);
7100 SMESH::long_array_var anIDs = aGrp->GetIDs();
7101 arrayToSet( anIDs, aMeshDS, domains[ i ], SMDSAbs_All );
7105 isOK = getEditor().DoubleNodesOnGroupBoundaries( domains, createJointElems, onAllBoundaries );
7106 // TODO publish the groups of flat elements in study
7108 declareMeshModified( /*isReComputeSafe=*/ !isOK );
7110 // Update Python script
7111 TPythonDump() << "isDone = " << this << ".DoubleNodesOnGroupBoundaries( " << &theDomains
7112 << ", " << createJointElems << ", " << onAllBoundaries << " )";
7114 SMESH_CATCH( SMESH::throwCorbaException );
7116 myMesh_i->CreateGroupServants(); // publish created groups if any
7121 //================================================================================
7123 * \brief Double nodes on some external faces and create flat elements.
7124 * Flat elements are mainly used by some types of mechanic calculations.
7126 * Each group of the list must be constituted of faces.
7127 * Triangles are transformed in prisms, and quadrangles in hexahedrons.
7128 * @param theGroupsOfFaces - list of groups of faces
7129 * @return TRUE if operation has been completed successfully, FALSE otherwise
7131 //================================================================================
7134 SMESH_MeshEditor_i::CreateFlatElementsOnFacesGroups( const SMESH::ListOfGroups& theGroupsOfFaces )
7135 throw (SALOME::SALOME_Exception)
7140 SMESHDS_Mesh* aMeshDS = getMeshDS();
7142 vector<TIDSortedElemSet> faceGroups;
7145 for ( int i = 0, n = theGroupsOfFaces.length(); i < n; i++ )
7147 SMESH::SMESH_GroupBase_var aGrp = theGroupsOfFaces[ i ];
7148 if ( !CORBA::is_nil( aGrp ) && ( aGrp->GetType() != SMESH::NODE ) )
7150 TIDSortedElemSet faceGroup;
7152 faceGroups.push_back(faceGroup);
7153 SMESH::long_array_var anIDs = aGrp->GetIDs();
7154 arrayToSet( anIDs, aMeshDS, faceGroups[ i ], SMDSAbs_All );
7158 bool aResult = getEditor().CreateFlatElementsOnFacesGroups( faceGroups );
7159 // TODO publish the groups of flat elements in study
7161 declareMeshModified( /*isReComputeSafe=*/ !aResult );
7163 // Update Python script
7164 TPythonDump() << this << ".CreateFlatElementsOnFacesGroups( " << &theGroupsOfFaces << " )";
7167 SMESH_CATCH( SMESH::throwCorbaException );
7171 //================================================================================
7173 * \brief Identify all the elements around a geom shape, get the faces delimiting
7176 * Build groups of volume to remove, groups of faces to replace on the skin of the
7177 * object, groups of faces to remove inside the object, (idem edges).
7178 * Build ordered list of nodes at the border of each group of faces to replace
7179 * (to be used to build a geom subshape).
7181 //================================================================================
7183 void SMESH_MeshEditor_i::CreateHoleSkin(CORBA::Double radius,
7184 GEOM::GEOM_Object_ptr theShape,
7185 const char* groupName,
7186 const SMESH::double_array& theNodesCoords,
7187 SMESH::array_of_long_array_out GroupsOfNodes)
7188 throw (SALOME::SALOME_Exception)
7193 std::vector<std::vector<int> > aListOfListOfNodes;
7194 ::SMESH_MeshEditor aMeshEditor( myMesh );
7196 theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other
7197 if ( !theNodeSearcher )
7198 theNodeSearcher = SMESH_MeshAlgos::GetNodeSearcher( *getMeshDS() );
7200 vector<double> nodesCoords;
7201 for (int i = 0; i < theNodesCoords.length(); i++)
7203 nodesCoords.push_back( theNodesCoords[i] );
7206 TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape );
7207 aMeshEditor.CreateHoleSkin(radius, aShape, theNodeSearcher, groupName,
7208 nodesCoords, aListOfListOfNodes);
7210 GroupsOfNodes = new SMESH::array_of_long_array;
7211 GroupsOfNodes->length( aListOfListOfNodes.size() );
7212 std::vector<std::vector<int> >::iterator llIt = aListOfListOfNodes.begin();
7213 for ( CORBA::Long i = 0; llIt != aListOfListOfNodes.end(); llIt++, i++ )
7215 vector<int>& aListOfNodes = *llIt;
7216 vector<int>::iterator lIt = aListOfNodes.begin();;
7217 SMESH::long_array& aGroup = (*GroupsOfNodes)[ i ];
7218 aGroup.length( aListOfNodes.size() );
7219 for ( int j = 0; lIt != aListOfNodes.end(); lIt++, j++ )
7220 aGroup[ j ] = (*lIt);
7222 TPythonDump() << "lists_nodes = " << this << ".CreateHoleSkin( "
7225 << ", '" << groupName << "', "
7226 << theNodesCoords << " )";
7228 SMESH_CATCH( SMESH::throwCorbaException );
7231 // issue 20749 ===================================================================
7233 * \brief Creates missing boundary elements
7234 * \param elements - elements whose boundary is to be checked
7235 * \param dimension - defines type of boundary elements to create
7236 * \param groupName - a name of group to store created boundary elements in,
7237 * "" means not to create the group
7238 * \param meshName - a name of new mesh to store created boundary elements in,
7239 * "" means not to create the new mesh
7240 * \param toCopyElements - if true, the checked elements will be copied into the new mesh
7241 * \param toCopyExistingBondary - if true, not only new but also pre-existing
7242 * boundary elements will be copied into the new mesh
7243 * \param group - returns the create group, if any
7244 * \retval SMESH::SMESH_Mesh - the mesh where elements were added to
7246 // ================================================================================
7248 SMESH::SMESH_Mesh_ptr
7249 SMESH_MeshEditor_i::MakeBoundaryMesh(SMESH::SMESH_IDSource_ptr idSource,
7250 SMESH::Bnd_Dimension dim,
7251 const char* groupName,
7252 const char* meshName,
7253 CORBA::Boolean toCopyElements,
7254 CORBA::Boolean toCopyExistingBondary,
7255 SMESH::SMESH_Group_out group)
7256 throw (SALOME::SALOME_Exception)
7261 if ( dim > SMESH::BND_1DFROM2D )
7262 THROW_SALOME_CORBA_EXCEPTION("Invalid boundary dimension", SALOME::BAD_PARAM);
7264 SMESHDS_Mesh* aMeshDS = getMeshDS();
7266 SMESH::SMESH_Mesh_var mesh_var;
7267 SMESH::SMESH_Group_var group_var;
7271 TIDSortedElemSet elements;
7272 SMDSAbs_ElementType elemType = (dim == SMESH::BND_1DFROM2D) ? SMDSAbs_Face : SMDSAbs_Volume;
7273 prepareIdSource( idSource );
7274 if ( idSourceToSet( idSource, aMeshDS, elements, elemType,/*emptyIfIsMesh=*/true ))
7278 strlen(meshName) ? makeMesh(meshName) : SMESH::SMESH_Mesh::_duplicate(myMesh_i->_this());
7279 SMESH_Mesh_i* mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh_var );
7281 SMESH_Mesh* smesh_mesh = (mesh_i==myMesh_i) ? (SMESH_Mesh*)0 : &mesh_i->GetImpl();
7283 // group of new boundary elements
7284 SMESH_Group* smesh_group = 0;
7285 if ( strlen(groupName) )
7287 group_var = mesh_i->CreateGroup( SMESH::ElementType(int(elemType)-1),groupName);
7288 if ( SMESH_GroupBase_i* group_i = SMESH::DownCast<SMESH_GroupBase_i*>( group_var ))
7289 smesh_group = group_i->GetSmeshGroup();
7293 getEditor().MakeBoundaryMesh( elements,
7294 ::SMESH_MeshEditor::Bnd_Dimension(dim),
7298 toCopyExistingBondary);
7301 smesh_mesh->GetMeshDS()->Modified();
7304 const char* dimName[] = { "BND_2DFROM3D", "BND_1DFROM3D", "BND_1DFROM2D" };
7306 // result of MakeBoundaryMesh() is a tuple (mesh, group)
7307 if ( mesh_var->_is_nil() )
7308 pyDump << myMesh_i->_this() << ", ";
7310 pyDump << mesh_var << ", ";
7311 if ( group_var->_is_nil() )
7312 pyDump << "_NoneGroup = "; // assignment to None is forbiden
7314 pyDump << group_var << " = ";
7315 pyDump << this << ".MakeBoundaryMesh( "
7317 << "SMESH." << dimName[int(dim)] << ", "
7318 << "'" << groupName << "', "
7319 << "'" << meshName<< "', "
7320 << toCopyElements << ", "
7321 << toCopyExistingBondary << ")";
7323 group = group_var._retn();
7324 return mesh_var._retn();
7326 SMESH_CATCH( SMESH::throwCorbaException );
7327 return SMESH::SMESH_Mesh::_nil();
7330 //================================================================================
7332 * \brief Creates missing boundary elements
7333 * \param dimension - defines type of boundary elements to create
7334 * \param groupName - a name of group to store all boundary elements in,
7335 * "" means not to create the group
7336 * \param meshName - a name of a new mesh, which is a copy of the initial
7337 * mesh + created boundary elements; "" means not to create the new mesh
7338 * \param toCopyAll - if true, the whole initial mesh will be copied into
7339 * the new mesh else only boundary elements will be copied into the new mesh
7340 * \param groups - optional groups of elements to make boundary around
7341 * \param mesh - returns the mesh where elements were added to
7342 * \param group - returns the created group, if any
7343 * \retval long - number of added boundary elements
7345 //================================================================================
7347 CORBA::Long SMESH_MeshEditor_i::MakeBoundaryElements(SMESH::Bnd_Dimension dim,
7348 const char* groupName,
7349 const char* meshName,
7350 CORBA::Boolean toCopyAll,
7351 const SMESH::ListOfIDSources& groups,
7352 SMESH::SMESH_Mesh_out mesh,
7353 SMESH::SMESH_Group_out group)
7354 throw (SALOME::SALOME_Exception)
7359 if ( dim > SMESH::BND_1DFROM2D )
7360 THROW_SALOME_CORBA_EXCEPTION("Invalid boundary dimension", SALOME::BAD_PARAM);
7362 // separate groups belonging to this and other mesh
7363 SMESH::ListOfIDSources_var groupsOfThisMesh = new SMESH::ListOfIDSources;
7364 SMESH::ListOfIDSources_var groupsOfOtherMesh = new SMESH::ListOfIDSources;
7365 groupsOfThisMesh->length( groups.length() );
7366 groupsOfOtherMesh->length( groups.length() );
7367 int nbGroups = 0, nbGroupsOfOtherMesh = 0;
7368 for ( int i = 0; i < groups.length(); ++i )
7370 SMESH::SMESH_Mesh_var m = groups[i]->GetMesh();
7371 if ( myMesh_i != SMESH::DownCast<SMESH_Mesh_i*>( m ))
7372 groupsOfOtherMesh[ nbGroupsOfOtherMesh++ ] = groups[i];
7374 groupsOfThisMesh[ nbGroups++ ] = groups[i];
7375 if ( SMESH::DownCast<SMESH_Mesh_i*>( groups[i] ))
7376 THROW_SALOME_CORBA_EXCEPTION("expect a group but recieve a mesh", SALOME::BAD_PARAM);
7378 groupsOfThisMesh->length( nbGroups );
7379 groupsOfOtherMesh->length( nbGroupsOfOtherMesh );
7384 if ( nbGroupsOfOtherMesh > 0 )
7386 // process groups belonging to another mesh
7387 SMESH::SMESH_Mesh_var otherMesh = groupsOfOtherMesh[0]->GetMesh();
7388 SMESH::SMESH_MeshEditor_var editor = otherMesh->GetMeshEditor();
7389 nbAdded += editor->MakeBoundaryElements( dim, groupName, meshName, toCopyAll,
7390 groupsOfOtherMesh, mesh, group );
7393 SMESH::SMESH_Mesh_var mesh_var;
7394 SMESH::SMESH_Group_var group_var;
7397 mesh_var = SMESH::SMESH_Mesh::_duplicate( myMesh_i->_this() );
7398 const bool toCopyMesh = ( strlen( meshName ) > 0 );
7402 mesh_var = SMESH_Gen_i::GetSMESHGen()->CopyMesh(mesh_var,
7404 /*toCopyGroups=*/false,
7405 /*toKeepIDs=*/true);
7407 mesh_var = makeMesh(meshName);
7409 SMESH_Mesh_i* mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh_var );
7410 SMESH_Mesh* tgtMesh = &mesh_i->GetImpl();
7413 SMESH_Mesh* srcMesh = ( toCopyMesh && !toCopyAll ) ? myMesh : tgtMesh;
7414 SMESHDS_Mesh* srcMeshDS = srcMesh->GetMeshDS();
7416 // group of boundary elements
7417 SMESH_Group* smesh_group = 0;
7418 SMDSAbs_ElementType elemType = (dim == SMESH::BND_2DFROM3D) ? SMDSAbs_Volume : SMDSAbs_Face;
7419 if ( strlen(groupName) )
7421 SMESH::ElementType groupType = SMESH::ElementType( int(elemType)-1 );
7422 group_var = mesh_i->CreateGroup( groupType, groupName );
7423 if ( SMESH_GroupBase_i* group_i = SMESH::DownCast<SMESH_GroupBase_i*>( group_var ))
7424 smesh_group = group_i->GetSmeshGroup();
7427 TIDSortedElemSet elements;
7429 if ( groups.length() > 0 )
7431 for ( int i = 0; i < nbGroups; ++i )
7434 if ( idSourceToSet( groupsOfThisMesh[i], srcMeshDS, elements, elemType,/*emptyIfIsMesh=*/0 ))
7436 SMESH::Bnd_Dimension bdim =
7437 ( elemType == SMDSAbs_Volume ) ? SMESH::BND_2DFROM3D : SMESH::BND_1DFROM2D;
7438 nbAdded += getEditor().MakeBoundaryMesh( elements,
7439 ::SMESH_MeshEditor::Bnd_Dimension(bdim),
7442 /*toCopyElements=*/false,
7443 /*toCopyExistingBondary=*/srcMesh != tgtMesh,
7444 /*toAddExistingBondary=*/true,
7445 /*aroundElements=*/true);
7451 nbAdded += getEditor().MakeBoundaryMesh( elements,
7452 ::SMESH_MeshEditor::Bnd_Dimension(dim),
7455 /*toCopyElements=*/false,
7456 /*toCopyExistingBondary=*/srcMesh != tgtMesh,
7457 /*toAddExistingBondary=*/true);
7459 tgtMesh->GetMeshDS()->Modified();
7461 const char* dimName[] = { "BND_2DFROM3D", "BND_1DFROM3D", "BND_1DFROM2D" };
7463 // result of MakeBoundaryElements() is a tuple (nb, mesh, group)
7464 pyDump << "nbAdded, ";
7465 if ( mesh_var->_is_nil() )
7466 pyDump << myMesh_i->_this() << ", ";
7468 pyDump << mesh_var << ", ";
7469 if ( group_var->_is_nil() )
7470 pyDump << "_NoneGroup = "; // assignment to None is forbiden
7472 pyDump << group_var << " = ";
7473 pyDump << this << ".MakeBoundaryElements( "
7474 << "SMESH." << dimName[int(dim)] << ", "
7475 << "'" << groupName << "', "
7476 << "'" << meshName<< "', "
7477 << toCopyAll << ", "
7480 mesh = mesh_var._retn();
7481 group = group_var._retn();
7484 SMESH_CATCH( SMESH::throwCorbaException );