1 // SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
3 // Copyright (C) 2003 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.
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
24 // File : SMESH_MeshEditor_i.cxx
25 // Author : Nicolas REJNERI
29 #include "SMESH_MeshEditor_i.hxx"
31 #include "SMDS_MeshEdge.hxx"
32 #include "SMDS_MeshFace.hxx"
33 #include "SMDS_MeshVolume.hxx"
34 #include "SMDS_PolyhedralVolumeOfNodes.hxx"
35 #include "SMESH_MeshEditor.hxx"
36 #include "SMESH_subMeshEventListener.hxx"
37 #include "SMESH_Gen_i.hxx"
38 #include "SMESH_Filter_i.hxx"
39 #include "SMESH_PythonDump.hxx"
41 #include "utilities.h"
47 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
51 #include <Standard_Failure.hxx>
54 #include <Standard_ErrorHandler.hxx>
56 #include "CASCatch.hxx"
61 #define cast2Node(elem) static_cast<const SMDS_MeshNode*>( elem )
64 using SMESH::TPythonDump;
68 //=============================================================================
70 * \brief Mesh to apply modifications for preview purposes
72 //=============================================================================
74 struct TPreviewMesh: public SMESH_Mesh
76 SMDSAbs_ElementType myPreviewType; // type to show
78 TPreviewMesh(SMDSAbs_ElementType previewElements = SMDSAbs_All) {
79 _isShapeToMesh = _id =_studyId =_idDoc = 0;
80 _myMeshDS = new SMESHDS_Mesh( _id, true );
81 myPreviewType = previewElements;
84 virtual ~TPreviewMesh() { delete _myMeshDS; }
85 //!< Copy a set of elements
86 void Copy(const TIDSortedElemSet & theElements,
87 TIDSortedElemSet& theCopyElements,
88 SMDSAbs_ElementType theSelectType = SMDSAbs_All,
89 SMDSAbs_ElementType theAvoidType = SMDSAbs_All)
91 // loop on theIDsOfElements
92 TIDSortedElemSet::const_iterator eIt = theElements.begin();
93 for ( ; eIt != theElements.end(); ++eIt )
95 const SMDS_MeshElement* anElem = *eIt;
96 if ( !anElem ) continue;
97 SMDSAbs_ElementType type = anElem->GetType();
98 if ( type == theAvoidType ||
99 ( theSelectType != SMDSAbs_All && type != theSelectType ))
102 if ( const SMDS_MeshElement* anElemCopy = Copy( anElem ))
103 theCopyElements.insert( theCopyElements.end(), anElemCopy );
107 SMDS_MeshElement* Copy( const SMDS_MeshElement* anElem )
109 // copy element nodes
110 int anElemNbNodes = anElem->NbNodes();
111 vector< int > anElemNodesID( anElemNbNodes ) ;
112 SMDS_ElemIteratorPtr itElemNodes = anElem->nodesIterator();
113 for ( int i = 0; itElemNodes->more(); i++)
115 const SMDS_MeshNode* anElemNode = cast2Node( itElemNodes->next() );
117 anElemNodesID[i] = anElemNode->GetID();
120 // creates a corresponding element on copied nodes
121 SMDS_MeshElement* anElemCopy = 0;
122 if ( anElem->IsPoly() && anElem->GetType() == SMDSAbs_Volume )
124 const SMDS_PolyhedralVolumeOfNodes* ph =
125 dynamic_cast<const SMDS_PolyhedralVolumeOfNodes*> (anElem);
127 anElemCopy = _myMeshDS->AddPolyhedralVolumeWithID
128 (anElemNodesID, ph->GetQuanities(),anElem->GetID());
131 anElemCopy = ::SMESH_MeshEditor(this).AddElement( anElemNodesID,
138 SMDS_MeshNode* Copy( const SMDS_MeshNode* anElemNode )
140 return _myMeshDS->AddNodeWithID(anElemNode->X(), anElemNode->Y(), anElemNode->Z(),
141 anElemNode->GetID());
143 };// struct TPreviewMesh
145 static SMESH_NodeSearcher * myNodeSearcher = 0;
147 //=============================================================================
149 * \brief Deleter of myNodeSearcher at any compute event occured
151 //=============================================================================
153 struct TNodeSearcherDeleter : public SMESH_subMeshEventListener
157 TNodeSearcherDeleter(): SMESH_subMeshEventListener( false ), // won't be deleted by submesh
159 //!< Delete myNodeSearcher
162 if ( myNodeSearcher ) { delete myNodeSearcher; myNodeSearcher = 0; }
164 typedef map < int, SMESH_subMesh * > TDependsOnMap;
165 //!< The meshod called by submesh: do my main job
166 void ProcessEvent(const int, const int eventType, SMESH_subMesh* sm,
167 SMESH_subMeshEventListenerData*,const SMESH_Hypothesis*)
169 if ( eventType == SMESH_subMesh::COMPUTE_EVENT ) {
171 Unset( sm->GetFather() );
174 //!< set self on all submeshes and delete myNodeSearcher if other mesh is set
175 void Set(SMESH_Mesh* mesh)
177 if ( myMesh && myMesh != mesh ) {
182 if ( SMESH_subMesh* myMainSubMesh = mesh->GetSubMeshContaining(1) ) {
183 const TDependsOnMap & subMeshes = myMainSubMesh->DependsOn();
184 TDependsOnMap::const_iterator sm;
185 for (sm = subMeshes.begin(); sm != subMeshes.end(); sm++)
186 sm->second->SetEventListener( this, 0, sm->second );
189 //!< delete self from all submeshes
190 void Unset(SMESH_Mesh* mesh)
192 if ( SMESH_subMesh* myMainSubMesh = mesh->GetSubMeshContaining(1) ) {
193 const TDependsOnMap & subMeshes = myMainSubMesh->DependsOn();
194 TDependsOnMap::const_iterator sm;
195 for (sm = subMeshes.begin(); sm != subMeshes.end(); sm++)
196 sm->second->DeleteEventListener( this );
202 //=============================================================================
206 //=============================================================================
208 SMESH_MeshEditor_i::SMESH_MeshEditor_i(SMESH_Mesh* theMesh, bool isPreview)
211 myPreviewMode = isPreview;
214 //================================================================================
218 //================================================================================
220 SMESH_MeshEditor_i::~SMESH_MeshEditor_i()
224 //================================================================================
226 * \brief Clear members
228 //================================================================================
230 void SMESH_MeshEditor_i::initData()
232 if ( myPreviewMode ) {
233 myPreviewData = new SMESH::MeshPreviewStruct();
236 myLastCreatedElems = new SMESH::long_array();
237 myLastCreatedNodes = new SMESH::long_array();
238 TNodeSearcherDeleter::Delete();
242 //=============================================================================
246 //=============================================================================
249 SMESH_MeshEditor_i::RemoveElements(const SMESH::long_array & IDsOfElements)
253 ::SMESH_MeshEditor anEditor( myMesh );
256 for (int i = 0; i < IDsOfElements.length(); i++)
257 IdList.push_back( IDsOfElements[i] );
259 // Update Python script
260 TPythonDump() << "isDone = " << this << ".RemoveElements( " << IDsOfElements << " )";
262 TPythonDump() << "print 'RemoveElements: ', isDone";
265 return anEditor.Remove( IdList, false );
268 //=============================================================================
272 //=============================================================================
274 CORBA::Boolean SMESH_MeshEditor_i::RemoveNodes(const SMESH::long_array & IDsOfNodes)
278 ::SMESH_MeshEditor anEditor( myMesh );
280 for (int i = 0; i < IDsOfNodes.length(); i++)
281 IdList.push_back( IDsOfNodes[i] );
283 // Update Python script
284 TPythonDump() << "isDone = " << this << ".RemoveNodes( " << IDsOfNodes << " )";
286 TPythonDump() << "print 'RemoveNodes: ', isDone";
289 return anEditor.Remove( IdList, true );
292 //=============================================================================
296 //=============================================================================
298 CORBA::Long SMESH_MeshEditor_i::AddEdge(const SMESH::long_array & IDsOfNodes)
302 int NbNodes = IDsOfNodes.length();
303 SMDS_MeshElement* elem = 0;
306 CORBA::Long index1 = IDsOfNodes[0];
307 CORBA::Long index2 = IDsOfNodes[1];
308 elem = GetMeshDS()->AddEdge(GetMeshDS()->FindNode(index1), GetMeshDS()->FindNode(index2));
310 // Update Python script
311 TPythonDump() << "edge = " << this << ".AddEdge([ "
312 << index1 << ", " << index2 <<" ])";
315 CORBA::Long n1 = IDsOfNodes[0];
316 CORBA::Long n2 = IDsOfNodes[1];
317 CORBA::Long n12 = IDsOfNodes[2];
318 elem = GetMeshDS()->AddEdge(GetMeshDS()->FindNode(n1),
319 GetMeshDS()->FindNode(n2),
320 GetMeshDS()->FindNode(n12));
321 // Update Python script
322 TPythonDump() << "edgeID = " << this << ".AddEdge([ "
323 <<n1<<", "<<n2<<", "<<n12<<" ])";
327 return elem->GetID();
332 //=============================================================================
336 //=============================================================================
338 CORBA::Long SMESH_MeshEditor_i::AddNode(CORBA::Double x,
339 CORBA::Double y, CORBA::Double z)
343 const SMDS_MeshNode* N = GetMeshDS()->AddNode(x, y, z);
345 // Update Python script
346 TPythonDump() << "nodeID = " << this << ".AddNode( "
347 << x << ", " << y << ", " << z << " )";
352 //=============================================================================
356 //=============================================================================
358 CORBA::Long SMESH_MeshEditor_i::AddFace(const SMESH::long_array & IDsOfNodes)
362 int NbNodes = IDsOfNodes.length();
368 std::vector<const SMDS_MeshNode*> nodes (NbNodes);
369 for (int i = 0; i < NbNodes; i++)
370 nodes[i] = GetMeshDS()->FindNode(IDsOfNodes[i]);
372 SMDS_MeshElement* elem = 0;
374 elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2]);
376 else if (NbNodes == 4) {
377 elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3]);
379 else if (NbNodes == 6) {
380 elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
383 else if (NbNodes == 8) {
384 elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
385 nodes[4], nodes[5], nodes[6], nodes[7]);
388 // Update Python script
389 TPythonDump() << "faceID = " << this << ".AddFace( " << IDsOfNodes << " )";
392 return elem->GetID();
397 //=============================================================================
401 //=============================================================================
402 CORBA::Long SMESH_MeshEditor_i::AddPolygonalFace
403 (const SMESH::long_array & IDsOfNodes)
407 int NbNodes = IDsOfNodes.length();
408 std::vector<const SMDS_MeshNode*> nodes (NbNodes);
409 for (int i = 0; i < NbNodes; i++)
410 nodes[i] = GetMeshDS()->FindNode(IDsOfNodes[i]);
412 const SMDS_MeshElement* elem = GetMeshDS()->AddPolygonalFace(nodes);
414 // Update Python script
415 TPythonDump() <<"faceID = "<<this<<".AddPolygonalFace( "<<IDsOfNodes<<" )";
417 TPythonDump() << "print 'AddPolygonalFace: ', faceID";
421 return elem->GetID();
426 //=============================================================================
430 //=============================================================================
432 CORBA::Long SMESH_MeshEditor_i::AddVolume(const SMESH::long_array & IDsOfNodes)
436 int NbNodes = IDsOfNodes.length();
437 vector< const SMDS_MeshNode*> n(NbNodes);
438 for(int i=0;i<NbNodes;i++)
439 n[i]=GetMeshDS()->FindNode(IDsOfNodes[i]);
441 SMDS_MeshElement* elem = 0;
444 case 4 :elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3]); break;
445 case 5 :elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4]); break;
446 case 6 :elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5]); break;
447 case 8 :elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7]); break;
448 case 10:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],
449 n[6],n[7],n[8],n[9]);
451 case 13:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],
452 n[7],n[8],n[9],n[10],n[11],n[12]);
454 case 15:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],n[8],
455 n[9],n[10],n[11],n[12],n[13],n[14]);
457 case 20:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],
458 n[8],n[9],n[10],n[11],n[12],n[13],n[14],
459 n[15],n[16],n[17],n[18],n[19]);
463 // Update Python script
464 TPythonDump() << "volID = " << this << ".AddVolume( " << IDsOfNodes << " )";
466 TPythonDump() << "print 'AddVolume: ', volID";
470 return elem->GetID();
475 //=============================================================================
477 * AddPolyhedralVolume
479 //=============================================================================
480 CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolume
481 (const SMESH::long_array & IDsOfNodes,
482 const SMESH::long_array & Quantities)
486 int NbNodes = IDsOfNodes.length();
487 std::vector<const SMDS_MeshNode*> n (NbNodes);
488 for (int i = 0; i < NbNodes; i++)
489 n[i] = GetMeshDS()->FindNode(IDsOfNodes[i]);
491 int NbFaces = Quantities.length();
492 std::vector<int> q (NbFaces);
493 for (int j = 0; j < NbFaces; j++)
494 q[j] = Quantities[j];
496 const SMDS_MeshElement* elem = GetMeshDS()->AddPolyhedralVolume(n, q);
498 // Update Python script
499 TPythonDump() << "volID = " << this << ".AddPolyhedralVolume( "
500 << IDsOfNodes << ", " << Quantities << " )";
502 TPythonDump() << "print 'AddPolyhedralVolume: ', volID";
506 return elem->GetID();
511 //=============================================================================
513 * AddPolyhedralVolumeByFaces
515 //=============================================================================
516 CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolumeByFaces
517 (const SMESH::long_array & IdsOfFaces)
521 int NbFaces = IdsOfFaces.length();
522 std::vector<const SMDS_MeshNode*> poly_nodes;
523 std::vector<int> quantities (NbFaces);
525 for (int i = 0; i < NbFaces; i++) {
526 const SMDS_MeshElement* aFace = GetMeshDS()->FindElement(IdsOfFaces[i]);
527 quantities[i] = aFace->NbNodes();
529 SMDS_ElemIteratorPtr It = aFace->nodesIterator();
531 poly_nodes.push_back(static_cast<const SMDS_MeshNode *>(It->next()));
535 const SMDS_MeshElement* elem = GetMeshDS()->AddPolyhedralVolume(poly_nodes, quantities);
537 // Update Python script
538 TPythonDump() << "volID = " << this << ".AddPolyhedralVolumeByFaces( "
539 << IdsOfFaces << " )";
541 TPythonDump() << "print 'AddPolyhedralVolume: ', volID";
545 return elem->GetID();
550 //=============================================================================
554 //=============================================================================
556 CORBA::Boolean SMESH_MeshEditor_i::MoveNode(CORBA::Long NodeID,
563 const SMDS_MeshNode * node = GetMeshDS()->FindNode( NodeID );
567 GetMeshDS()->MoveNode(node, x, y, z);
569 // Update Python script
570 TPythonDump() << "isDone = " << this << ".MoveNode( "
571 << NodeID << ", " << x << ", " << y << ", " << z << " )";
576 //=============================================================================
580 //=============================================================================
582 CORBA::Boolean SMESH_MeshEditor_i::InverseDiag(CORBA::Long NodeID1,
587 const SMDS_MeshNode * n1 = GetMeshDS()->FindNode( NodeID1 );
588 const SMDS_MeshNode * n2 = GetMeshDS()->FindNode( NodeID2 );
592 // Update Python script
593 TPythonDump() << "isDone = " << this << ".InverseDiag( "
594 << NodeID1 << ", " << NodeID2 << " )";
596 ::SMESH_MeshEditor aMeshEditor( myMesh );
597 return aMeshEditor.InverseDiag ( n1, n2 );
600 //=============================================================================
604 //=============================================================================
606 CORBA::Boolean SMESH_MeshEditor_i::DeleteDiag(CORBA::Long NodeID1,
611 const SMDS_MeshNode * n1 = GetMeshDS()->FindNode( NodeID1 );
612 const SMDS_MeshNode * n2 = GetMeshDS()->FindNode( NodeID2 );
616 // Update Python script
617 TPythonDump() << "isDone = " << this << ".DeleteDiag( "
618 << NodeID1 << ", " << NodeID2 << " )";
620 ::SMESH_MeshEditor aMeshEditor( myMesh );
622 bool stat = aMeshEditor.DeleteDiag ( n1, n2 );
624 StoreResult(aMeshEditor);
629 //=============================================================================
633 //=============================================================================
635 CORBA::Boolean SMESH_MeshEditor_i::Reorient(const SMESH::long_array & IDsOfElements)
639 ::SMESH_MeshEditor anEditor( myMesh );
640 for (int i = 0; i < IDsOfElements.length(); i++)
642 CORBA::Long index = IDsOfElements[i];
643 const SMDS_MeshElement * elem = GetMeshDS()->FindElement(index);
645 anEditor.Reorient( elem );
647 // Update Python script
648 TPythonDump() << "isDone = " << this << ".Reorient( " << IDsOfElements << " )";
654 //=============================================================================
658 //=============================================================================
660 CORBA::Boolean SMESH_MeshEditor_i::ReorientObject(SMESH::SMESH_IDSource_ptr theObject)
664 SMESH::long_array_var anElementsId = theObject->GetIDs();
665 CORBA::Boolean isDone = Reorient(anElementsId);
667 // Clear python line, created by Reorient()
668 SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
669 aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
671 // Update Python script
672 TPythonDump() << "isDone = " << this << ".ReorientObject( " << theObject << " )";
679 //================================================================================
681 * \brief function for conversion long_array to TIDSortedElemSet
682 * \param IDs - array of IDs
683 * \param aMesh - mesh
684 * \param aMap - collection to fill
685 * \param aType - element type
687 //================================================================================
689 void ToMap(const SMESH::long_array & IDs,
690 const SMESHDS_Mesh* aMesh,
691 TIDSortedElemSet& aMap,
692 const SMDSAbs_ElementType aType = SMDSAbs_All )
694 for (int i=0; i<IDs.length(); i++) {
695 CORBA::Long ind = IDs[i];
696 const SMDS_MeshElement * elem = aMesh->FindElement(ind);
697 if ( elem && ( aType == SMDSAbs_All || elem->GetType() == aType ))
703 //=============================================================================
707 //=============================================================================
708 CORBA::Boolean SMESH_MeshEditor_i::TriToQuad (const SMESH::long_array & IDsOfElements,
709 SMESH::NumericalFunctor_ptr Criterion,
710 CORBA::Double MaxAngle)
714 SMESHDS_Mesh* aMesh = GetMeshDS();
715 TIDSortedElemSet faces;
716 ToMap(IDsOfElements, aMesh, faces, SMDSAbs_Face);
718 SMESH::NumericalFunctor_i* aNumericalFunctor =
719 dynamic_cast<SMESH::NumericalFunctor_i*>( SMESH_Gen_i::GetServant( Criterion ).in() );
720 SMESH::Controls::NumericalFunctorPtr aCrit;
721 if ( !aNumericalFunctor )
722 aCrit.reset( new SMESH::Controls::AspectRatio() );
724 aCrit = aNumericalFunctor->GetNumericalFunctor();
726 // Update Python script
727 TPythonDump() << "isDone = " << this << ".TriToQuad( "
728 << IDsOfElements << ", " << aNumericalFunctor << ", " << MaxAngle << " )";
730 TPythonDump() << "print 'TriToQuad: ', isDone";
733 ::SMESH_MeshEditor anEditor( myMesh );
735 bool stat = anEditor.TriToQuad( faces, aCrit, MaxAngle );
737 StoreResult(anEditor);
743 //=============================================================================
747 //=============================================================================
748 CORBA::Boolean SMESH_MeshEditor_i::TriToQuadObject (SMESH::SMESH_IDSource_ptr theObject,
749 SMESH::NumericalFunctor_ptr Criterion,
750 CORBA::Double MaxAngle)
754 SMESH::long_array_var anElementsId = theObject->GetIDs();
755 CORBA::Boolean isDone = TriToQuad(anElementsId, Criterion, MaxAngle);
757 // Clear python line(s), created by TriToQuad()
758 SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
759 aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
761 aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
764 SMESH::NumericalFunctor_i* aNumericalFunctor =
765 SMESH::DownCast<SMESH::NumericalFunctor_i*>( Criterion );
767 // Update Python script
768 TPythonDump() << "isDone = " << this << ".TriToQuadObject("
769 << theObject << ", " << aNumericalFunctor << ", " << MaxAngle << " )";
771 TPythonDump() << "print 'TriToQuadObject: ', isDone";
778 //=============================================================================
782 //=============================================================================
783 CORBA::Boolean SMESH_MeshEditor_i::QuadToTri (const SMESH::long_array & IDsOfElements,
784 SMESH::NumericalFunctor_ptr Criterion)
788 SMESHDS_Mesh* aMesh = GetMeshDS();
789 TIDSortedElemSet faces;
790 ToMap(IDsOfElements, aMesh, faces, SMDSAbs_Face);
792 SMESH::NumericalFunctor_i* aNumericalFunctor =
793 dynamic_cast<SMESH::NumericalFunctor_i*>( SMESH_Gen_i::GetServant( Criterion ).in() );
794 SMESH::Controls::NumericalFunctorPtr aCrit;
795 if ( !aNumericalFunctor )
796 aCrit.reset( new SMESH::Controls::AspectRatio() );
798 aCrit = aNumericalFunctor->GetNumericalFunctor();
801 // Update Python script
802 TPythonDump() << "isDone = " << this << ".QuadToTri( " << IDsOfElements << ", " << aNumericalFunctor << " )";
804 TPythonDump() << "print 'QuadToTri: ', isDone";
807 ::SMESH_MeshEditor anEditor( myMesh );
808 CORBA::Boolean stat = anEditor.QuadToTri( faces, aCrit );
810 StoreResult(anEditor);
816 //=============================================================================
820 //=============================================================================
821 CORBA::Boolean SMESH_MeshEditor_i::QuadToTriObject (SMESH::SMESH_IDSource_ptr theObject,
822 SMESH::NumericalFunctor_ptr Criterion)
826 SMESH::long_array_var anElementsId = theObject->GetIDs();
827 CORBA::Boolean isDone = QuadToTri(anElementsId, Criterion);
829 // Clear python line(s), created by QuadToTri()
830 SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
831 aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
833 aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
836 SMESH::NumericalFunctor_i* aNumericalFunctor =
837 SMESH::DownCast<SMESH::NumericalFunctor_i*>( Criterion );
839 // Update Python script
840 TPythonDump() << "isDone = " << this << ".QuadToTriObject( " << theObject << ", " << aNumericalFunctor << " )";
842 TPythonDump() << "print 'QuadToTriObject: ', isDone";
849 //=============================================================================
853 //=============================================================================
854 CORBA::Boolean SMESH_MeshEditor_i::SplitQuad (const SMESH::long_array & IDsOfElements,
855 CORBA::Boolean Diag13)
859 SMESHDS_Mesh* aMesh = GetMeshDS();
860 TIDSortedElemSet faces;
861 ToMap(IDsOfElements, aMesh, faces, SMDSAbs_Face);
863 // Update Python script
864 TPythonDump() << "isDone = " << this << ".SplitQuad( "
865 << IDsOfElements << ", " << Diag13 << " )";
867 TPythonDump() << "print 'SplitQuad: ', isDone";
870 ::SMESH_MeshEditor anEditor( myMesh );
871 CORBA::Boolean stat = anEditor.QuadToTri( faces, Diag13 );
873 StoreResult(anEditor);
879 //=============================================================================
883 //=============================================================================
884 CORBA::Boolean SMESH_MeshEditor_i::SplitQuadObject (SMESH::SMESH_IDSource_ptr theObject,
885 CORBA::Boolean Diag13)
889 SMESH::long_array_var anElementsId = theObject->GetIDs();
890 CORBA::Boolean isDone = SplitQuad(anElementsId, Diag13);
892 // Clear python line(s), created by SplitQuad()
893 SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
894 aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
896 aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
899 // Update Python script
900 TPythonDump() << "isDone = " << this << ".SplitQuadObject( "
901 << theObject << ", " << Diag13 << " )";
903 TPythonDump() << "print 'SplitQuadObject: ', isDone";
910 //=============================================================================
914 //=============================================================================
915 CORBA::Long SMESH_MeshEditor_i::BestSplit (CORBA::Long IDOfQuad,
916 SMESH::NumericalFunctor_ptr Criterion)
918 const SMDS_MeshElement* quad = GetMeshDS()->FindElement(IDOfQuad);
919 if (quad && quad->GetType() == SMDSAbs_Face && quad->NbNodes() == 4)
921 SMESH::NumericalFunctor_i* aNumericalFunctor =
922 dynamic_cast<SMESH::NumericalFunctor_i*>(SMESH_Gen_i::GetServant(Criterion).in());
923 SMESH::Controls::NumericalFunctorPtr aCrit;
924 if (aNumericalFunctor)
925 aCrit = aNumericalFunctor->GetNumericalFunctor();
927 aCrit.reset(new SMESH::Controls::AspectRatio());
929 ::SMESH_MeshEditor anEditor (myMesh);
930 return anEditor.BestSplit(quad, aCrit);
936 //=======================================================================
939 //=======================================================================
942 SMESH_MeshEditor_i::Smooth(const SMESH::long_array & IDsOfElements,
943 const SMESH::long_array & IDsOfFixedNodes,
944 CORBA::Long MaxNbOfIterations,
945 CORBA::Double MaxAspectRatio,
946 SMESH::SMESH_MeshEditor::Smooth_Method Method)
948 return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
949 MaxAspectRatio, Method, false );
953 //=======================================================================
954 //function : SmoothParametric
956 //=======================================================================
959 SMESH_MeshEditor_i::SmoothParametric(const SMESH::long_array & IDsOfElements,
960 const SMESH::long_array & IDsOfFixedNodes,
961 CORBA::Long MaxNbOfIterations,
962 CORBA::Double MaxAspectRatio,
963 SMESH::SMESH_MeshEditor::Smooth_Method Method)
965 return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
966 MaxAspectRatio, Method, true );
970 //=======================================================================
971 //function : SmoothObject
973 //=======================================================================
976 SMESH_MeshEditor_i::SmoothObject(SMESH::SMESH_IDSource_ptr theObject,
977 const SMESH::long_array & IDsOfFixedNodes,
978 CORBA::Long MaxNbOfIterations,
979 CORBA::Double MaxAspectRatio,
980 SMESH::SMESH_MeshEditor::Smooth_Method Method)
982 return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
983 MaxAspectRatio, Method, false);
987 //=======================================================================
988 //function : SmoothParametricObject
990 //=======================================================================
993 SMESH_MeshEditor_i::SmoothParametricObject(SMESH::SMESH_IDSource_ptr theObject,
994 const SMESH::long_array & IDsOfFixedNodes,
995 CORBA::Long MaxNbOfIterations,
996 CORBA::Double MaxAspectRatio,
997 SMESH::SMESH_MeshEditor::Smooth_Method Method)
999 return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
1000 MaxAspectRatio, Method, true);
1004 //=============================================================================
1008 //=============================================================================
1011 SMESH_MeshEditor_i::smooth(const SMESH::long_array & IDsOfElements,
1012 const SMESH::long_array & IDsOfFixedNodes,
1013 CORBA::Long MaxNbOfIterations,
1014 CORBA::Double MaxAspectRatio,
1015 SMESH::SMESH_MeshEditor::Smooth_Method Method,
1020 SMESHDS_Mesh* aMesh = GetMeshDS();
1022 TIDSortedElemSet elements;
1023 ToMap(IDsOfElements, aMesh, elements, SMDSAbs_Face);
1025 set<const SMDS_MeshNode*> fixedNodes;
1026 for (int i = 0; i < IDsOfFixedNodes.length(); i++) {
1027 CORBA::Long index = IDsOfFixedNodes[i];
1028 const SMDS_MeshNode * node = aMesh->FindNode(index);
1030 fixedNodes.insert( node );
1032 ::SMESH_MeshEditor::SmoothMethod method = ::SMESH_MeshEditor::LAPLACIAN;
1033 if ( Method != SMESH::SMESH_MeshEditor::LAPLACIAN_SMOOTH )
1034 method = ::SMESH_MeshEditor::CENTROIDAL;
1036 ::SMESH_MeshEditor anEditor( myMesh );
1037 anEditor.Smooth(elements, fixedNodes, method,
1038 MaxNbOfIterations, MaxAspectRatio, IsParametric );
1040 StoreResult(anEditor);
1042 // Update Python script
1043 TPythonDump() << "isDone = " << this << "."
1044 << (IsParametric ? "SmoothParametric( " : "Smooth( ")
1045 << IDsOfElements << ", " << IDsOfFixedNodes << ", "
1046 << MaxNbOfIterations << ", " << MaxAspectRatio << ", "
1047 << "SMESH.SMESH_MeshEditor."
1048 << ( Method == SMESH::SMESH_MeshEditor::CENTROIDAL_SMOOTH ?
1049 "CENTROIDAL_SMOOTH )" : "LAPLACIAN_SMOOTH )");
1051 TPythonDump() << "print 'Smooth: ', isDone";
1058 //=============================================================================
1062 //=============================================================================
1065 SMESH_MeshEditor_i::smoothObject(SMESH::SMESH_IDSource_ptr theObject,
1066 const SMESH::long_array & IDsOfFixedNodes,
1067 CORBA::Long MaxNbOfIterations,
1068 CORBA::Double MaxAspectRatio,
1069 SMESH::SMESH_MeshEditor::Smooth_Method Method,
1074 SMESH::long_array_var anElementsId = theObject->GetIDs();
1075 CORBA::Boolean isDone = smooth (anElementsId, IDsOfFixedNodes, MaxNbOfIterations,
1076 MaxAspectRatio, Method, IsParametric);
1078 // Clear python line(s), created by Smooth()
1079 SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
1080 aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
1082 aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
1085 // Update Python script
1086 TPythonDump() << "isDone = " << this << "."
1087 << (IsParametric ? "SmoothParametricObject( " : "SmoothObject( ")
1088 << theObject << ", " << IDsOfFixedNodes << ", "
1089 << MaxNbOfIterations << ", " << MaxAspectRatio << ", "
1090 << "SMESH.SMESH_MeshEditor."
1091 << ( Method == SMESH::SMESH_MeshEditor::CENTROIDAL_SMOOTH ?
1092 "CENTROIDAL_SMOOTH )" : "LAPLACIAN_SMOOTH )");
1094 TPythonDump() << "print 'SmoothObject: ', isDone";
1101 //=============================================================================
1105 //=============================================================================
1107 void SMESH_MeshEditor_i::RenumberNodes()
1109 // Update Python script
1110 TPythonDump() << this << ".RenumberNodes()";
1112 GetMeshDS()->Renumber( true );
1116 //=============================================================================
1120 //=============================================================================
1122 void SMESH_MeshEditor_i::RenumberElements()
1124 // Update Python script
1125 TPythonDump() << this << ".RenumberElements()";
1127 GetMeshDS()->Renumber( false );
1131 //=======================================================================
1132 //function : RotationSweep
1134 //=======================================================================
1136 void SMESH_MeshEditor_i::RotationSweep(const SMESH::long_array & theIDsOfElements,
1137 const SMESH::AxisStruct & theAxis,
1138 CORBA::Double theAngleInRadians,
1139 CORBA::Long theNbOfSteps,
1140 CORBA::Double theTolerance)
1144 TIDSortedElemSet inElements, copyElements;
1145 ToMap(theIDsOfElements, GetMeshDS(), inElements);
1147 TIDSortedElemSet* workElements = & inElements;
1148 TPreviewMesh tmpMesh( SMDSAbs_Face );
1149 SMESH_Mesh* mesh = 0;
1150 bool makeWalls=true;
1151 if ( myPreviewMode )
1153 SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
1154 tmpMesh.Copy( inElements, copyElements, select, avoid );
1156 workElements = & copyElements;
1157 //makeWalls = false;
1164 gp_Ax1 Ax1 (gp_Pnt( theAxis.x, theAxis.y, theAxis.z ),
1165 gp_Vec( theAxis.vx, theAxis.vy, theAxis.vz ));
1167 ::SMESH_MeshEditor anEditor( mesh );
1168 anEditor.RotationSweep (*workElements, Ax1, theAngleInRadians,
1169 theNbOfSteps, theTolerance, makeWalls);
1171 StoreResult(anEditor);
1173 if ( !myPreviewMode ) {
1174 // Update Python script
1175 TPythonDump() << "axis = " << theAxis;
1176 TPythonDump() << this << ".RotationSweep( "
1179 << theAngleInRadians << ", "
1180 << theNbOfSteps << ", "
1181 << theTolerance << " )";
1185 //=======================================================================
1186 //function : RotationSweepObject
1188 //=======================================================================
1190 void SMESH_MeshEditor_i::RotationSweepObject(SMESH::SMESH_IDSource_ptr theObject,
1191 const SMESH::AxisStruct & theAxis,
1192 CORBA::Double theAngleInRadians,
1193 CORBA::Long theNbOfSteps,
1194 CORBA::Double theTolerance)
1198 SMESH::long_array_var anElementsId = theObject->GetIDs();
1199 RotationSweep(anElementsId, theAxis, theAngleInRadians, theNbOfSteps, theTolerance);
1201 // Clear python line, created by RotationSweep()
1202 SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
1203 aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
1205 // Update Python script
1206 TPythonDump() << this << ".RotationSweepObject( "
1209 << theAngleInRadians << ", "
1210 << theNbOfSteps << ", "
1211 << theTolerance << " )";
1214 //=======================================================================
1215 //function : ExtrusionSweep
1217 //=======================================================================
1219 void SMESH_MeshEditor_i::ExtrusionSweep(const SMESH::long_array & theIDsOfElements,
1220 const SMESH::DirStruct & theStepVector,
1221 CORBA::Long theNbOfSteps)
1231 SMESHDS_Mesh* aMesh = GetMeshDS();
1233 TIDSortedElemSet elements;
1234 ToMap(theIDsOfElements, aMesh, elements);
1236 const SMESH::PointStruct * P = &theStepVector.PS;
1237 gp_Vec stepVec( P->x, P->y, P->z );
1239 TElemOfElemListMap aHystory;
1240 ::SMESH_MeshEditor anEditor( myMesh );
1241 anEditor.ExtrusionSweep (elements, stepVec, theNbOfSteps, aHystory);
1243 StoreResult(anEditor);
1245 // Update Python script
1246 TPythonDump() << "stepVector = " << theStepVector;
1247 TPythonDump() << this << ".ExtrusionSweep( "
1248 << theIDsOfElements << ", stepVector, " << theNbOfSteps << " )";
1251 } catch(Standard_Failure) {
1253 } CASCatch_CATCH(Standard_Failure) {
1255 Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1256 INFOS( "SMESH_MeshEditor_i::ExtrusionSweep fails - "<< aFail->GetMessageString() );
1261 //=======================================================================
1262 //function : ExtrusionSweepObject
1264 //=======================================================================
1266 void SMESH_MeshEditor_i::ExtrusionSweepObject(SMESH::SMESH_IDSource_ptr theObject,
1267 const SMESH::DirStruct & theStepVector,
1268 CORBA::Long theNbOfSteps)
1272 SMESH::long_array_var anElementsId = theObject->GetIDs();
1273 ExtrusionSweep(anElementsId, theStepVector, theNbOfSteps);
1275 // Clear python line, created by ExtrusionSweep()
1276 SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
1277 aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
1279 // Update Python script
1280 TPythonDump() << this << ".ExtrusionSweepObject( "
1281 << theObject << ", stepVector, " << theNbOfSteps << " )";
1284 //=======================================================================
1285 //function : ExtrusionSweepObject1D
1287 //=======================================================================
1289 void SMESH_MeshEditor_i::ExtrusionSweepObject1D(SMESH::SMESH_IDSource_ptr theObject,
1290 const SMESH::DirStruct & theStepVector,
1291 CORBA::Long theNbOfSteps)
1295 SMESHDS_Mesh* aMesh = GetMeshDS();
1297 SMESH::long_array_var allElementsId = theObject->GetIDs();
1299 TIDSortedElemSet elements;
1300 ToMap(allElementsId, aMesh, elements);
1302 const SMESH::PointStruct * P = &theStepVector.PS;
1303 gp_Vec stepVec( P->x, P->y, P->z );
1305 ::SMESH_MeshEditor anEditor( myMesh );
1306 //anEditor.ExtrusionSweep (elements, stepVec, theNbOfSteps);
1307 TElemOfElemListMap aHystory;
1308 anEditor.ExtrusionSweep (elements, stepVec, theNbOfSteps, aHystory);
1310 StoreResult(anEditor);
1312 // Update Python script
1313 TPythonDump() << "stepVector = " << theStepVector;
1314 TPythonDump() << this << ".ExtrusionSweepObject1D( "
1315 << theObject << ", stepVector, " << theNbOfSteps << " )";
1318 //=======================================================================
1319 //function : ExtrusionSweepObject2D
1321 //=======================================================================
1323 void SMESH_MeshEditor_i::ExtrusionSweepObject2D(SMESH::SMESH_IDSource_ptr theObject,
1324 const SMESH::DirStruct & theStepVector,
1325 CORBA::Long theNbOfSteps)
1329 SMESHDS_Mesh* aMesh = GetMeshDS();
1331 SMESH::long_array_var allElementsId = theObject->GetIDs();
1333 TIDSortedElemSet elements;
1334 ToMap(allElementsId, aMesh, elements);
1336 const SMESH::PointStruct * P = &theStepVector.PS;
1337 gp_Vec stepVec( P->x, P->y, P->z );
1339 ::SMESH_MeshEditor anEditor( myMesh );
1340 //anEditor.ExtrusionSweep (elements, stepVec, theNbOfSteps);
1341 TElemOfElemListMap aHystory;
1342 anEditor.ExtrusionSweep (elements, stepVec, theNbOfSteps, aHystory);
1344 StoreResult(anEditor);
1346 // Update Python script
1347 TPythonDump() << "stepVector = " << theStepVector;
1348 TPythonDump() << this << ".ExtrusionSweepObject2D( "
1349 << theObject << ", stepVector, " << theNbOfSteps << " )";
1353 //=======================================================================
1354 //function : AdvancedExtrusion
1356 //=======================================================================
1358 void SMESH_MeshEditor_i::AdvancedExtrusion(const SMESH::long_array & theIDsOfElements,
1359 const SMESH::DirStruct & theStepVector,
1360 CORBA::Long theNbOfSteps,
1361 CORBA::Long theExtrFlags,
1362 CORBA::Double theSewTolerance)
1366 SMESHDS_Mesh* aMesh = GetMeshDS();
1368 TIDSortedElemSet elements;
1369 ToMap(theIDsOfElements, aMesh, elements);
1371 const SMESH::PointStruct * P = &theStepVector.PS;
1372 gp_Vec stepVec( P->x, P->y, P->z );
1374 ::SMESH_MeshEditor anEditor( myMesh );
1375 TElemOfElemListMap aHystory;
1376 anEditor.ExtrusionSweep (elements, stepVec, theNbOfSteps, aHystory,
1377 theExtrFlags, theSewTolerance);
1379 StoreResult(anEditor);
1381 // Update Python script
1382 TPythonDump() << "stepVector = " << theStepVector;
1383 TPythonDump() << this << ".AdvancedExtrusion("
1386 << theNbOfSteps << ","
1387 << theExtrFlags << ", "
1388 << theSewTolerance << " )";
1392 #define RETCASE(enm) case ::SMESH_MeshEditor::enm: return SMESH::SMESH_MeshEditor::enm;
1394 static SMESH::SMESH_MeshEditor::Extrusion_Error convExtrError( const::SMESH_MeshEditor::Extrusion_Error e )
1398 RETCASE( EXTR_NO_ELEMENTS );
1399 RETCASE( EXTR_PATH_NOT_EDGE );
1400 RETCASE( EXTR_BAD_PATH_SHAPE );
1401 RETCASE( EXTR_BAD_STARTING_NODE );
1402 RETCASE( EXTR_BAD_ANGLES_NUMBER );
1403 RETCASE( EXTR_CANT_GET_TANGENT );
1405 return SMESH::SMESH_MeshEditor::EXTR_OK;
1408 //=======================================================================
1409 //function : ExtrusionAlongPath
1411 //=======================================================================
1413 SMESH::SMESH_MeshEditor::Extrusion_Error
1414 SMESH_MeshEditor_i::ExtrusionAlongPath(const SMESH::long_array & theIDsOfElements,
1415 SMESH::SMESH_Mesh_ptr thePathMesh,
1416 GEOM::GEOM_Object_ptr thePathShape,
1417 CORBA::Long theNodeStart,
1418 CORBA::Boolean theHasAngles,
1419 const SMESH::double_array & theAngles,
1420 CORBA::Boolean theHasRefPoint,
1421 const SMESH::PointStruct & theRefPoint)
1425 SMESHDS_Mesh* aMesh = GetMeshDS();
1427 if ( thePathMesh->_is_nil() || thePathShape->_is_nil() )
1428 return SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
1430 SMESH_Mesh_i* aMeshImp = dynamic_cast<SMESH_Mesh_i*>( SMESH_Gen_i::GetServant( thePathMesh ).in() );
1431 TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( thePathShape );
1432 SMESH_subMesh* aSubMesh = aMeshImp->GetImpl().GetSubMesh( aShape );
1434 if ( !aSubMesh || !aSubMesh->GetSubMeshDS())
1435 return SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
1437 SMDS_MeshNode* nodeStart = (SMDS_MeshNode*)aMeshImp->GetImpl().GetMeshDS()->FindNode(theNodeStart);
1439 return SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE;
1441 TIDSortedElemSet elements;
1442 ToMap(theIDsOfElements, aMesh, elements);
1444 list<double> angles;
1445 for (int i = 0; i < theAngles.length(); i++) {
1446 angles.push_back( theAngles[i] );
1449 gp_Pnt refPnt( theRefPoint.x, theRefPoint.y, theRefPoint.z );
1451 // Update Python script
1452 TPythonDump() << "rotAngles = " << theAngles;
1454 if ( theHasRefPoint )
1455 TPythonDump() << "refPoint = SMESH.PointStruct( "
1456 << refPnt.X() << ", "
1457 << refPnt.Y() << ", "
1458 << refPnt.Z() << " )";
1460 TPythonDump() << "refPoint = SMESH.PointStruct( 0,0,0 )";
1462 TPythonDump() << "error = " << this << ".ExtrusionAlongPath( "
1463 << theIDsOfElements << ", "
1464 << thePathMesh << ", "
1465 << thePathShape << ", "
1466 << theNodeStart << ", "
1467 << theHasAngles << ", "
1468 << "rotAngles" << ", "
1469 << theHasRefPoint << ", refPoint )";
1471 ::SMESH_MeshEditor anEditor( myMesh );
1472 SMESH::SMESH_MeshEditor::Extrusion_Error error =
1473 convExtrError( anEditor.ExtrusionAlongTrack( elements, aSubMesh, nodeStart,
1474 theHasAngles, angles,
1475 theHasRefPoint, refPnt ) );
1477 StoreResult(anEditor);
1482 //=======================================================================
1483 //function : ExtrusionAlongPathObject
1485 //=======================================================================
1487 SMESH::SMESH_MeshEditor::Extrusion_Error
1488 SMESH_MeshEditor_i::ExtrusionAlongPathObject(SMESH::SMESH_IDSource_ptr theObject,
1489 SMESH::SMESH_Mesh_ptr thePathMesh,
1490 GEOM::GEOM_Object_ptr thePathShape,
1491 CORBA::Long theNodeStart,
1492 CORBA::Boolean theHasAngles,
1493 const SMESH::double_array & theAngles,
1494 CORBA::Boolean theHasRefPoint,
1495 const SMESH::PointStruct & theRefPoint)
1499 SMESH::long_array_var anElementsId = theObject->GetIDs();
1500 SMESH::SMESH_MeshEditor::Extrusion_Error error = ExtrusionAlongPath
1501 (anElementsId, thePathMesh, thePathShape, theNodeStart,
1502 theHasAngles, theAngles, theHasRefPoint, theRefPoint);
1504 // Clear python line, created by ExtrusionAlongPath()
1505 SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
1506 aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
1508 // Update Python script
1509 TPythonDump() << "rotAngles = " << theAngles;
1510 TPythonDump() << "error = " << this << ".ExtrusionAlongPathObject( "
1511 << theObject << ", "
1512 << thePathMesh << ", "
1513 << thePathShape << ", "
1514 << theNodeStart << ", "
1515 << theHasAngles << ", "
1516 << "rotAngles" << ", "
1517 << theHasRefPoint<<", refPoint )";
1522 //================================================================================
1524 * \brief Compute rotation angles for ExtrusionAlongPath as linear variation
1525 * of given angles along path steps
1526 * \param PathMesh mesh containing a 1D sub-mesh on the edge, along
1527 * which proceeds the extrusion
1528 * \param PathShape is shape(edge); as the mesh can be complex, the edge
1529 * is used to define the sub-mesh for the path
1531 //================================================================================
1533 SMESH::double_array*
1534 SMESH_MeshEditor_i::LinearAnglesVariation(SMESH::SMESH_Mesh_ptr thePathMesh,
1535 GEOM::GEOM_Object_ptr thePathShape,
1536 const SMESH::double_array & theAngles)
1538 SMESH::double_array_var aResult = new SMESH::double_array();
1539 return aResult._retn();
1542 //=======================================================================
1545 //=======================================================================
1547 void SMESH_MeshEditor_i::Mirror(const SMESH::long_array & theIDsOfElements,
1548 const SMESH::AxisStruct & theAxis,
1549 SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
1550 CORBA::Boolean theCopy)
1554 SMESHDS_Mesh* aMesh = GetMeshDS();
1556 TIDSortedElemSet elements;
1557 ToMap(theIDsOfElements, aMesh, elements);
1559 gp_Pnt P ( theAxis.x, theAxis.y, theAxis.z );
1560 gp_Vec V ( theAxis.vx, theAxis.vy, theAxis.vz );
1563 TCollection_AsciiString typeStr;
1564 switch ( theMirrorType ) {
1565 case SMESH::SMESH_MeshEditor::POINT:
1566 aTrsf.SetMirror( P );
1567 typeStr = "SMESH.SMESH_MeshEditor.POINT";
1569 case SMESH::SMESH_MeshEditor::AXIS:
1570 aTrsf.SetMirror( gp_Ax1( P, V ));
1571 typeStr = "SMESH.SMESH_MeshEditor.AXIS";
1574 aTrsf.SetMirror( gp_Ax2( P, V ));
1575 typeStr = "SMESH.SMESH_MeshEditor.PLANE";
1578 // Update Python script
1579 TPythonDump() << this << ".Mirror( "
1580 << theIDsOfElements << ", "
1585 ::SMESH_MeshEditor anEditor( myMesh );
1586 anEditor.Transform (elements, aTrsf, theCopy);
1589 StoreResult(anEditor);
1594 //=======================================================================
1595 //function : MirrorObject
1597 //=======================================================================
1599 void SMESH_MeshEditor_i::MirrorObject(SMESH::SMESH_IDSource_ptr theObject,
1600 const SMESH::AxisStruct & theAxis,
1601 SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
1602 CORBA::Boolean theCopy)
1606 SMESH::long_array_var anElementsId = theObject->GetIDs();
1607 Mirror(anElementsId, theAxis, theMirrorType, theCopy);
1609 // Clear python line, created by Mirror()
1610 SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
1611 aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
1613 // Update Python script
1614 TCollection_AsciiString typeStr;
1615 switch ( theMirrorType ) {
1616 case SMESH::SMESH_MeshEditor::POINT:
1617 typeStr = "SMESH.SMESH_MeshEditor.POINT";
1619 case SMESH::SMESH_MeshEditor::AXIS:
1620 typeStr = "SMESH.SMESH_MeshEditor.AXIS";
1623 typeStr = "SMESH.SMESH_MeshEditor.PLANE";
1625 TPythonDump() << "axis = " << theAxis;
1626 TPythonDump() << this << ".MirrorObject( "
1627 << theObject << ", "
1633 //=======================================================================
1634 //function : Translate
1636 //=======================================================================
1638 void SMESH_MeshEditor_i::Translate(const SMESH::long_array & theIDsOfElements,
1639 const SMESH::DirStruct & theVector,
1640 CORBA::Boolean theCopy)
1644 SMESHDS_Mesh* aMesh = GetMeshDS();
1646 TIDSortedElemSet elements;
1647 ToMap(theIDsOfElements, aMesh, elements);
1650 const SMESH::PointStruct * P = &theVector.PS;
1651 aTrsf.SetTranslation( gp_Vec( P->x, P->y, P->z ));
1653 ::SMESH_MeshEditor anEditor( myMesh );
1654 anEditor.Transform (elements, aTrsf, theCopy);
1657 StoreResult(anEditor);
1660 // Update Python script
1661 TPythonDump() << "vector = " << theVector;
1662 TPythonDump() << this << ".Translate( "
1668 //=======================================================================
1669 //function : TranslateObject
1671 //=======================================================================
1673 void SMESH_MeshEditor_i::TranslateObject(SMESH::SMESH_IDSource_ptr theObject,
1674 const SMESH::DirStruct & theVector,
1675 CORBA::Boolean theCopy)
1679 SMESH::long_array_var anElementsId = theObject->GetIDs();
1680 Translate(anElementsId, theVector, theCopy);
1682 // Clear python line, created by Translate()
1683 SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
1684 aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
1686 // Update Python script
1687 TPythonDump() << this << ".TranslateObject( "
1693 //=======================================================================
1696 //=======================================================================
1698 void SMESH_MeshEditor_i::Rotate(const SMESH::long_array & theIDsOfElements,
1699 const SMESH::AxisStruct & theAxis,
1700 CORBA::Double theAngle,
1701 CORBA::Boolean theCopy)
1705 SMESHDS_Mesh* aMesh = GetMeshDS();
1707 TIDSortedElemSet elements;
1708 ToMap(theIDsOfElements, aMesh, elements);
1710 gp_Pnt P ( theAxis.x, theAxis.y, theAxis.z );
1711 gp_Vec V ( theAxis.vx, theAxis.vy, theAxis.vz );
1714 aTrsf.SetRotation( gp_Ax1( P, V ), theAngle);
1716 ::SMESH_MeshEditor anEditor( myMesh );
1717 anEditor.Transform (elements, aTrsf, theCopy);
1720 StoreResult(anEditor);
1723 // Update Python script
1724 TPythonDump() << "axis = " << theAxis;
1725 TPythonDump() << this << ".Rotate( "
1732 //=======================================================================
1733 //function : RotateObject
1735 //=======================================================================
1737 void SMESH_MeshEditor_i::RotateObject(SMESH::SMESH_IDSource_ptr theObject,
1738 const SMESH::AxisStruct & theAxis,
1739 CORBA::Double theAngle,
1740 CORBA::Boolean theCopy)
1744 SMESH::long_array_var anElementsId = theObject->GetIDs();
1745 Rotate(anElementsId, theAxis, theAngle, theCopy);
1747 // Clear python line, created by Rotate()
1748 SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
1749 aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
1751 // Update Python script
1752 TPythonDump() << this << ".RotateObject( "
1759 //=======================================================================
1760 //function : FindCoincidentNodes
1762 //=======================================================================
1764 void SMESH_MeshEditor_i::FindCoincidentNodes (CORBA::Double Tolerance,
1765 SMESH::array_of_long_array_out GroupsOfNodes)
1769 ::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
1770 ::SMESH_MeshEditor anEditor( myMesh );
1771 set<const SMDS_MeshNode*> nodes; // no input nodes
1772 anEditor.FindCoincidentNodes( nodes, Tolerance, aListOfListOfNodes );
1774 GroupsOfNodes = new SMESH::array_of_long_array;
1775 GroupsOfNodes->length( aListOfListOfNodes.size() );
1776 ::SMESH_MeshEditor::TListOfListOfNodes::iterator llIt = aListOfListOfNodes.begin();
1777 for ( CORBA::Long i = 0; llIt != aListOfListOfNodes.end(); llIt++, i++ ) {
1778 list< const SMDS_MeshNode* >& aListOfNodes = *llIt;
1779 list< const SMDS_MeshNode* >::iterator lIt = aListOfNodes.begin();;
1780 SMESH::long_array& aGroup = GroupsOfNodes[ i ];
1781 aGroup.length( aListOfNodes.size() );
1782 for ( int j = 0; lIt != aListOfNodes.end(); lIt++, j++ )
1783 aGroup[ j ] = (*lIt)->GetID();
1785 // Update Python script
1786 TPythonDump() << "coincident_nodes = " << this << ".FindCoincidentNodes( "
1787 << Tolerance << " )";
1790 //=======================================================================
1791 //function : FindCoincidentNodesOnPart
1793 //=======================================================================
1794 void SMESH_MeshEditor_i::FindCoincidentNodesOnPart(SMESH::SMESH_IDSource_ptr theObject,
1795 CORBA::Double Tolerance,
1796 SMESH::array_of_long_array_out GroupsOfNodes)
1799 SMESH::long_array_var aElementsId = theObject->GetIDs();
1801 SMESHDS_Mesh* aMesh = GetMeshDS();
1802 set<const SMDS_MeshNode*> nodes;
1804 if ( !CORBA::is_nil(SMESH::SMESH_GroupBase::_narrow(theObject)) &&
1805 SMESH::SMESH_GroupBase::_narrow(theObject)->GetType() == SMESH::NODE) {
1806 for(int i = 0; i < aElementsId->length(); i++) {
1807 CORBA::Long ind = aElementsId[i];
1808 const SMDS_MeshNode * elem = aMesh->FindNode(ind);
1814 for(int i = 0; i < aElementsId->length(); i++) {
1815 CORBA::Long ind = aElementsId[i];
1816 const SMDS_MeshElement * elem = aMesh->FindElement(ind);
1818 SMDS_ElemIteratorPtr nIt = elem->nodesIterator();
1819 while ( nIt->more() )
1820 nodes.insert( nodes.end(),static_cast<const SMDS_MeshNode*>(nIt->next()));
1826 ::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
1827 ::SMESH_MeshEditor anEditor( myMesh );
1829 anEditor.FindCoincidentNodes( nodes, Tolerance, aListOfListOfNodes );
1831 GroupsOfNodes = new SMESH::array_of_long_array;
1832 GroupsOfNodes->length( aListOfListOfNodes.size() );
1833 ::SMESH_MeshEditor::TListOfListOfNodes::iterator llIt = aListOfListOfNodes.begin();
1834 for ( CORBA::Long i = 0; llIt != aListOfListOfNodes.end(); llIt++, i++ ) {
1835 list< const SMDS_MeshNode* >& aListOfNodes = *llIt;
1836 list< const SMDS_MeshNode* >::iterator lIt = aListOfNodes.begin();;
1837 SMESH::long_array& aGroup = GroupsOfNodes[ i ];
1838 aGroup.length( aListOfNodes.size() );
1839 for ( int j = 0; lIt != aListOfNodes.end(); lIt++, j++ )
1840 aGroup[ j ] = (*lIt)->GetID();
1842 // Update Python script
1843 TPythonDump() << "coincident_nodes_on_part = " << this << ".FindCoincidentNodesOnPart( "
1845 << Tolerance << " )";
1848 //=======================================================================
1849 //function : MergeNodes
1851 //=======================================================================
1853 void SMESH_MeshEditor_i::MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes)
1857 SMESHDS_Mesh* aMesh = GetMeshDS();
1859 TPythonDump aTPythonDump;
1860 aTPythonDump << this << ".MergeNodes([";
1861 ::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
1862 for (int i = 0; i < GroupsOfNodes.length(); i++)
1864 const SMESH::long_array& aNodeGroup = GroupsOfNodes[ i ];
1865 aListOfListOfNodes.push_back( list< const SMDS_MeshNode* >() );
1866 list< const SMDS_MeshNode* >& aListOfNodes = aListOfListOfNodes.back();
1867 for ( int j = 0; j < aNodeGroup.length(); j++ )
1869 CORBA::Long index = aNodeGroup[ j ];
1870 const SMDS_MeshNode * node = aMesh->FindNode(index);
1872 aListOfNodes.push_back( node );
1874 if ( aListOfNodes.size() < 2 )
1875 aListOfListOfNodes.pop_back();
1877 if ( i > 0 ) aTPythonDump << ", ";
1878 aTPythonDump << aNodeGroup;
1880 ::SMESH_MeshEditor anEditor( myMesh );
1881 anEditor.MergeNodes( aListOfListOfNodes );
1883 // Update Python script
1884 aTPythonDump << "])";
1887 //=======================================================================
1888 //function : FindEqualElements
1890 //=======================================================================
1891 void SMESH_MeshEditor_i::FindEqualElements(SMESH::SMESH_IDSource_ptr theObject,
1892 SMESH::array_of_long_array_out GroupsOfElementsID)
1895 if ( !(!CORBA::is_nil(SMESH::SMESH_GroupBase::_narrow(theObject)) &&
1896 SMESH::SMESH_GroupBase::_narrow(theObject)->GetType() == SMESH::NODE) ) {
1897 typedef list<int> TListOfIDs;
1898 set<const SMDS_MeshElement*> elems;
1899 SMESH::long_array_var aElementsId = theObject->GetIDs();
1900 SMESHDS_Mesh* aMesh = GetMeshDS();
1902 for(int i = 0; i < aElementsId->length(); i++) {
1903 CORBA::Long anID = aElementsId[i];
1904 const SMDS_MeshElement * elem = aMesh->FindElement(anID);
1910 ::SMESH_MeshEditor::TListOfListOfElementsID aListOfListOfElementsID;
1911 ::SMESH_MeshEditor anEditor( myMesh );
1912 anEditor.FindEqualElements( elems, aListOfListOfElementsID );
1914 GroupsOfElementsID = new SMESH::array_of_long_array;
1915 GroupsOfElementsID->length( aListOfListOfElementsID.size() );
1917 ::SMESH_MeshEditor::TListOfListOfElementsID::iterator arraysIt = aListOfListOfElementsID.begin();
1918 for (CORBA::Long j = 0; arraysIt != aListOfListOfElementsID.end(); ++arraysIt, ++j) {
1919 SMESH::long_array& aGroup = GroupsOfElementsID[ j ];
1920 TListOfIDs& listOfIDs = *arraysIt;
1921 aGroup.length( listOfIDs.size() );
1922 TListOfIDs::iterator idIt = listOfIDs.begin();
1923 for (int k = 0; idIt != listOfIDs.end(); ++idIt, ++k ) {
1924 aGroup[ k ] = *idIt;
1928 // Update Python script
1929 TPythonDump() << "equal_elements = " << this << ".FindEqualElements( "
1934 //=======================================================================
1935 //function : MergeElements
1937 //=======================================================================
1939 void SMESH_MeshEditor_i::MergeElements(const SMESH::array_of_long_array& GroupsOfElementsID)
1943 TPythonDump aTPythonDump;
1944 aTPythonDump << this << ".MergeElements( [";
1946 ::SMESH_MeshEditor::TListOfListOfElementsID aListOfListOfElementsID;
1948 for (int i = 0; i < GroupsOfElementsID.length(); i++) {
1949 const SMESH::long_array& anElemsIDGroup = GroupsOfElementsID[ i ];
1950 aListOfListOfElementsID.push_back( list< int >() );
1951 list< int >& aListOfElemsID = aListOfListOfElementsID.back();
1952 for ( int j = 0; j < anElemsIDGroup.length(); j++ ) {
1953 CORBA::Long id = anElemsIDGroup[ j ];
1954 aListOfElemsID.push_back( id );
1956 if ( aListOfElemsID.size() < 2 )
1957 aListOfListOfElementsID.pop_back();
1958 if ( i > 0 ) aTPythonDump << ", ";
1959 aTPythonDump << anElemsIDGroup;
1962 ::SMESH_MeshEditor anEditor( myMesh );
1963 anEditor.MergeElements(aListOfListOfElementsID);
1965 // Update Python script
1966 aTPythonDump << "] )";
1969 //=======================================================================
1970 //function : MergeEqualElements
1972 //=======================================================================
1974 void SMESH_MeshEditor_i::MergeEqualElements()
1978 ::SMESH_MeshEditor anEditor( myMesh );
1979 anEditor.MergeEqualElements();
1981 // Update Python script
1982 TPythonDump() << this << ".MergeEqualElements()";
1985 //================================================================================
1987 * \brief If the given ID is a valid node ID (nodeID > 0), just move this node, else
1988 * move the node closest to the point to point's location and return ID of the node
1990 //================================================================================
1992 CORBA::Long SMESH_MeshEditor_i::MoveClosestNodeToPoint(CORBA::Double x,
1995 CORBA::Long theNodeID)
1997 // We keep myNodeSearcher until any mesh modification:
1998 // 1) initData() deletes myNodeSearcher at any edition,
1999 // 2) TNodeSearcherDeleter - at any mesh compute event and mesh change
2003 int nodeID = theNodeID;
2004 const SMDS_MeshNode* node = GetMeshDS()->FindNode( nodeID );
2007 static TNodeSearcherDeleter deleter;
2008 deleter.Set( myMesh );
2009 if ( !myNodeSearcher ) {
2010 ::SMESH_MeshEditor anEditor( myMesh );
2011 myNodeSearcher = anEditor.GetNodeSearcher();
2014 node = myNodeSearcher->FindClosestTo( p );
2017 nodeID = node->GetID();
2018 if ( myPreviewMode ) // make preview data
2020 // in a preview mesh, make edges linked to a node
2021 TPreviewMesh tmpMesh;
2022 TIDSortedElemSet linkedNodes;
2023 ::SMESH_MeshEditor::GetLinkedNodes( node, linkedNodes );
2024 TIDSortedElemSet::iterator nIt = linkedNodes.begin();
2025 for ( ; nIt != linkedNodes.end(); ++nIt )
2027 SMDS_MeshEdge edge( node, cast2Node( *nIt ));
2028 tmpMesh.Copy( &edge );
2031 node = tmpMesh.GetMeshDS()->FindNode( nodeID );
2033 tmpMesh.GetMeshDS()->MoveNode(node, x, y, z);
2034 // fill preview data
2035 ::SMESH_MeshEditor anEditor( & tmpMesh );
2036 StoreResult( anEditor );
2040 GetMeshDS()->MoveNode(node, x, y, z);
2044 if ( !myPreviewMode ) {
2045 // Update Python script
2046 TPythonDump() << "nodeID = " << this
2047 << ".MoveClosestNodeToPoint( "<< x << ", " << y << ", " << z << " )";
2053 //=======================================================================
2054 //function : convError
2056 //=======================================================================
2058 #define RETCASE(enm) case ::SMESH_MeshEditor::enm: return SMESH::SMESH_MeshEditor::enm;
2060 static SMESH::SMESH_MeshEditor::Sew_Error convError( const::SMESH_MeshEditor::Sew_Error e )
2064 RETCASE( SEW_BORDER1_NOT_FOUND );
2065 RETCASE( SEW_BORDER2_NOT_FOUND );
2066 RETCASE( SEW_BOTH_BORDERS_NOT_FOUND );
2067 RETCASE( SEW_BAD_SIDE_NODES );
2068 RETCASE( SEW_VOLUMES_TO_SPLIT );
2069 RETCASE( SEW_DIFF_NB_OF_ELEMENTS );
2070 RETCASE( SEW_TOPO_DIFF_SETS_OF_ELEMENTS );
2071 RETCASE( SEW_BAD_SIDE1_NODES );
2072 RETCASE( SEW_BAD_SIDE2_NODES );
2074 return SMESH::SMESH_MeshEditor::SEW_OK;
2077 //=======================================================================
2078 //function : SewFreeBorders
2080 //=======================================================================
2082 SMESH::SMESH_MeshEditor::Sew_Error
2083 SMESH_MeshEditor_i::SewFreeBorders(CORBA::Long FirstNodeID1,
2084 CORBA::Long SecondNodeID1,
2085 CORBA::Long LastNodeID1,
2086 CORBA::Long FirstNodeID2,
2087 CORBA::Long SecondNodeID2,
2088 CORBA::Long LastNodeID2,
2089 CORBA::Boolean CreatePolygons,
2090 CORBA::Boolean CreatePolyedrs)
2094 SMESHDS_Mesh* aMesh = GetMeshDS();
2096 const SMDS_MeshNode* aBorderFirstNode = aMesh->FindNode( FirstNodeID1 );
2097 const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeID1 );
2098 const SMDS_MeshNode* aBorderLastNode = aMesh->FindNode( LastNodeID1 );
2099 const SMDS_MeshNode* aSide2FirstNode = aMesh->FindNode( FirstNodeID2 );
2100 const SMDS_MeshNode* aSide2SecondNode = aMesh->FindNode( SecondNodeID2 );
2101 const SMDS_MeshNode* aSide2ThirdNode = aMesh->FindNode( LastNodeID2 );
2103 if (!aBorderFirstNode ||
2104 !aBorderSecondNode||
2106 return SMESH::SMESH_MeshEditor::SEW_BORDER1_NOT_FOUND;
2107 if (!aSide2FirstNode ||
2108 !aSide2SecondNode ||
2110 return SMESH::SMESH_MeshEditor::SEW_BORDER2_NOT_FOUND;
2112 // Update Python script
2113 TPythonDump() << "error = " << this << ".SewFreeBorders( "
2114 << FirstNodeID1 << ", "
2115 << SecondNodeID1 << ", "
2116 << LastNodeID1 << ", "
2117 << FirstNodeID2 << ", "
2118 << SecondNodeID2 << ", "
2119 << LastNodeID2 << ", "
2120 << CreatePolygons<< ", "
2121 << CreatePolyedrs<< " )";
2123 ::SMESH_MeshEditor anEditor( myMesh );
2124 SMESH::SMESH_MeshEditor::Sew_Error error =
2125 convError( anEditor.SewFreeBorder (aBorderFirstNode,
2135 StoreResult(anEditor);
2141 //=======================================================================
2142 //function : SewConformFreeBorders
2144 //=======================================================================
2146 SMESH::SMESH_MeshEditor::Sew_Error
2147 SMESH_MeshEditor_i::SewConformFreeBorders(CORBA::Long FirstNodeID1,
2148 CORBA::Long SecondNodeID1,
2149 CORBA::Long LastNodeID1,
2150 CORBA::Long FirstNodeID2,
2151 CORBA::Long SecondNodeID2)
2155 SMESHDS_Mesh* aMesh = GetMeshDS();
2157 const SMDS_MeshNode* aBorderFirstNode = aMesh->FindNode( FirstNodeID1 );
2158 const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeID1 );
2159 const SMDS_MeshNode* aBorderLastNode = aMesh->FindNode( LastNodeID1 );
2160 const SMDS_MeshNode* aSide2FirstNode = aMesh->FindNode( FirstNodeID2 );
2161 const SMDS_MeshNode* aSide2SecondNode = aMesh->FindNode( SecondNodeID2 );
2162 const SMDS_MeshNode* aSide2ThirdNode = 0;
2164 if (!aBorderFirstNode ||
2165 !aBorderSecondNode||
2167 return SMESH::SMESH_MeshEditor::SEW_BORDER1_NOT_FOUND;
2168 if (!aSide2FirstNode ||
2170 return SMESH::SMESH_MeshEditor::SEW_BORDER2_NOT_FOUND;
2172 // Update Python script
2173 TPythonDump() << "error = " << this << ".SewConformFreeBorders( "
2174 << FirstNodeID1 << ", "
2175 << SecondNodeID1 << ", "
2176 << LastNodeID1 << ", "
2177 << FirstNodeID2 << ", "
2178 << SecondNodeID2 << " )";
2180 ::SMESH_MeshEditor anEditor( myMesh );
2181 SMESH::SMESH_MeshEditor::Sew_Error error =
2182 convError( anEditor.SewFreeBorder (aBorderFirstNode,
2191 StoreResult(anEditor);
2197 //=======================================================================
2198 //function : SewBorderToSide
2200 //=======================================================================
2202 SMESH::SMESH_MeshEditor::Sew_Error
2203 SMESH_MeshEditor_i::SewBorderToSide(CORBA::Long FirstNodeIDOnFreeBorder,
2204 CORBA::Long SecondNodeIDOnFreeBorder,
2205 CORBA::Long LastNodeIDOnFreeBorder,
2206 CORBA::Long FirstNodeIDOnSide,
2207 CORBA::Long LastNodeIDOnSide,
2208 CORBA::Boolean CreatePolygons,
2209 CORBA::Boolean CreatePolyedrs)
2213 SMESHDS_Mesh* aMesh = GetMeshDS();
2215 const SMDS_MeshNode* aBorderFirstNode = aMesh->FindNode( FirstNodeIDOnFreeBorder );
2216 const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeIDOnFreeBorder );
2217 const SMDS_MeshNode* aBorderLastNode = aMesh->FindNode( LastNodeIDOnFreeBorder );
2218 const SMDS_MeshNode* aSide2FirstNode = aMesh->FindNode( FirstNodeIDOnSide );
2219 const SMDS_MeshNode* aSide2SecondNode = aMesh->FindNode( LastNodeIDOnSide );
2220 const SMDS_MeshNode* aSide2ThirdNode = 0;
2222 if (!aBorderFirstNode ||
2223 !aBorderSecondNode||
2225 return SMESH::SMESH_MeshEditor::SEW_BORDER1_NOT_FOUND;
2226 if (!aSide2FirstNode ||
2228 return SMESH::SMESH_MeshEditor::SEW_BAD_SIDE_NODES;
2230 // Update Python script
2231 TPythonDump() << "error = " << this << ".SewBorderToSide( "
2232 << FirstNodeIDOnFreeBorder << ", "
2233 << SecondNodeIDOnFreeBorder << ", "
2234 << LastNodeIDOnFreeBorder << ", "
2235 << FirstNodeIDOnSide << ", "
2236 << LastNodeIDOnSide << ", "
2237 << CreatePolygons << ", "
2238 << CreatePolyedrs << ") ";
2240 ::SMESH_MeshEditor anEditor( myMesh );
2241 SMESH::SMESH_MeshEditor::Sew_Error error =
2242 convError( anEditor.SewFreeBorder (aBorderFirstNode,
2252 StoreResult(anEditor);
2258 //=======================================================================
2259 //function : SewSideElements
2261 //=======================================================================
2263 SMESH::SMESH_MeshEditor::Sew_Error
2264 SMESH_MeshEditor_i::SewSideElements(const SMESH::long_array& IDsOfSide1Elements,
2265 const SMESH::long_array& IDsOfSide2Elements,
2266 CORBA::Long NodeID1OfSide1ToMerge,
2267 CORBA::Long NodeID1OfSide2ToMerge,
2268 CORBA::Long NodeID2OfSide1ToMerge,
2269 CORBA::Long NodeID2OfSide2ToMerge)
2273 SMESHDS_Mesh* aMesh = GetMeshDS();
2275 const SMDS_MeshNode* aFirstNode1ToMerge = aMesh->FindNode( NodeID1OfSide1ToMerge );
2276 const SMDS_MeshNode* aFirstNode2ToMerge = aMesh->FindNode( NodeID1OfSide2ToMerge );
2277 const SMDS_MeshNode* aSecondNode1ToMerge = aMesh->FindNode( NodeID2OfSide1ToMerge );
2278 const SMDS_MeshNode* aSecondNode2ToMerge = aMesh->FindNode( NodeID2OfSide2ToMerge );
2280 if (!aFirstNode1ToMerge ||
2281 !aFirstNode2ToMerge )
2282 return SMESH::SMESH_MeshEditor::SEW_BAD_SIDE1_NODES;
2283 if (!aSecondNode1ToMerge||
2284 !aSecondNode2ToMerge)
2285 return SMESH::SMESH_MeshEditor::SEW_BAD_SIDE2_NODES;
2287 TIDSortedElemSet aSide1Elems, aSide2Elems;
2288 ToMap(IDsOfSide1Elements, aMesh, aSide1Elems);
2289 ToMap(IDsOfSide2Elements, aMesh, aSide2Elems);
2291 // Update Python script
2292 TPythonDump() << "error = " << this << ".SewSideElements( "
2293 << IDsOfSide1Elements << ", "
2294 << IDsOfSide2Elements << ", "
2295 << NodeID1OfSide1ToMerge << ", "
2296 << NodeID1OfSide2ToMerge << ", "
2297 << NodeID2OfSide1ToMerge << ", "
2298 << NodeID2OfSide2ToMerge << ")";
2300 ::SMESH_MeshEditor anEditor( myMesh );
2301 SMESH::SMESH_MeshEditor::Sew_Error error =
2302 convError( anEditor.SewSideElements (aSide1Elems, aSide2Elems,
2305 aSecondNode1ToMerge,
2306 aSecondNode2ToMerge));
2308 StoreResult(anEditor);
2313 //================================================================================
2315 * \brief Set new nodes for given element
2316 * \param ide - element id
2317 * \param newIDs - new node ids
2318 * \retval CORBA::Boolean - true if result is OK
2320 //================================================================================
2322 CORBA::Boolean SMESH_MeshEditor_i::ChangeElemNodes(CORBA::Long ide,
2323 const SMESH::long_array& newIDs)
2327 const SMDS_MeshElement* elem = GetMeshDS()->FindElement(ide);
2328 if(!elem) return false;
2330 int nbn = newIDs.length();
2332 const SMDS_MeshNode* aNodes [nbn];
2335 const SMDS_MeshNode* aNode = GetMeshDS()->FindNode(newIDs[i]);
2338 aNodes[nbn1] = aNode;
2341 // Update Python script
2342 TPythonDump() << "isDone = " << this << ".ChangeElemNodes( "
2343 << ide << ", " << newIDs << " )";
2345 TPythonDump() << "print 'ChangeElemNodes: ', isDone";
2348 return GetMeshDS()->ChangeElementNodes( elem, aNodes, nbn1+1 );
2351 //================================================================================
2353 * \brief Update myLastCreated* or myPreviewData
2354 * \param anEditor - it contains last modification results
2356 //================================================================================
2358 void SMESH_MeshEditor_i::StoreResult(::SMESH_MeshEditor& anEditor)
2360 if ( myPreviewMode ) { // --- MeshPreviewStruct filling ---
2362 list<int> aNodesConnectivity;
2363 typedef map<int, int> TNodesMap;
2366 TPreviewMesh * aPreviewMesh = dynamic_cast< TPreviewMesh* >( anEditor.GetMesh() );
2367 SMDSAbs_ElementType previewType = aPreviewMesh->myPreviewType;
2369 SMESHDS_Mesh* aMeshDS = anEditor.GetMeshDS();
2370 int nbEdges = aMeshDS->NbEdges();
2371 int nbFaces = aMeshDS->NbFaces();
2372 int nbVolum = aMeshDS->NbVolumes();
2373 switch ( previewType ) {
2374 case SMDSAbs_Edge : nbFaces = nbVolum = 0; break;
2375 case SMDSAbs_Face : nbEdges = nbVolum = 0; break;
2376 case SMDSAbs_Volume: nbEdges = nbFaces = 0; break;
2379 myPreviewData->nodesXYZ.length(aMeshDS->NbNodes());
2380 myPreviewData->elementTypes.length(nbEdges + nbFaces + nbVolum);
2382 SMDS_ElemIteratorPtr itMeshElems = aMeshDS->elementsIterator();
2384 while ( itMeshElems->more() ) {
2385 const SMDS_MeshElement* aMeshElem = itMeshElems->next();
2386 if ( previewType != SMDSAbs_All && aMeshElem->GetType() != previewType )
2389 SMDS_ElemIteratorPtr itElemNodes = aMeshElem->nodesIterator();
2390 while ( itElemNodes->more() ) {
2391 const SMDS_MeshNode* aMeshNode =
2392 static_cast<const SMDS_MeshNode*>( itElemNodes->next() );
2393 int aNodeID = aMeshNode->GetID();
2394 TNodesMap::iterator anIter = nodesMap.find(aNodeID);
2395 if ( anIter == nodesMap.end() ) {
2396 // filling the nodes coordinates
2397 myPreviewData->nodesXYZ[j].x = aMeshNode->X();
2398 myPreviewData->nodesXYZ[j].y = aMeshNode->Y();
2399 myPreviewData->nodesXYZ[j].z = aMeshNode->Z();
2400 anIter = nodesMap.insert( make_pair(aNodeID, j) ).first;
2403 aNodesConnectivity.push_back(anIter->second);
2406 // filling the elements types
2407 SMDSAbs_ElementType aType;
2409 /*if (aMeshElem->GetType() == SMDSAbs_Volume) {
2410 aType = SMDSAbs_Node;
2414 aType = aMeshElem->GetType();
2415 isPoly = aMeshElem->IsPoly();
2418 myPreviewData->elementTypes[i].SMDS_ElementType = (SMESH::ElementType) aType;
2419 myPreviewData->elementTypes[i].isPoly = isPoly;
2420 myPreviewData->elementTypes[i].nbNodesInElement = aMeshElem->NbNodes();
2424 myPreviewData->nodesXYZ.length( j );
2426 // filling the elements connectivities
2427 list<int>::iterator aConnIter = aNodesConnectivity.begin();
2428 myPreviewData->elementConnectivities.length(aNodesConnectivity.size());
2429 for( int i = 0; aConnIter != aNodesConnectivity.end(); aConnIter++, i++ )
2430 myPreviewData->elementConnectivities[i] = *aConnIter;
2436 // add new nodes into myLastCreatedNodes
2437 const SMESH_SequenceOfElemPtr& aSeq = anEditor.GetLastCreatedNodes();
2438 myLastCreatedNodes->length(aSeq.Length());
2439 for(int i=0; i<aSeq.Length(); i++)
2440 myLastCreatedNodes[i] = aSeq.Value(i+1)->GetID();
2443 // add new elements into myLastCreatedElems
2444 const SMESH_SequenceOfElemPtr& aSeq = anEditor.GetLastCreatedElems();
2445 myLastCreatedElems->length(aSeq.Length());
2446 for(int i=0; i<aSeq.Length(); i++)
2447 myLastCreatedElems[i] = aSeq.Value(i+1)->GetID();
2451 //================================================================================
2453 * Return data of mesh edition preview
2455 //================================================================================
2457 SMESH::MeshPreviewStruct* SMESH_MeshEditor_i::GetPreviewData()
2459 return myPreviewData._retn();
2462 //================================================================================
2464 * \brief Returns list of it's IDs of created nodes
2465 * \retval SMESH::long_array* - list of node ID
2467 //================================================================================
2469 SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedNodes()
2471 return myLastCreatedNodes._retn();
2474 //================================================================================
2476 * \brief Returns list of it's IDs of created elements
2477 * \retval SMESH::long_array* - list of elements' ID
2479 //================================================================================
2481 SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedElems()
2483 return myLastCreatedElems._retn();
2486 //=======================================================================
2487 //function : ConvertToQuadratic
2489 //=======================================================================
2491 void SMESH_MeshEditor_i::ConvertToQuadratic(CORBA::Boolean theForce3d)
2493 ::SMESH_MeshEditor anEditor( myMesh );
2494 anEditor.ConvertToQuadratic(theForce3d);
2495 // Update Python script
2496 TPythonDump() << this << ".ConvertToQuadratic( " << theForce3d << " )";
2499 //=======================================================================
2500 //function : ConvertFromQuadratic
2502 //=======================================================================
2504 CORBA::Boolean SMESH_MeshEditor_i::ConvertFromQuadratic()
2506 ::SMESH_MeshEditor anEditor( myMesh );
2507 CORBA::Boolean isDone = anEditor.ConvertFromQuadratic();
2508 // Update Python script
2509 TPythonDump() << this << ".ConvertFromQuadratic()";