X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH_I%2FSMESH_MeshEditor_i.cxx;h=70462b1151fe749312912bfb169225e41d7d8872;hp=6887ed0a16129da83de75d2af9d6625d96e06266;hb=2c607013a23bd4e7ba07e72e0c04dee2c1209cff;hpb=9357f5c87098aff2b95b754d69f66c76d2df9c24 diff --git a/src/SMESH_I/SMESH_MeshEditor_i.cxx b/src/SMESH_I/SMESH_MeshEditor_i.cxx index 6887ed0a1..70462b115 100644 --- a/src/SMESH_I/SMESH_MeshEditor_i.cxx +++ b/src/SMESH_I/SMESH_MeshEditor_i.cxx @@ -1,44 +1,46 @@ -// Copyright (C) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE +// Copyright (C) 2007-2011 CEA/DEN, EDF R&D, OPEN CASCADE // -// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, -// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS // -// This library is free software; you can redistribute it and/or -// modify it under the terms of the GNU Lesser General Public -// License as published by the Free Software Foundation; either -// version 2.1 of the License. +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. // -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -// Lesser General Public License for more details. +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. // -// You should have received a copy of the GNU Lesser General Public -// License along with this library; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // -// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // - -// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses // File : SMESH_MeshEditor_i.cxx // Author : Nicolas REJNERI // Module : SMESH -// + +#ifdef WNT +#define NOMINMAX +#endif + #include "SMESH_MeshEditor_i.hxx" #include "SMDS_Mesh0DElement.hxx" -#include "SMDS_MeshEdge.hxx" +#include "SMDS_LinearEdge.hxx" #include "SMDS_MeshFace.hxx" #include "SMDS_MeshVolume.hxx" #include "SMDS_PolyhedralVolumeOfNodes.hxx" -#include "SMESH_MeshEditor.hxx" #include "SMESH_subMeshEventListener.hxx" #include "SMESH_Gen_i.hxx" #include "SMESH_Filter_i.hxx" #include "SMESH_subMesh_i.hxx" #include "SMESH_Group_i.hxx" #include "SMESH_PythonDump.hxx" +#include "SMESH_ControlsDef.hxx" #include "utilities.h" #include "Utils_ExceptHandlers.hxx" @@ -65,6 +67,7 @@ #endif #include +#include #define cast2Node(elem) static_cast( elem ) @@ -129,11 +132,11 @@ namespace { SMDS_MeshElement* anElemCopy = 0; if ( anElem->IsPoly() && anElem->GetType() == SMDSAbs_Volume ) { - const SMDS_PolyhedralVolumeOfNodes* ph = - dynamic_cast (anElem); + const SMDS_VtkVolume* ph = + dynamic_cast (anElem); if ( ph ) anElemCopy = _myMeshDS->AddPolyhedralVolumeWithID - (anElemNodesID, ph->GetQuanities(),anElem->GetID()); + (anElemNodesID, ph->GetQuantities(),anElem->GetID()); } else { anElemCopy = ::SMESH_MeshEditor(this).AddElement( anElemNodesID, @@ -145,7 +148,7 @@ namespace { //!< Copy a node SMDS_MeshNode* Copy( const SMDS_MeshNode* anElemNode ) { - return _myMeshDS->AddNodeWithID(anElemNode->X(), anElemNode->Y(), anElemNode->Z(), + return _myMeshDS->AddNodeWithID(anElemNode->X(), anElemNode->Y(), anElemNode->Z(), anElemNode->GetID()); } };// struct TPreviewMesh @@ -228,6 +231,143 @@ namespace { } return typeStr; } + //================================================================================ + /*! + * \brief function for conversion of long_array to TIDSortedElemSet + * \param IDs - array of IDs + * \param aMesh - mesh + * \param aMap - collection to fill + * \param aType - element type + */ + //================================================================================ + + void arrayToSet(const SMESH::long_array & IDs, + const SMESHDS_Mesh* aMesh, + TIDSortedElemSet& aMap, + const SMDSAbs_ElementType aType = SMDSAbs_All ) + { + for (int i=0; iFindNode(ind) : aMesh->FindElement(ind)); + if ( elem && ( aType == SMDSAbs_All || elem->GetType() == aType )) + aMap.insert( elem ); + } + } + //================================================================================ + /*! + * \brief Retrieve elements of given type from SMESH_IDSource + */ + //================================================================================ + + bool idSourceToSet(SMESH::SMESH_IDSource_ptr theIDSource, + const SMESHDS_Mesh* theMeshDS, + TIDSortedElemSet& theElemSet, + const SMDSAbs_ElementType theType, + const bool emptyIfIsMesh=false) + + { + if ( CORBA::is_nil( theIDSource ) ) + return false; + if ( emptyIfIsMesh && SMESH::DownCast( theIDSource )) + return true; + + SMESH::long_array_var anIDs = theIDSource->GetIDs(); + if ( anIDs->length() == 0 ) + return false; + SMESH::array_of_ElementType_var types = theIDSource->GetTypes(); + if ( types->length() == 1 && types[0] == SMESH::NODE ) // group of nodes + { + if ( theType == SMDSAbs_All || theType == SMDSAbs_Node ) + arrayToSet( anIDs, theMeshDS, theElemSet, SMDSAbs_Node ); + else + return false; + } + else + { + arrayToSet( anIDs, theMeshDS, theElemSet, theType); + } + return true; + } + //================================================================================ + /*! + * \brief Retrieve nodes from SMESH_IDSource + */ + //================================================================================ + + void idSourceToNodeSet(SMESH::SMESH_IDSource_ptr theObject, + const SMESHDS_Mesh* theMeshDS, + TIDSortedNodeSet& theNodeSet) + + { + if ( CORBA::is_nil( theObject ) ) + return; + SMESH::array_of_ElementType_var types = theObject->GetTypes(); + SMESH::long_array_var aElementsId = theObject->GetIDs(); + if ( types->length() == 1 && types[0] == SMESH::NODE) + { + for(int i = 0; i < aElementsId->length(); i++) + if ( const SMDS_MeshNode * n = theMeshDS->FindNode( aElementsId[i] )) + theNodeSet.insert( theNodeSet.end(), n); + } + else if ( SMESH::DownCast( theObject )) + { + SMDS_NodeIteratorPtr nIt = theMeshDS->nodesIterator(); + while ( nIt->more( )) + if( const SMDS_MeshElement * elem = nIt->next() ) + theNodeSet.insert( elem->begin_nodes(), elem->end_nodes()); + } + else + { + for(int i = 0; i < aElementsId->length(); i++) + if( const SMDS_MeshElement * elem = theMeshDS->FindElement( aElementsId[i] )) + theNodeSet.insert( elem->begin_nodes(), elem->end_nodes()); + } + } + + //================================================================================ + /*! + * \brief Returns elements connected to the given elements + */ + //================================================================================ + + void getElementsAround(const TIDSortedElemSet& theElements, + const SMESHDS_Mesh* theMeshDS, + TIDSortedElemSet& theElementsAround) + { + if ( theElements.empty() ) return; + + SMDSAbs_ElementType elemType = (*theElements.begin())->GetType(); + bool sameElemType = ( elemType == (*theElements.rbegin())->GetType() ); + if ( sameElemType && + theMeshDS->GetMeshInfo().NbElements( elemType ) == theElements.size() ) + return; // all the elements are in theElements + + if ( !sameElemType ) + elemType = SMDSAbs_All; + + TIDSortedElemSet visitedNodes; + TIDSortedElemSet::const_iterator elemIt = theElements.begin(); + for ( ; elemIt != theElements.end(); ++elemIt ) + { + const SMDS_MeshElement* e = *elemIt; + int i = e->NbCornerNodes(); + while ( --i != -1 ) + { + const SMDS_MeshNode* n = e->GetNode( i ); + if ( visitedNodes.insert( n ).second ) + { + SMDS_ElemIteratorPtr invIt = n->GetInverseElementIterator(elemType); + while ( invIt->more() ) + { + const SMDS_MeshElement* elemAround = invIt->next(); + if ( !theElements.count( elemAround )) + theElementsAround.insert( elemAround ); + } + } + } + } + } } //============================================================================= @@ -279,17 +419,30 @@ void SMESH_MeshEditor_i::initData(bool deleteSearchers) struct _IDSource : public POA_SMESH::SMESH_IDSource { - SMESH::long_array _ids; + SMESH::long_array _ids; + SMESH::ElementType _type; + SMESH::SMESH_Mesh_ptr _mesh; SMESH::long_array* GetIDs() { return new SMESH::long_array( _ids ); } SMESH::long_array* GetMeshInfo() { return 0; } + SMESH::SMESH_Mesh_ptr GetMesh() { return SMESH::SMESH_Mesh::_duplicate( _mesh ); } + SMESH::array_of_ElementType* GetTypes() + { + SMESH::array_of_ElementType_var types = new SMESH::array_of_ElementType; + types->length( 1 ); + types[0] = _type; + return types._retn(); + } }; -SMESH::SMESH_IDSource_ptr SMESH_MeshEditor_i::MakeIDSource(const SMESH::long_array& ids) +SMESH::SMESH_IDSource_ptr SMESH_MeshEditor_i::MakeIDSource(const SMESH::long_array& ids, + SMESH::ElementType type) { _IDSource* anIDSource = new _IDSource; anIDSource->_ids = ids; + anIDSource->_type = type; + anIDSource->_mesh = myMesh_i->_this(); SMESH::SMESH_IDSource_var anIDSourceVar = anIDSource->_this(); - + return anIDSourceVar._retn(); } @@ -313,11 +466,12 @@ SMESH_MeshEditor_i::RemoveElements(const SMESH::long_array & IDsOfElements) // Update Python script TPythonDump() << "isDone = " << this << ".RemoveElements( " << IDsOfElements << " )"; + // Remove Elements + bool ret = anEditor.Remove( IdList, false ); + myMesh->GetMeshDS()->Modified(); if ( IDsOfElements.length() ) myMesh->SetIsModified( true ); // issue 0020693 - - // Remove Elements - return anEditor.Remove( IdList, false ); + return ret; } //============================================================================= @@ -338,10 +492,44 @@ CORBA::Boolean SMESH_MeshEditor_i::RemoveNodes(const SMESH::long_array & IDsOfNo // Update Python script TPythonDump() << "isDone = " << this << ".RemoveNodes( " << IDsOfNodes << " )"; + bool ret = anEditor.Remove( IdList, true ); + myMesh->GetMeshDS()->Modified(); if ( IDsOfNodes.length() ) myMesh->SetIsModified( true ); // issue 0020693 + return ret; +} + +//============================================================================= +/*! + * + */ +//============================================================================= + +CORBA::Long SMESH_MeshEditor_i::RemoveOrphanNodes() +{ + initData(); + + ::SMESH_MeshEditor anEditor( myMesh ); + + // Update Python script + TPythonDump() << "nbRemoved = " << this << ".RemoveOrphanNodes()"; + + // Create filter to find all orphan nodes + SMESH::Controls::Filter::TIdSequence seq; + SMESH::Controls::PredicatePtr predicate( new SMESH::Controls::FreeNodes() ); + SMESH::Controls::Filter::GetElementsId( GetMeshDS(), predicate, seq ); + + // remove orphan nodes (if there are any) + list< int > IdList; + for ( int i = 0; i < seq.size(); i++ ) + IdList.push_back( seq[i] ); + + bool ret = anEditor.Remove( IdList, true ); + myMesh->GetMeshDS()->Modified(); + if ( IdList.size() ) + myMesh->SetIsModified( true ); - return anEditor.Remove( IdList, true ); + return ret; } //============================================================================= @@ -361,8 +549,8 @@ CORBA::Long SMESH_MeshEditor_i::AddNode(CORBA::Double x, TPythonDump() << "nodeID = " << this << ".AddNode( " << x << ", " << y << ", " << z << " )"; + myMesh->GetMeshDS()->Modified(); myMesh->SetIsModified( true ); // issue 0020693 - return N->GetID(); } @@ -381,6 +569,7 @@ CORBA::Long SMESH_MeshEditor_i::Add0DElement(CORBA::Long IDOfNode) // Update Python script TPythonDump() << "elem0d = " << this << ".Add0DElement( " << IDOfNode <<" )"; + myMesh->GetMeshDS()->Modified(); myMesh->SetIsModified( true ); // issue 0020693 if (elem) @@ -423,6 +612,7 @@ CORBA::Long SMESH_MeshEditor_i::AddEdge(const SMESH::long_array & IDsOfNodes) <GetMeshDS()->Modified(); if(elem) return myMesh->SetIsModified( true ), elem->GetID(); @@ -471,6 +661,7 @@ CORBA::Long SMESH_MeshEditor_i::AddFace(const SMESH::long_array & IDsOfNodes) // Update Python script TPythonDump() << "faceID = " << this << ".AddFace( " << IDsOfNodes << " )"; + myMesh->GetMeshDS()->Modified(); if(elem) return myMesh->SetIsModified( true ), elem->GetID(); @@ -496,6 +687,7 @@ CORBA::Long SMESH_MeshEditor_i::AddPolygonalFace (const SMESH::long_array & IDsO // Update Python script TPythonDump() <<"faceID = "<GetMeshDS()->Modified(); return elem ? ( myMesh->SetIsModified( true ), elem->GetID()) : 0; } @@ -539,6 +731,7 @@ CORBA::Long SMESH_MeshEditor_i::AddVolume(const SMESH::long_array & IDsOfNodes) // Update Python script TPythonDump() << "volID = " << this << ".AddVolume( " << IDsOfNodes << " )"; + myMesh->GetMeshDS()->Modified(); if(elem) return myMesh->SetIsModified( true ), elem->GetID(); @@ -558,7 +751,11 @@ CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolume (const SMESH::long_array & I int NbNodes = IDsOfNodes.length(); std::vector n (NbNodes); for (int i = 0; i < NbNodes; i++) - n[i] = GetMeshDS()->FindNode(IDsOfNodes[i]); + { + const SMDS_MeshNode* aNode = GetMeshDS()->FindNode(IDsOfNodes[i]); + if (!aNode) return 0; + n[i] = aNode; + } int NbFaces = Quantities.length(); std::vector q (NbFaces); @@ -570,6 +767,7 @@ CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolume (const SMESH::long_array & I // Update Python script TPythonDump() << "volID = " << this << ".AddPolyhedralVolume( " << IDsOfNodes << ", " << Quantities << " )"; + myMesh->GetMeshDS()->Modified(); return elem ? ( myMesh->SetIsModified( true ), elem->GetID()) : 0; } @@ -602,6 +800,7 @@ CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolumeByFaces (const SMESH::long_ar // Update Python script TPythonDump() << "volID = " << this << ".AddPolyhedralVolumeByFaces( " << IdsOfFaces << " )"; + myMesh->GetMeshDS()->Modified(); return elem ? ( myMesh->SetIsModified( true ), elem->GetID()) : 0; } @@ -713,16 +912,15 @@ void SMESH_MeshEditor_i::SetNodeOnFace(CORBA::Long NodeID, CORBA::Long FaceID, if ( isOut ) { #ifdef _DEBUG_ MESSAGE ( "FACE " << FaceID << " (" << u << "," << v << ") out of " - << " u( " << surf.FirstUParameter() - << "," << surf.LastUParameter() - << ") v( " << surf.FirstVParameter() + << " u( " << surf.FirstUParameter() + << "," << surf.LastUParameter() + << ") v( " << surf.FirstVParameter() << "," << surf.LastVParameter() << ")" ); -#endif +#endif THROW_SALOME_CORBA_EXCEPTION("Invalid UV", SALOME::BAD_PARAM); } mesh->SetNodeOnFace( node, FaceID, u, v ); - myMesh->SetIsModified( true ); } @@ -813,10 +1011,12 @@ CORBA::Boolean SMESH_MeshEditor_i::InverseDiag(CORBA::Long NodeID1, TPythonDump() << "isDone = " << this << ".InverseDiag( " << NodeID1 << ", " << NodeID2 << " )"; - myMesh->SetIsModified( true ); ::SMESH_MeshEditor aMeshEditor( myMesh ); - return aMeshEditor.InverseDiag ( n1, n2 ); + int ret = aMeshEditor.InverseDiag ( n1, n2 ); + myMesh->GetMeshDS()->Modified(); + myMesh->SetIsModified( true ); + return ret; } //============================================================================= @@ -843,9 +1043,10 @@ CORBA::Boolean SMESH_MeshEditor_i::DeleteDiag(CORBA::Long NodeID1, bool stat = aMeshEditor.DeleteDiag ( n1, n2 ); + myMesh->GetMeshDS()->Modified(); if ( stat ) myMesh->SetIsModified( true ); // issue 0020693 - + storeResult(aMeshEditor); return stat; @@ -872,6 +1073,7 @@ CORBA::Boolean SMESH_MeshEditor_i::Reorient(const SMESH::long_array & IDsOfEleme // Update Python script TPythonDump() << "isDone = " << this << ".Reorient( " << IDsOfElements << " )"; + myMesh->GetMeshDS()->Modified(); if ( IDsOfElements.length() ) myMesh->SetIsModified( true ); // issue 0020693 @@ -900,34 +1102,6 @@ CORBA::Boolean SMESH_MeshEditor_i::ReorientObject(SMESH::SMESH_IDSource_ptr theO return isDone; } -namespace -{ - //================================================================================ - /*! - * \brief function for conversion long_array to TIDSortedElemSet - * \param IDs - array of IDs - * \param aMesh - mesh - * \param aMap - collection to fill - * \param aType - element type - */ - //================================================================================ - - void arrayToSet(const SMESH::long_array & IDs, - const SMESHDS_Mesh* aMesh, - TIDSortedElemSet& aMap, - const SMDSAbs_ElementType aType = SMDSAbs_All ) - { - for (int i=0; iFindNode(ind) - : aMesh->FindElement(ind)); - if ( elem && ( aType == SMDSAbs_All || elem->GetType() == aType )) - aMap.insert( elem ); - } - } -} - //============================================================================= /*! * @@ -958,6 +1132,7 @@ CORBA::Boolean SMESH_MeshEditor_i::TriToQuad (const SMESH::long_array & IDsOfE ::SMESH_MeshEditor anEditor( myMesh ); bool stat = anEditor.TriToQuad( faces, aCrit, MaxAngle ); + myMesh->GetMeshDS()->Modified(); if ( stat ) myMesh->SetIsModified( true ); // issue 0020693 @@ -1021,6 +1196,7 @@ CORBA::Boolean SMESH_MeshEditor_i::QuadToTri (const SMESH::long_array & IDsOfE ::SMESH_MeshEditor anEditor( myMesh ); CORBA::Boolean stat = anEditor.QuadToTri( faces, aCrit ); + myMesh->GetMeshDS()->Modified(); if ( stat ) myMesh->SetIsModified( true ); // issue 0020693 @@ -1075,6 +1251,7 @@ CORBA::Boolean SMESH_MeshEditor_i::SplitQuad (const SMESH::long_array & IDsOfEle ::SMESH_MeshEditor anEditor( myMesh ); CORBA::Boolean stat = anEditor.QuadToTri( faces, Diag13 ); + myMesh->GetMeshDS()->Modified(); if ( stat ) myMesh->SetIsModified( true ); // issue 0020693 @@ -1116,6 +1293,8 @@ CORBA::Boolean SMESH_MeshEditor_i::SplitQuadObject (SMESH::SMESH_IDSource_ptr th CORBA::Long SMESH_MeshEditor_i::BestSplit (CORBA::Long IDOfQuad, SMESH::NumericalFunctor_ptr Criterion) { + initData(); + const SMDS_MeshElement* quad = GetMeshDS()->FindElement(IDOfQuad); if (quad && quad->GetType() == SMDSAbs_Face && quad->NbNodes() == 4) { @@ -1145,12 +1324,15 @@ void SMESH_MeshEditor_i::SplitVolumesIntoTetra (SMESH::SMESH_IDSource_ptr elems, { Unexpect aCatch(SALOME_SalomeException); + initData(); + SMESH::long_array_var anElementsId = elems->GetIDs(); TIDSortedElemSet elemSet; arrayToSet( anElementsId, GetMeshDS(), elemSet, SMDSAbs_Volume ); - + ::SMESH_MeshEditor anEditor (myMesh); anEditor.SplitVolumesIntoTetra( elemSet, int( methodFlags )); + myMesh->GetMeshDS()->Modified(); storeResult(anEditor); @@ -1265,6 +1447,7 @@ SMESH_MeshEditor_i::smooth(const SMESH::long_array & IDsOfElements, anEditor.Smooth(elements, fixedNodes, method, MaxNbOfIterations, MaxAspectRatio, IsParametric ); + myMesh->GetMeshDS()->Modified(); myMesh->SetIsModified( true ); // issue 0020693 storeResult(anEditor); @@ -1362,7 +1545,7 @@ SMESH::ListOfGroups* SMESH_MeshEditor_i::getGroups(const std::list* groupID //======================================================================= //function : rotationSweep -//purpose : +//purpose : //======================================================================= SMESH::ListOfGroups* @@ -1404,6 +1587,7 @@ SMESH_MeshEditor_i::rotationSweep(const SMESH::long_array & theIDsOfElements, anEditor.RotationSweep (*workElements, Ax1, theAngleInRadians, theNbOfSteps, theTolerance, theMakeGroups, makeWalls); storeResult(anEditor); + myMesh->GetMeshDS()->Modified(); // myMesh->SetIsModified( true ); -- it does not influence Compute() @@ -1439,7 +1623,7 @@ void SMESH_MeshEditor_i::RotationSweep(const SMESH::long_array & theIDsOfElement //======================================================================= //function : RotationSweepMakeGroups -//purpose : +//purpose : //======================================================================= SMESH::ListOfGroups* @@ -1449,21 +1633,22 @@ SMESH_MeshEditor_i::RotationSweepMakeGroups(const SMESH::long_array& theIDsOfEle CORBA::Long theNbOfSteps, CORBA::Double theTolerance) { + TPythonDump aPythonDump; // it is here to prevent dump of GetGroups() + SMESH::ListOfGroups *aGroups = rotationSweep(theIDsOfElements, theAxis, theAngleInRadians, theNbOfSteps, theTolerance, true); - if ( !myPreviewMode ) { - TPythonDump aPythonDump; - DumpGroupsList(aPythonDump,aGroups); - aPythonDump<< this << ".RotationSweepMakeGroups( " - << theIDsOfElements << ", " - << theAxis << ", " - << theAngleInRadians << ", " - << theNbOfSteps << ", " - << theTolerance << " )"; + if (!myPreviewMode) { + DumpGroupsList(aPythonDump, aGroups); + aPythonDump << this << ".RotationSweepMakeGroups( " + << theIDsOfElements << ", " + << theAxis << ", " + << theAngleInRadians << ", " + << theNbOfSteps << ", " + << theTolerance << " )"; } return aGroups; } @@ -1556,7 +1741,7 @@ void SMESH_MeshEditor_i::RotationSweepObject2D(SMESH::SMESH_IDSource_ptr theObje //======================================================================= //function : RotationSweepObjectMakeGroups -//purpose : +//purpose : //======================================================================= SMESH::ListOfGroups* @@ -1566,6 +1751,8 @@ SMESH_MeshEditor_i::RotationSweepObjectMakeGroups(SMESH::SMESH_IDSource_ptr theO CORBA::Long theNbOfSteps, CORBA::Double theTolerance) { + TPythonDump aPythonDump; // it is here to prevent dump of GetGroups() + SMESH::long_array_var anElementsId = theObject->GetIDs(); SMESH::ListOfGroups *aGroups = rotationSweep(anElementsId, theAxis, @@ -1573,22 +1760,21 @@ SMESH_MeshEditor_i::RotationSweepObjectMakeGroups(SMESH::SMESH_IDSource_ptr theO theNbOfSteps, theTolerance, true); - if ( !myPreviewMode ) { - TPythonDump aPythonDump; - DumpGroupsList(aPythonDump,aGroups); - aPythonDump<< this << ".RotationSweepObjectMakeGroups( " - << theObject << ", " - << theAxis << ", " - << theAngleInRadians << ", " - << theNbOfSteps << ", " - << theTolerance << " )"; + if (!myPreviewMode) { + DumpGroupsList(aPythonDump, aGroups); + aPythonDump << this << ".RotationSweepObjectMakeGroups( " + << theObject << ", " + << theAxis << ", " + << theAngleInRadians << ", " + << theNbOfSteps << ", " + << theTolerance << " )"; } return aGroups; } //======================================================================= //function : RotationSweepObject1DMakeGroups -//purpose : +//purpose : //======================================================================= SMESH::ListOfGroups* @@ -1598,6 +1784,8 @@ SMESH_MeshEditor_i::RotationSweepObject1DMakeGroups(SMESH::SMESH_IDSource_ptr th CORBA::Long theNbOfSteps, CORBA::Double theTolerance) { + TPythonDump aPythonDump; // it is here to prevent dump of GetGroups() + SMESH::long_array_var anElementsId = theObject->GetIDs(); SMESH::ListOfGroups *aGroups = rotationSweep(anElementsId, theAxis, @@ -1606,22 +1794,21 @@ SMESH_MeshEditor_i::RotationSweepObject1DMakeGroups(SMESH::SMESH_IDSource_ptr th theTolerance, true, SMDSAbs_Edge); - if ( !myPreviewMode ) { - TPythonDump aPythonDump; - DumpGroupsList(aPythonDump,aGroups); - aPythonDump<< this << ".RotationSweepObject1DMakeGroups( " - << theObject << ", " - << theAxis << ", " - << theAngleInRadians << ", " - << theNbOfSteps << ", " - << theTolerance << " )"; + if (!myPreviewMode) { + DumpGroupsList(aPythonDump, aGroups); + aPythonDump << this << ".RotationSweepObject1DMakeGroups( " + << theObject << ", " + << theAxis << ", " + << theAngleInRadians << ", " + << theNbOfSteps << ", " + << theTolerance << " )"; } return aGroups; } //======================================================================= //function : RotationSweepObject2DMakeGroups -//purpose : +//purpose : //======================================================================= SMESH::ListOfGroups* @@ -1631,6 +1818,8 @@ SMESH_MeshEditor_i::RotationSweepObject2DMakeGroups(SMESH::SMESH_IDSource_ptr th CORBA::Long theNbOfSteps, CORBA::Double theTolerance) { + TPythonDump aPythonDump; // it is here to prevent dump of GetGroups() + SMESH::long_array_var anElementsId = theObject->GetIDs(); SMESH::ListOfGroups *aGroups = rotationSweep(anElementsId, theAxis, @@ -1639,15 +1828,14 @@ SMESH_MeshEditor_i::RotationSweepObject2DMakeGroups(SMESH::SMESH_IDSource_ptr th theTolerance, true, SMDSAbs_Face); - if ( !myPreviewMode ) { - TPythonDump aPythonDump; - DumpGroupsList(aPythonDump,aGroups); - aPythonDump<< this << ".RotationSweepObject2DMakeGroups( " - << theObject << ", " - << theAxis << ", " - << theAngleInRadians << ", " - << theNbOfSteps << ", " - << theTolerance << " )"; + if (!myPreviewMode) { + DumpGroupsList(aPythonDump, aGroups); + aPythonDump << this << ".RotationSweepObject2DMakeGroups( " + << theObject << ", " + << theAxis << ", " + << theAngleInRadians << ", " + << theNbOfSteps << ", " + << theTolerance << " )"; } return aGroups; } @@ -1655,39 +1843,52 @@ SMESH_MeshEditor_i::RotationSweepObject2DMakeGroups(SMESH::SMESH_IDSource_ptr th //======================================================================= //function : extrusionSweep -//purpose : +//purpose : //======================================================================= SMESH::ListOfGroups* SMESH_MeshEditor_i::extrusionSweep(const SMESH::long_array & theIDsOfElements, const SMESH::DirStruct & theStepVector, CORBA::Long theNbOfSteps, - const bool theMakeGroups, + bool theMakeGroups, const SMDSAbs_ElementType theElementType) { initData(); - try { + try { #ifdef NO_CAS_CATCH OCC_CATCH_SIGNALS; #endif - TIDSortedElemSet elements; + TIDSortedElemSet elements, copyElements; arrayToSet(theIDsOfElements, GetMeshDS(), elements, theElementType); const SMESH::PointStruct * P = &theStepVector.PS; gp_Vec stepVec( P->x, P->y, P->z ); + TIDSortedElemSet* workElements = & elements; + TPreviewMesh tmpMesh( SMDSAbs_Face ); + SMESH_Mesh* mesh = myMesh; + + if ( myPreviewMode ) { + SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume; + tmpMesh.Copy( elements, copyElements, select, avoid ); + mesh = &tmpMesh; + workElements = & copyElements; + theMakeGroups = false; + } + TElemOfElemListMap aHystory; - ::SMESH_MeshEditor anEditor( myMesh ); + ::SMESH_MeshEditor anEditor( mesh ); ::SMESH_MeshEditor::PGroupIDs groupIds = - anEditor.ExtrusionSweep (elements, stepVec, theNbOfSteps, aHystory, theMakeGroups); + anEditor.ExtrusionSweep (*workElements, stepVec, theNbOfSteps, aHystory, theMakeGroups); + myMesh->GetMeshDS()->Modified(); storeResult(anEditor); return theMakeGroups ? getGroups(groupIds.get()) : 0; } catch(Standard_Failure) { - Handle(Standard_Failure) aFail = Standard_Failure::Caught(); + Handle(Standard_Failure) aFail = Standard_Failure::Caught(); INFOS( "SMESH_MeshEditor_i::ExtrusionSweep fails - "<< aFail->GetMessageString() ); } return 0; @@ -1703,7 +1904,7 @@ void SMESH_MeshEditor_i::ExtrusionSweep(const SMESH::long_array & theIDsOfElemen CORBA::Long theNbOfSteps) { extrusionSweep (theIDsOfElements, theStepVector, theNbOfSteps, false ); - if ( !myPreviewMode ) { + if (!myPreviewMode) { TPythonDump() << this << ".ExtrusionSweep( " << theIDsOfElements << ", " << theStepVector <<", " << theNbOfSteps << " )"; } @@ -1721,7 +1922,7 @@ void SMESH_MeshEditor_i::ExtrusionSweepObject(SMESH::SMESH_IDSource_ptr theObjec { SMESH::long_array_var anElementsId = theObject->GetIDs(); extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false ); - if ( !myPreviewMode ) { + if (!myPreviewMode) { TPythonDump() << this << ".ExtrusionSweepObject( " << theObject << ", " << theStepVector << ", " << theNbOfSteps << " )"; } @@ -1763,7 +1964,7 @@ void SMESH_MeshEditor_i::ExtrusionSweepObject2D(SMESH::SMESH_IDSource_ptr theObj //======================================================================= //function : ExtrusionSweepMakeGroups -//purpose : +//purpose : //======================================================================= SMESH::ListOfGroups* @@ -1771,19 +1972,21 @@ SMESH_MeshEditor_i::ExtrusionSweepMakeGroups(const SMESH::long_array& theIDsOfEl const SMESH::DirStruct& theStepVector, CORBA::Long theNbOfSteps) { - SMESH::ListOfGroups* aGroups = extrusionSweep (theIDsOfElements, theStepVector, theNbOfSteps, true ); + TPythonDump aPythonDump; // it is here to prevent dump of GetGroups() - if ( !myPreviewMode ) { - TPythonDump aPythonDump; - DumpGroupsList(aPythonDump,aGroups); - aPythonDump << this << ".ExtrusionSweepMakeGroups( " - << theIDsOfElements << ", " << theStepVector <<", " << theNbOfSteps << " )"; + SMESH::ListOfGroups* aGroups = extrusionSweep(theIDsOfElements, theStepVector, theNbOfSteps, true); + + if (!myPreviewMode) { + DumpGroupsList(aPythonDump, aGroups); + aPythonDump << this << ".ExtrusionSweepMakeGroups( " << theIDsOfElements + << ", " << theStepVector <<", " << theNbOfSteps << " )"; } return aGroups; } + //======================================================================= //function : ExtrusionSweepObjectMakeGroups -//purpose : +//purpose : //======================================================================= SMESH::ListOfGroups* @@ -1791,21 +1994,22 @@ SMESH_MeshEditor_i::ExtrusionSweepObjectMakeGroups(SMESH::SMESH_IDSource_ptr the const SMESH::DirStruct& theStepVector, CORBA::Long theNbOfSteps) { + TPythonDump aPythonDump; // it is here to prevent dump of GetGroups() + SMESH::long_array_var anElementsId = theObject->GetIDs(); - SMESH::ListOfGroups * aGroups = extrusionSweep (anElementsId, theStepVector, theNbOfSteps, true ); + SMESH::ListOfGroups * aGroups = extrusionSweep(anElementsId, theStepVector, theNbOfSteps, true); - if ( !myPreviewMode ) { - TPythonDump aPythonDump; - DumpGroupsList(aPythonDump,aGroups); - aPythonDump<< this << ".ExtrusionSweepObjectMakeGroups( " - << theObject << ", " << theStepVector << ", " << theNbOfSteps << " )"; + if (!myPreviewMode) { + DumpGroupsList(aPythonDump, aGroups); + aPythonDump << this << ".ExtrusionSweepObjectMakeGroups( " << theObject + << ", " << theStepVector << ", " << theNbOfSteps << " )"; } return aGroups; } //======================================================================= //function : ExtrusionSweepObject1DMakeGroups -//purpose : +//purpose : //======================================================================= SMESH::ListOfGroups* @@ -1813,20 +2017,22 @@ SMESH_MeshEditor_i::ExtrusionSweepObject1DMakeGroups(SMESH::SMESH_IDSource_ptr t const SMESH::DirStruct& theStepVector, CORBA::Long theNbOfSteps) { + TPythonDump aPythonDump; // it is here to prevent dump of GetGroups() + SMESH::long_array_var anElementsId = theObject->GetIDs(); - SMESH::ListOfGroups * aGroups = extrusionSweep (anElementsId, theStepVector, theNbOfSteps, true, SMDSAbs_Edge ); - if ( !myPreviewMode ) { - TPythonDump aPythonDump; - DumpGroupsList(aPythonDump,aGroups); - aPythonDump << this << ".ExtrusionSweepObject1DMakeGroups( " - << theObject << ", " << theStepVector << ", " << theNbOfSteps << " )"; + SMESH::ListOfGroups * aGroups = extrusionSweep(anElementsId, theStepVector, + theNbOfSteps, true, SMDSAbs_Edge); + if (!myPreviewMode) { + DumpGroupsList(aPythonDump, aGroups); + aPythonDump << this << ".ExtrusionSweepObject1DMakeGroups( " << theObject + << ", " << theStepVector << ", " << theNbOfSteps << " )"; } return aGroups; } //======================================================================= //function : ExtrusionSweepObject2DMakeGroups -//purpose : +//purpose : //======================================================================= SMESH::ListOfGroups* @@ -1834,13 +2040,15 @@ SMESH_MeshEditor_i::ExtrusionSweepObject2DMakeGroups(SMESH::SMESH_IDSource_ptr t const SMESH::DirStruct& theStepVector, CORBA::Long theNbOfSteps) { + TPythonDump aPythonDump; // it is here to prevent dump of GetGroups() + SMESH::long_array_var anElementsId = theObject->GetIDs(); - SMESH::ListOfGroups * aGroups = extrusionSweep (anElementsId, theStepVector, theNbOfSteps, true, SMDSAbs_Face ); - if ( !myPreviewMode ) { - TPythonDump aPythonDump; - DumpGroupsList(aPythonDump,aGroups); - aPythonDump << this << ".ExtrusionSweepObject2DMakeGroups( " - << theObject << ", " << theStepVector << ", " << theNbOfSteps << " )"; + SMESH::ListOfGroups * aGroups = extrusionSweep(anElementsId, theStepVector, + theNbOfSteps, true, SMDSAbs_Face); + if (!myPreviewMode) { + DumpGroupsList(aPythonDump, aGroups); + aPythonDump << this << ".ExtrusionSweepObject2DMakeGroups( " << theObject + << ", " << theStepVector << ", " << theNbOfSteps << " )"; } return aGroups; } @@ -1848,7 +2056,7 @@ SMESH_MeshEditor_i::ExtrusionSweepObject2DMakeGroups(SMESH::SMESH_IDSource_ptr t //======================================================================= //function : advancedExtrusion -//purpose : +//purpose : //======================================================================= SMESH::ListOfGroups* @@ -1907,9 +2115,8 @@ void SMESH_MeshEditor_i::AdvancedExtrusion(const SMESH::long_array & theIDsOfEle //======================================================================= //function : AdvancedExtrusionMakeGroups -//purpose : +//purpose : //======================================================================= - SMESH::ListOfGroups* SMESH_MeshEditor_i::AdvancedExtrusionMakeGroups(const SMESH::long_array& theIDsOfElements, const SMESH::DirStruct& theStepVector, @@ -1917,6 +2124,11 @@ SMESH_MeshEditor_i::AdvancedExtrusionMakeGroups(const SMESH::long_array& theIDsO CORBA::Long theExtrFlags, CORBA::Double theSewTolerance) { + if (!myPreviewMode) { + TPythonDump() << "stepVector = " << theStepVector; + } + TPythonDump aPythonDump; // it is here to prevent dump of GetGroups() + SMESH::ListOfGroups * aGroups = advancedExtrusion( theIDsOfElements, theStepVector, theNbOfSteps, @@ -1924,10 +2136,8 @@ SMESH_MeshEditor_i::AdvancedExtrusionMakeGroups(const SMESH::long_array& theIDsO theSewTolerance, true); - if ( !myPreviewMode ) { - TPythonDump() << "stepVector = " << theStepVector; - TPythonDump aPythonDump; - DumpGroupsList(aPythonDump,aGroups); + if (!myPreviewMode) { + DumpGroupsList(aPythonDump, aGroups); aPythonDump << this << ".AdvancedExtrusionMakeGroups(" << theIDsOfElements << ", stepVector, " @@ -1964,9 +2174,8 @@ static SMESH::SMESH_MeshEditor::Extrusion_Error convExtrError( const::SMESH_Mesh //======================================================================= //function : extrusionAlongPath -//purpose : +//purpose : //======================================================================= - SMESH::ListOfGroups* SMESH_MeshEditor_i::extrusionAlongPath(const SMESH::long_array & theIDsOfElements, SMESH::SMESH_Mesh_ptr thePathMesh, @@ -1980,6 +2189,7 @@ SMESH_MeshEditor_i::extrusionAlongPath(const SMESH::long_array & theIDsOfEleme SMESH::SMESH_MeshEditor::Extrusion_Error & theError, const SMDSAbs_ElementType theElementType) { + MESSAGE("extrusionAlongPath"); initData(); if ( thePathMesh->_is_nil() || thePathShape->_is_nil() ) { @@ -2019,6 +2229,7 @@ SMESH_MeshEditor_i::extrusionAlongPath(const SMESH::long_array & theIDsOfEleme anEditor.ExtrusionAlongTrack( elements, aSubMesh, nodeStart, theHasAngles, angles, false, theHasRefPoint, refPnt, theMakeGroups ); + myMesh->GetMeshDS()->Modified(); storeResult(anEditor); theError = convExtrError( error ); @@ -2035,9 +2246,8 @@ SMESH_MeshEditor_i::extrusionAlongPath(const SMESH::long_array & theIDsOfEleme //======================================================================= //function : extrusionAlongPathX -//purpose : +//purpose : //======================================================================= - SMESH::ListOfGroups* SMESH_MeshEditor_i::extrusionAlongPathX(const SMESH::long_array & IDsOfElements, SMESH::SMESH_IDSource_ptr Path, @@ -2047,7 +2257,7 @@ SMESH_MeshEditor_i::extrusionAlongPathX(const SMESH::long_array & IDsOfElements CORBA::Boolean LinearVariation, CORBA::Boolean HasRefPoint, const SMESH::PointStruct& RefPoint, - const bool MakeGroups, + bool MakeGroups, const SMDSAbs_ElementType ElementType, SMESH::SMESH_MeshEditor::Extrusion_Error & Error) { @@ -2067,54 +2277,67 @@ SMESH_MeshEditor_i::extrusionAlongPathX(const SMESH::long_array & IDsOfElements return EmptyGr; } - TIDSortedElemSet elements; + TIDSortedElemSet elements, copyElements; arrayToSet(IDsOfElements, GetMeshDS(), elements, ElementType); - ::SMESH_MeshEditor anEditor( myMesh ); + TIDSortedElemSet* workElements = &elements; + TPreviewMesh tmpMesh( SMDSAbs_Face ); + SMESH_Mesh* mesh = myMesh; + + if ( myPreviewMode ) + { + SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume; + tmpMesh.Copy( elements, copyElements, select, avoid ); + mesh = &tmpMesh; + workElements = & copyElements; + MakeGroups = false; + } + + ::SMESH_MeshEditor anEditor( mesh ); ::SMESH_MeshEditor::Extrusion_Error error; - SMESH_Mesh_i* aMeshImp = SMESH::DownCast( Path ); - if(aMeshImp) { + if ( SMESH_Mesh_i* aMeshImp = SMESH::DownCast( Path )) + { // path as mesh - SMDS_MeshNode* aNodeStart = + SMDS_MeshNode* aNodeStart = (SMDS_MeshNode*)aMeshImp->GetImpl().GetMeshDS()->FindNode(NodeStart); if ( !aNodeStart ) { Error = SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE; return EmptyGr; } - error = anEditor.ExtrusionAlongTrack( elements, &(aMeshImp->GetImpl()), aNodeStart, + error = anEditor.ExtrusionAlongTrack( *workElements, &(aMeshImp->GetImpl()), aNodeStart, HasAngles, angles, LinearVariation, HasRefPoint, refPnt, MakeGroups ); + myMesh->GetMeshDS()->Modified(); } - else { - SMESH_subMesh_i* aSubMeshImp = SMESH::DownCast( Path ); - if(aSubMeshImp) { - // path as submesh - SMESH::SMESH_Mesh_ptr aPathMesh = aSubMeshImp->GetFather(); - aMeshImp = SMESH::DownCast( aPathMesh ); - SMDS_MeshNode* aNodeStart = - (SMDS_MeshNode*)aMeshImp->GetImpl().GetMeshDS()->FindNode(NodeStart); - if ( !aNodeStart ) { - Error = SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE; - return EmptyGr; - } - SMESH_subMesh* aSubMesh = - aMeshImp->GetImpl().GetSubMeshContaining(aSubMeshImp->GetId()); - error = anEditor.ExtrusionAlongTrack( elements, aSubMesh, aNodeStart, - HasAngles, angles, LinearVariation, - HasRefPoint, refPnt, MakeGroups ); - } - else { - SMESH_Group_i* aGroupImp = SMESH::DownCast( Path ); - if(aGroupImp) { - // path as group of 1D elements - } - else { - // invalid path - Error = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE; - return EmptyGr; - } + else if ( SMESH_subMesh_i* aSubMeshImp = SMESH::DownCast( Path )) + { + // path as submesh + SMESH::SMESH_Mesh_ptr aPathMesh = aSubMeshImp->GetFather(); + aMeshImp = SMESH::DownCast( aPathMesh ); + SMDS_MeshNode* aNodeStart = + (SMDS_MeshNode*)aMeshImp->GetImpl().GetMeshDS()->FindNode(NodeStart); + if ( !aNodeStart ) { + Error = SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE; + return EmptyGr; } + SMESH_subMesh* aSubMesh = + aMeshImp->GetImpl().GetSubMeshContaining(aSubMeshImp->GetId()); + error = anEditor.ExtrusionAlongTrack( *workElements, aSubMesh, aNodeStart, + HasAngles, angles, LinearVariation, + HasRefPoint, refPnt, MakeGroups ); + myMesh->GetMeshDS()->Modified(); + } + else if ( SMESH::DownCast( Path )) + { + // path as group of 1D elements + // ???????? + } + else + { + // invalid path + Error = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE; + return EmptyGr; } storeResult(anEditor); @@ -2135,7 +2358,6 @@ SMESH_MeshEditor_i::extrusionAlongPathX(const SMESH::long_array & IDsOfElements //function : ExtrusionAlongPath //purpose : //======================================================================= - SMESH::SMESH_MeshEditor::Extrusion_Error SMESH_MeshEditor_i::ExtrusionAlongPath(const SMESH::long_array & theIDsOfElements, SMESH::SMESH_Mesh_ptr thePathMesh, @@ -2146,6 +2368,7 @@ SMESH_MeshEditor_i::ExtrusionAlongPath(const SMESH::long_array & theIDsOfEleme CORBA::Boolean theHasRefPoint, const SMESH::PointStruct & theRefPoint) { + MESSAGE("ExtrusionAlongPath"); if ( !myPreviewMode ) { TPythonDump() << "error = " << this << ".ExtrusionAlongPath( " << theIDsOfElements << ", " @@ -2178,7 +2401,6 @@ SMESH_MeshEditor_i::ExtrusionAlongPath(const SMESH::long_array & theIDsOfEleme //function : ExtrusionAlongPathObject //purpose : //======================================================================= - SMESH::SMESH_MeshEditor::Extrusion_Error SMESH_MeshEditor_i::ExtrusionAlongPathObject(SMESH::SMESH_IDSource_ptr theObject, SMESH::SMESH_Mesh_ptr thePathMesh, @@ -2222,7 +2444,6 @@ SMESH_MeshEditor_i::ExtrusionAlongPathObject(SMESH::SMESH_IDSource_ptr theObje //function : ExtrusionAlongPathObject1D //purpose : //======================================================================= - SMESH::SMESH_MeshEditor::Extrusion_Error SMESH_MeshEditor_i::ExtrusionAlongPathObject1D(SMESH::SMESH_IDSource_ptr theObject, SMESH::SMESH_Mesh_ptr thePathMesh, @@ -2267,7 +2488,6 @@ SMESH_MeshEditor_i::ExtrusionAlongPathObject1D(SMESH::SMESH_IDSource_ptr theOb //function : ExtrusionAlongPathObject2D //purpose : //======================================================================= - SMESH::SMESH_MeshEditor::Extrusion_Error SMESH_MeshEditor_i::ExtrusionAlongPathObject2D(SMESH::SMESH_IDSource_ptr theObject, SMESH::SMESH_Mesh_ptr thePathMesh, @@ -2311,9 +2531,8 @@ SMESH_MeshEditor_i::ExtrusionAlongPathObject2D(SMESH::SMESH_IDSource_ptr theOb //======================================================================= //function : ExtrusionAlongPathMakeGroups -//purpose : +//purpose : //======================================================================= - SMESH::ListOfGroups* SMESH_MeshEditor_i::ExtrusionAlongPathMakeGroups(const SMESH::long_array& theIDsOfElements, SMESH::SMESH_Mesh_ptr thePathMesh, @@ -2325,6 +2544,8 @@ SMESH_MeshEditor_i::ExtrusionAlongPathMakeGroups(const SMESH::long_array& theI const SMESH::PointStruct& theRefPoint, SMESH::SMESH_MeshEditor::Extrusion_Error& Error) { + TPythonDump aPythonDump; // it is here to prevent dump of GetGroups() + SMESH::ListOfGroups * aGroups = extrusionAlongPath( theIDsOfElements, thePathMesh, thePathShape, @@ -2335,14 +2556,10 @@ SMESH_MeshEditor_i::ExtrusionAlongPathMakeGroups(const SMESH::long_array& theI theRefPoint, true, Error); - if ( !myPreviewMode ) { + if (!myPreviewMode) { bool isDumpGroups = aGroups && aGroups->length() > 0; - TPythonDump aPythonDump; - if(isDumpGroups) { - aPythonDump << "("<GetIDs(); SMESH::ListOfGroups * aGroups = extrusionAlongPath( anElementsId, thePathMesh, @@ -2390,14 +2608,10 @@ ExtrusionAlongPathObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject, true, Error); - if ( !myPreviewMode ) { + if (!myPreviewMode) { bool isDumpGroups = aGroups && aGroups->length() > 0; - TPythonDump aPythonDump; - if(isDumpGroups) { - aPythonDump << "("<GetIDs(); SMESH::ListOfGroups * aGroups = extrusionAlongPath( anElementsId, thePathMesh, @@ -2446,16 +2661,12 @@ ExtrusionAlongPathObject1DMakeGroups(SMESH::SMESH_IDSource_ptr theObject, Error, SMDSAbs_Edge); - if ( !myPreviewMode ) { + if (!myPreviewMode) { bool isDumpGroups = aGroups && aGroups->length() > 0; - TPythonDump aPythonDump; - if(isDumpGroups) { - aPythonDump << "("<GetIDs(); SMESH::ListOfGroups * aGroups = extrusionAlongPath( anElementsId, thePathMesh, @@ -2502,16 +2714,12 @@ ExtrusionAlongPathObject2DMakeGroups(SMESH::SMESH_IDSource_ptr theObject, Error, SMDSAbs_Face); - if ( !myPreviewMode ) { + if (!myPreviewMode) { bool isDumpGroups = aGroups && aGroups->length() > 0; - TPythonDump aPythonDump; - if(isDumpGroups) { - aPythonDump << "("<GetIDs(); SMESH::ListOfGroups * aGroups = extrusionAlongPathX(anElementsId, Path, @@ -2560,16 +2770,12 @@ ExtrusionAlongPathObjX(SMESH::SMESH_IDSource_ptr Object, (SMDSAbs_ElementType)ElemType, Error); - if ( !myPreviewMode ) { + if (!myPreviewMode) { bool isDumpGroups = aGroups && aGroups->length() > 0; - TPythonDump aPythonDump; - if(isDumpGroups) { - aPythonDump << "("<length() > 0; - TPythonDump aPythonDump; - if(isDumpGroups) { - aPythonDump << "("<SetIsModified( true ); - + myMesh->GetMeshDS()->Modified(); + } return theMakeGroups ? getGroups(groupIds.get()) : 0; } @@ -2782,7 +3008,12 @@ void SMESH_MeshEditor_i::Mirror(const SMESH::long_array & theIDsOfElem << mirrorTypeName(theMirrorType) << ", " << theCopy << " )"; } - mirror(theIDsOfElements, theAxis, theMirrorType, theCopy, false); + if ( theIDsOfElements.length() > 0 ) + { + TIDSortedElemSet elements; + arrayToSet(theIDsOfElements, GetMeshDS(), elements); + mirror(elements, theAxis, theMirrorType, theCopy, false); + } } @@ -2803,13 +3034,17 @@ void SMESH_MeshEditor_i::MirrorObject(SMESH::SMESH_IDSource_ptr theObj << mirrorTypeName(theMirrorType) << ", " << theCopy << " )"; } - SMESH::long_array_var anElementsId = theObject->GetIDs(); - mirror(anElementsId, theAxis, theMirrorType, theCopy, false); + TIDSortedElemSet elements; + + bool emptyIfIsMesh = myPreviewMode ? false : true; + + if (idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh)) + mirror(elements, theAxis, theMirrorType, theCopy, false); } //======================================================================= //function : MirrorMakeGroups -//purpose : +//purpose : //======================================================================= SMESH::ListOfGroups* @@ -2817,10 +3052,17 @@ SMESH_MeshEditor_i::MirrorMakeGroups(const SMESH::long_array& theIDsO const SMESH::AxisStruct& theMirror, SMESH::SMESH_MeshEditor::MirrorType theMirrorType) { - SMESH::ListOfGroups * aGroups = mirror(theIDsOfElements, theMirror, theMirrorType, true, true); - if ( !myPreviewMode ) { - TPythonDump aPythonDump; - DumpGroupsList(aPythonDump,aGroups); + TPythonDump aPythonDump; // it is here to prevent dump of GetGroups() + + SMESH::ListOfGroups * aGroups = 0; + if ( theIDsOfElements.length() > 0 ) + { + TIDSortedElemSet elements; + arrayToSet(theIDsOfElements, GetMeshDS(), elements); + aGroups = mirror(elements, theMirror, theMirrorType, true, true); + } + if (!myPreviewMode) { + DumpGroupsList(aPythonDump, aGroups); aPythonDump << this << ".MirrorMakeGroups( " << theIDsOfElements << ", " << theMirror << ", " @@ -2831,7 +3073,7 @@ SMESH_MeshEditor_i::MirrorMakeGroups(const SMESH::long_array& theIDsO //======================================================================= //function : MirrorObjectMakeGroups -//purpose : +//purpose : //======================================================================= SMESH::ListOfGroups* @@ -2839,10 +3081,15 @@ SMESH_MeshEditor_i::MirrorObjectMakeGroups(SMESH::SMESH_IDSource_ptr t const SMESH::AxisStruct& theMirror, SMESH::SMESH_MeshEditor::MirrorType theMirrorType) { - SMESH::long_array_var anElementsId = theObject->GetIDs(); - SMESH::ListOfGroups * aGroups = mirror(anElementsId, theMirror, theMirrorType, true, true); - if ( !myPreviewMode ) { - TPythonDump aPythonDump; + TPythonDump aPythonDump; // it is here to prevent dump of GetGroups() + + SMESH::ListOfGroups * aGroups = 0; + TIDSortedElemSet elements; + if ( idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1)) + aGroups = mirror(elements, theMirror, theMirrorType, true, true); + + if (!myPreviewMode) + { DumpGroupsList(aPythonDump,aGroups); aPythonDump << this << ".MirrorObjectMakeGroups( " << theObject << ", " @@ -2854,7 +3101,7 @@ SMESH_MeshEditor_i::MirrorObjectMakeGroups(SMESH::SMESH_IDSource_ptr t //======================================================================= //function : MirrorMakeMesh -//purpose : +//purpose : //======================================================================= SMESH::SMESH_Mesh_ptr @@ -2873,13 +3120,16 @@ SMESH_MeshEditor_i::MirrorMakeMesh(const SMESH::long_array& theIDsOfE mesh = makeMesh( theMeshName ); mesh_i = SMESH::DownCast( mesh ); - if (mesh_i) { - mirror(theIDsOfElements, theMirror, theMirrorType, + if (mesh_i && theIDsOfElements.length() > 0 ) + { + TIDSortedElemSet elements; + arrayToSet(theIDsOfElements, GetMeshDS(), elements); + mirror(elements, theMirror, theMirrorType, false, theCopyGroups, & mesh_i->GetImpl()); mesh_i->CreateGroupServants(); } - if ( !myPreviewMode ) { + if (!myPreviewMode) { pydump << mesh << " = " << this << ".MirrorMakeMesh( " << theIDsOfElements << ", " << theMirror << ", " @@ -2890,7 +3140,7 @@ SMESH_MeshEditor_i::MirrorMakeMesh(const SMESH::long_array& theIDsOfE } //dump "GetGroups" - if(!myPreviewMode && mesh_i) + if (!myPreviewMode && mesh_i) mesh_i->GetGroups(); return mesh._retn(); @@ -2898,7 +3148,7 @@ SMESH_MeshEditor_i::MirrorMakeMesh(const SMESH::long_array& theIDsOfE //======================================================================= //function : MirrorObjectMakeMesh -//purpose : +//purpose : //======================================================================= SMESH::SMESH_Mesh_ptr @@ -2917,14 +3167,15 @@ SMESH_MeshEditor_i::MirrorObjectMakeMesh(SMESH::SMESH_IDSource_ptr the mesh = makeMesh( theMeshName ); mesh_i = SMESH::DownCast( mesh ); - if ( mesh_i ) { - SMESH::long_array_var anElementsId = theObject->GetIDs(); - mirror(anElementsId, theMirror, theMirrorType, + TIDSortedElemSet elements; + if ( mesh_i && + idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1)) + { + mirror(elements, theMirror, theMirrorType, false, theCopyGroups, & mesh_i->GetImpl()); mesh_i->CreateGroupServants(); } - - if ( !myPreviewMode ) { + if (!myPreviewMode) { pydump << mesh << " = " << this << ".MirrorObjectMakeMesh( " << theObject << ", " << theMirror << ", " @@ -2932,10 +3183,10 @@ SMESH_MeshEditor_i::MirrorObjectMakeMesh(SMESH::SMESH_IDSource_ptr the << theCopyGroups << ", '" << theMeshName << "' )"; } - } + } //dump "GetGroups" - if(!myPreviewMode && mesh_i) + if (!myPreviewMode && mesh_i) mesh_i->GetGroups(); return mesh._retn(); @@ -2943,33 +3194,55 @@ SMESH_MeshEditor_i::MirrorObjectMakeMesh(SMESH::SMESH_IDSource_ptr the //======================================================================= //function : translate -//purpose : +//purpose : //======================================================================= SMESH::ListOfGroups* -SMESH_MeshEditor_i::translate(const SMESH::long_array & theIDsOfElements, +SMESH_MeshEditor_i::translate(TIDSortedElemSet & theElements, const SMESH::DirStruct & theVector, CORBA::Boolean theCopy, - const bool theMakeGroups, + bool theMakeGroups, ::SMESH_Mesh* theTargetMesh) { initData(); - TIDSortedElemSet elements; - arrayToSet(theIDsOfElements, GetMeshDS(), elements); + if ( theTargetMesh ) + theCopy = false; gp_Trsf aTrsf; const SMESH::PointStruct * P = &theVector.PS; aTrsf.SetTranslation( gp_Vec( P->x, P->y, P->z )); - ::SMESH_MeshEditor anEditor( myMesh ); + TIDSortedElemSet copyElements; + TIDSortedElemSet* workElements = &theElements; + TPreviewMesh tmpMesh; + SMESH_Mesh* mesh = myMesh; + + if ( myPreviewMode ) + { + tmpMesh.Copy( theElements, copyElements); + if ( !theCopy && !theTargetMesh ) + { + TIDSortedElemSet elemsAround, elemsAroundCopy; + getElementsAround( theElements, GetMeshDS(), elemsAround ); + tmpMesh.Copy( elemsAround, elemsAroundCopy); + } + mesh = &tmpMesh; + workElements = & copyElements; + theMakeGroups = false; + } + + ::SMESH_MeshEditor anEditor( mesh ); ::SMESH_MeshEditor::PGroupIDs groupIds = - anEditor.Transform (elements, aTrsf, theCopy, theMakeGroups, theTargetMesh); + anEditor.Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh); - if(theCopy) + if(theCopy || myPreviewMode) storeResult(anEditor); else + { + myMesh->GetMeshDS()->Modified(); myMesh->SetIsModified( true ); + } return theMakeGroups ? getGroups(groupIds.get()) : 0; } @@ -2983,16 +3256,17 @@ void SMESH_MeshEditor_i::Translate(const SMESH::long_array & theIDsOfElements, const SMESH::DirStruct & theVector, CORBA::Boolean theCopy) { - if ( !myPreviewMode ) { + if (!myPreviewMode) { TPythonDump() << this << ".Translate( " << theIDsOfElements << ", " << theVector << ", " << theCopy << " )"; } - translate(theIDsOfElements, - theVector, - theCopy, - false); + if (theIDsOfElements.length()) { + TIDSortedElemSet elements; + arrayToSet(theIDsOfElements, GetMeshDS(), elements); + translate(elements, theVector, theCopy, false); + } } //======================================================================= @@ -3004,32 +3278,39 @@ void SMESH_MeshEditor_i::TranslateObject(SMESH::SMESH_IDSource_ptr theObject, const SMESH::DirStruct & theVector, CORBA::Boolean theCopy) { - if ( !myPreviewMode ) { + if (!myPreviewMode) { TPythonDump() << this << ".TranslateObject( " << theObject << ", " << theVector << ", " << theCopy << " )"; } - SMESH::long_array_var anElementsId = theObject->GetIDs(); - translate(anElementsId, - theVector, - theCopy, - false); + TIDSortedElemSet elements; + + bool emptyIfIsMesh = myPreviewMode ? false : true; + + if (idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh)) + translate(elements, theVector, theCopy, false); } //======================================================================= //function : TranslateMakeGroups -//purpose : +//purpose : //======================================================================= SMESH::ListOfGroups* SMESH_MeshEditor_i::TranslateMakeGroups(const SMESH::long_array& theIDsOfElements, const SMESH::DirStruct& theVector) { - SMESH::ListOfGroups * aGroups = translate(theIDsOfElements,theVector,true,true); - if ( !myPreviewMode ) { - TPythonDump aPythonDump; - DumpGroupsList(aPythonDump,aGroups); + TPythonDump aPythonDump; // it is here to prevent dump of GetGroups() + + SMESH::ListOfGroups * aGroups = 0; + if (theIDsOfElements.length()) { + TIDSortedElemSet elements; + arrayToSet(theIDsOfElements, GetMeshDS(), elements); + aGroups = translate(elements,theVector,true,true); + } + if (!myPreviewMode) { + DumpGroupsList(aPythonDump, aGroups); aPythonDump << this << ".TranslateMakeGroups( " << theIDsOfElements << ", " << theVector << " )"; @@ -3039,20 +3320,22 @@ SMESH_MeshEditor_i::TranslateMakeGroups(const SMESH::long_array& theIDsOfElement //======================================================================= //function : TranslateObjectMakeGroups -//purpose : +//purpose : //======================================================================= SMESH::ListOfGroups* SMESH_MeshEditor_i::TranslateObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject, const SMESH::DirStruct& theVector) { - SMESH::long_array_var anElementsId = theObject->GetIDs(); - SMESH::ListOfGroups * aGroups = translate(anElementsId, theVector, true, true); + TPythonDump aPythonDump; // it is here to prevent dump of GetGroups() - if ( !myPreviewMode ) { + SMESH::ListOfGroups * aGroups = 0; + TIDSortedElemSet elements; + if (idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1)) + aGroups = translate(elements, theVector, true, true); - TPythonDump aPythonDump; - DumpGroupsList(aPythonDump,aGroups); + if (!myPreviewMode) { + DumpGroupsList(aPythonDump, aGroups); aPythonDump << this << ".TranslateObjectMakeGroups( " << theObject << ", " << theVector << " )"; @@ -3062,7 +3345,7 @@ SMESH_MeshEditor_i::TranslateObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObjec //======================================================================= //function : TranslateMakeMesh -//purpose : +//purpose : //======================================================================= SMESH::SMESH_Mesh_ptr @@ -3082,9 +3365,11 @@ SMESH_MeshEditor_i::TranslateMakeMesh(const SMESH::long_array& theIDsOfElements, mesh = makeMesh( theMeshName ); mesh_i = SMESH::DownCast( mesh ); - if ( mesh_i ) { - translate(theIDsOfElements, theVector, - false, theCopyGroups, & mesh_i->GetImpl()); + if ( mesh_i && theIDsOfElements.length() ) + { + TIDSortedElemSet elements; + arrayToSet(theIDsOfElements, GetMeshDS(), elements); + translate(elements, theVector, false, theCopyGroups, & mesh_i->GetImpl()); mesh_i->CreateGroupServants(); } @@ -3098,7 +3383,7 @@ SMESH_MeshEditor_i::TranslateMakeMesh(const SMESH::long_array& theIDsOfElements, } //dump "GetGroups" - if(!myPreviewMode && mesh_i) + if (!myPreviewMode && mesh_i) mesh_i->GetGroups(); return mesh._retn(); @@ -3106,7 +3391,7 @@ SMESH_MeshEditor_i::TranslateMakeMesh(const SMESH::long_array& theIDsOfElements, //======================================================================= //function : TranslateObjectMakeMesh -//purpose : +//purpose : //======================================================================= SMESH::SMESH_Mesh_ptr @@ -3124,10 +3409,11 @@ SMESH_MeshEditor_i::TranslateObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject, mesh = makeMesh( theMeshName ); mesh_i = SMESH::DownCast( mesh ); - if ( mesh_i ) { - SMESH::long_array_var anElementsId = theObject->GetIDs(); - translate(anElementsId, theVector, - false, theCopyGroups, & mesh_i->GetImpl()); + TIDSortedElemSet elements; + if ( mesh_i && + idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1)) + { + translate(elements, theVector,false, theCopyGroups, & mesh_i->GetImpl()); mesh_i->CreateGroupServants(); } if ( !myPreviewMode ) { @@ -3139,8 +3425,8 @@ SMESH_MeshEditor_i::TranslateObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject, } } - //dump "GetGroups" - if(!myPreviewMode && mesh_i) + // dump "GetGroups" + if (!myPreviewMode && mesh_i) mesh_i->GetGroups(); return mesh._retn(); @@ -3148,21 +3434,21 @@ SMESH_MeshEditor_i::TranslateObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject, //======================================================================= //function : rotate -//purpose : +//purpose : //======================================================================= SMESH::ListOfGroups* -SMESH_MeshEditor_i::rotate(const SMESH::long_array & theIDsOfElements, +SMESH_MeshEditor_i::rotate(TIDSortedElemSet & theElements, const SMESH::AxisStruct & theAxis, CORBA::Double theAngle, CORBA::Boolean theCopy, - const bool theMakeGroups, + bool theMakeGroups, ::SMESH_Mesh* theTargetMesh) { initData(); - TIDSortedElemSet elements; - arrayToSet(theIDsOfElements, GetMeshDS(), elements); + if ( theTargetMesh ) + theCopy = false; gp_Pnt P ( theAxis.x, theAxis.y, theAxis.z ); gp_Vec V ( theAxis.vx, theAxis.vy, theAxis.vz ); @@ -3170,14 +3456,35 @@ SMESH_MeshEditor_i::rotate(const SMESH::long_array & theIDsOfElements, gp_Trsf aTrsf; aTrsf.SetRotation( gp_Ax1( P, V ), theAngle); - ::SMESH_MeshEditor anEditor( myMesh ); + TIDSortedElemSet copyElements; + TIDSortedElemSet* workElements = &theElements; + TPreviewMesh tmpMesh; + SMESH_Mesh* mesh = myMesh; + + if ( myPreviewMode ) { + tmpMesh.Copy( theElements, copyElements ); + if ( !theCopy && !theTargetMesh ) + { + TIDSortedElemSet elemsAround, elemsAroundCopy; + getElementsAround( theElements, GetMeshDS(), elemsAround ); + tmpMesh.Copy( elemsAround, elemsAroundCopy); + } + mesh = &tmpMesh; + workElements = ©Elements; + theMakeGroups = false; + } + + ::SMESH_MeshEditor anEditor( mesh ); ::SMESH_MeshEditor::PGroupIDs groupIds = - anEditor.Transform (elements, aTrsf, theCopy, theMakeGroups, theTargetMesh); + anEditor.Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh); - if(theCopy) + if(theCopy || myPreviewMode) storeResult(anEditor); else + { + myMesh->GetMeshDS()->Modified(); myMesh->SetIsModified( true ); + } return theMakeGroups ? getGroups(groupIds.get()) : 0; } @@ -3192,18 +3499,19 @@ void SMESH_MeshEditor_i::Rotate(const SMESH::long_array & theIDsOfElements, CORBA::Double theAngle, CORBA::Boolean theCopy) { - if ( !myPreviewMode ) { + if (!myPreviewMode) { TPythonDump() << this << ".Rotate( " << theIDsOfElements << ", " << theAxis << ", " << theAngle << ", " << theCopy << " )"; } - rotate(theIDsOfElements, - theAxis, - theAngle, - theCopy, - false); + if (theIDsOfElements.length() > 0) + { + TIDSortedElemSet elements; + arrayToSet(theIDsOfElements, GetMeshDS(), elements); + rotate(elements,theAxis,theAngle,theCopy,false); + } } //======================================================================= @@ -3223,17 +3531,15 @@ void SMESH_MeshEditor_i::RotateObject(SMESH::SMESH_IDSource_ptr theObject, << theAngle << ", " << theCopy << " )"; } - SMESH::long_array_var anElementsId = theObject->GetIDs(); - rotate(anElementsId, - theAxis, - theAngle, - theCopy, - false); + TIDSortedElemSet elements; + bool emptyIfIsMesh = myPreviewMode ? false : true; + if (idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh)) + rotate(elements,theAxis,theAngle,theCopy,false); } //======================================================================= //function : RotateMakeGroups -//purpose : +//purpose : //======================================================================= SMESH::ListOfGroups* @@ -3241,10 +3547,17 @@ SMESH_MeshEditor_i::RotateMakeGroups(const SMESH::long_array& theIDsOfElements, const SMESH::AxisStruct& theAxis, CORBA::Double theAngle) { - SMESH::ListOfGroups * aGroups = rotate(theIDsOfElements,theAxis,theAngle,true,true); - if ( !myPreviewMode ) { - TPythonDump aPythonDump; - DumpGroupsList(aPythonDump,aGroups); + TPythonDump aPythonDump; // it is here to prevent dump of GetGroups() + + SMESH::ListOfGroups * aGroups = 0; + if (theIDsOfElements.length() > 0) + { + TIDSortedElemSet elements; + arrayToSet(theIDsOfElements, GetMeshDS(), elements); + aGroups = rotate(elements,theAxis,theAngle,true,true); + } + if (!myPreviewMode) { + DumpGroupsList(aPythonDump, aGroups); aPythonDump << this << ".RotateMakeGroups( " << theIDsOfElements << ", " << theAxis << ", " @@ -3255,7 +3568,7 @@ SMESH_MeshEditor_i::RotateMakeGroups(const SMESH::long_array& theIDsOfElements, //======================================================================= //function : RotateObjectMakeGroups -//purpose : +//purpose : //======================================================================= SMESH::ListOfGroups* @@ -3263,12 +3576,15 @@ SMESH_MeshEditor_i::RotateObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject, const SMESH::AxisStruct& theAxis, CORBA::Double theAngle) { - SMESH::long_array_var anElementsId = theObject->GetIDs(); - SMESH::ListOfGroups * aGroups = rotate(anElementsId,theAxis,theAngle,true,true); + TPythonDump aPythonDump; // it is here to prevent dump of GetGroups() - if ( !myPreviewMode ) { - TPythonDump aPythonDump; - DumpGroupsList(aPythonDump,aGroups); + SMESH::ListOfGroups * aGroups = 0; + TIDSortedElemSet elements; + if (idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1)) + aGroups = rotate(elements, theAxis, theAngle, true, true); + + if (!myPreviewMode) { + DumpGroupsList(aPythonDump, aGroups); aPythonDump << this << ".RotateObjectMakeGroups( " << theObject << ", " << theAxis << ", " @@ -3279,10 +3595,10 @@ SMESH_MeshEditor_i::RotateObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject, //======================================================================= //function : RotateMakeMesh -//purpose : +//purpose : //======================================================================= -SMESH::SMESH_Mesh_ptr +SMESH::SMESH_Mesh_ptr SMESH_MeshEditor_i::RotateMakeMesh(const SMESH::long_array& theIDsOfElements, const SMESH::AxisStruct& theAxis, CORBA::Double theAngleInRadians, @@ -3300,8 +3616,11 @@ SMESH_MeshEditor_i::RotateMakeMesh(const SMESH::long_array& theIDsOfElements, mesh = makeMesh( theMeshName ); mesh_i = SMESH::DownCast( mesh ); - if ( mesh_i ) { - rotate(theIDsOfElements, theAxis, theAngleInRadians, + if ( mesh_i && theIDsOfElements.length() > 0 ) + { + TIDSortedElemSet elements; + arrayToSet(theIDsOfElements, GetMeshDS(), elements); + rotate(elements, theAxis, theAngleInRadians, false, theCopyGroups, & mesh_i->GetImpl()); mesh_i->CreateGroupServants(); } @@ -3315,8 +3634,8 @@ SMESH_MeshEditor_i::RotateMakeMesh(const SMESH::long_array& theIDsOfElements, } } - //dump "GetGroups" - if(!myPreviewMode && mesh_i) + // dump "GetGroups" + if (!myPreviewMode && mesh_i && theIDsOfElements.length() > 0 ) mesh_i->GetGroups(); return mesh._retn(); @@ -3324,10 +3643,10 @@ SMESH_MeshEditor_i::RotateMakeMesh(const SMESH::long_array& theIDsOfElements, //======================================================================= //function : RotateObjectMakeMesh -//purpose : +//purpose : //======================================================================= -SMESH::SMESH_Mesh_ptr +SMESH::SMESH_Mesh_ptr SMESH_MeshEditor_i::RotateObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject, const SMESH::AxisStruct& theAxis, CORBA::Double theAngleInRadians, @@ -3344,9 +3663,11 @@ SMESH_MeshEditor_i::RotateObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject, mesh = makeMesh( theMeshName ); mesh_i = SMESH::DownCast( mesh ); - if (mesh_i ) { - SMESH::long_array_var anElementsId = theObject->GetIDs(); - rotate(anElementsId, theAxis, theAngleInRadians, + TIDSortedElemSet elements; + if (mesh_i && + idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1)) + { + rotate(elements, theAxis, theAngleInRadians, false, theCopyGroups, & mesh_i->GetImpl()); mesh_i->CreateGroupServants(); } @@ -3360,52 +3681,84 @@ SMESH_MeshEditor_i::RotateObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject, } } - //dump "GetGroups" - if(!myPreviewMode && mesh_i) + // dump "GetGroups" + if (!myPreviewMode && mesh_i) mesh_i->GetGroups(); return mesh._retn(); } - //======================================================================= //function : scale -//purpose : +//purpose : //======================================================================= SMESH::ListOfGroups* -SMESH_MeshEditor_i::scale(const SMESH::long_array & theIDsOfElements, +SMESH_MeshEditor_i::scale(SMESH::SMESH_IDSource_ptr theObject, const SMESH::PointStruct& thePoint, const SMESH::double_array& theScaleFact, CORBA::Boolean theCopy, - const bool theMakeGroups, + bool theMakeGroups, ::SMESH_Mesh* theTargetMesh) { initData(); + if ( theScaleFact.length() < 1 ) + THROW_SALOME_CORBA_EXCEPTION("Scale factor not given", SALOME::BAD_PARAM); + if ( theScaleFact.length() == 2 ) + THROW_SALOME_CORBA_EXCEPTION("Invalid nb of scale factors : 2", SALOME::BAD_PARAM); + + if ( theTargetMesh ) + theCopy = false; TIDSortedElemSet elements; - arrayToSet(theIDsOfElements, GetMeshDS(), elements); + bool emptyIfIsMesh = myPreviewMode ? false : true; + if ( !idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh)) + return 0; - gp_Pnt aPnt( thePoint.x, thePoint.y, thePoint.z ); - list aScaleFact; - for (int i = 0; i < theScaleFact.length(); i++) { - aScaleFact.push_back( theScaleFact[i] ); + double S[3] = { + theScaleFact[0], + (theScaleFact.length() == 1) ? theScaleFact[0] : theScaleFact[1], + (theScaleFact.length() == 1) ? theScaleFact[0] : theScaleFact[2], + }; + double tol = std::numeric_limits::max(); + gp_Trsf aTrsf; + aTrsf.SetValues( S[0], 0, 0, thePoint.x * (1-S[0]), + 0, S[1], 0, thePoint.y * (1-S[1]), + 0, 0, S[2], thePoint.z * (1-S[2]), tol, tol); + + TIDSortedElemSet copyElements; + TPreviewMesh tmpMesh; + TIDSortedElemSet* workElements = &elements; + SMESH_Mesh* mesh = myMesh; + + if ( myPreviewMode ) + { + tmpMesh.Copy( elements, copyElements); + if ( !theCopy && !theTargetMesh ) + { + TIDSortedElemSet elemsAround, elemsAroundCopy; + getElementsAround( elements, GetMeshDS(), elemsAround ); + tmpMesh.Copy( elemsAround, elemsAroundCopy); + } + mesh = &tmpMesh; + workElements = & copyElements; + theMakeGroups = false; } - ::SMESH_MeshEditor anEditor( myMesh ); + ::SMESH_MeshEditor anEditor( mesh ); ::SMESH_MeshEditor::PGroupIDs groupIds = - anEditor.Scale (elements, aPnt, aScaleFact, theCopy, - theMakeGroups, theTargetMesh); + anEditor.Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh); - if(theCopy) + if(theCopy || myPreviewMode ) storeResult(anEditor); else + { + myMesh->GetMeshDS()->Modified(); myMesh->SetIsModified( true ); - + } return theMakeGroups ? getGroups(groupIds.get()) : 0; } - //======================================================================= //function : Scale //purpose : @@ -3424,14 +3777,13 @@ void SMESH_MeshEditor_i::Scale(SMESH::SMESH_IDSource_ptr theObject, << theScaleFact << ", " << theCopy << " )"; } - SMESH::long_array_var anElementsId = theObject->GetIDs(); - scale(anElementsId, thePoint, theScaleFact, theCopy, false); + scale(theObject, thePoint, theScaleFact, theCopy, false); } //======================================================================= //function : ScaleMakeGroups -//purpose : +//purpose : //======================================================================= SMESH::ListOfGroups* @@ -3439,14 +3791,11 @@ SMESH_MeshEditor_i::ScaleMakeGroups(SMESH::SMESH_IDSource_ptr theObject, const SMESH::PointStruct& thePoint, const SMESH::double_array& theScaleFact) { - SMESH::long_array_var anElementsId = theObject->GetIDs(); - SMESH::ListOfGroups * aGroups = - scale(anElementsId, thePoint, theScaleFact, true, true); - - if ( !myPreviewMode ) { + TPythonDump aPythonDump; // it is here to prevent dump of GetGroups() - TPythonDump aPythonDump; - DumpGroupsList(aPythonDump,aGroups); + SMESH::ListOfGroups * aGroups = scale(theObject, thePoint, theScaleFact, true, true); + if (!myPreviewMode) { + DumpGroupsList(aPythonDump, aGroups); aPythonDump << this << ".Scale(" << theObject << "," << "SMESH.PointStruct(" <( mesh ); - if ( mesh_i ) { - SMESH::long_array_var anElementsId = theObject->GetIDs(); - scale(anElementsId, thePoint, theScaleFact, - false, theCopyGroups, & mesh_i->GetImpl()); + if ( mesh_i ) + { + scale(theObject, thePoint, theScaleFact,false, theCopyGroups, & mesh_i->GetImpl()); mesh_i->CreateGroupServants(); } - if ( !myPreviewMode ) { + if ( !myPreviewMode ) pydump << mesh << " = " << this << ".ScaleMakeMesh( " << theObject << ", " << "SMESH.PointStruct( " << thePoint.x << ", " @@ -3492,11 +3840,10 @@ SMESH_MeshEditor_i::ScaleMakeMesh(SMESH::SMESH_IDSource_ptr theObject, << theScaleFact << ", " << theCopyGroups << ", '" << theMeshName << "' )"; - } } - //dump "GetGroups" - if(!myPreviewMode && mesh_i) + // dump "GetGroups" + if (!myPreviewMode && mesh_i) mesh_i->GetGroups(); return mesh._retn(); @@ -3515,7 +3862,7 @@ void SMESH_MeshEditor_i::FindCoincidentNodes (CORBA::Double Tol ::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes; ::SMESH_MeshEditor anEditor( myMesh ); - set nodes; // no input nodes + TIDSortedNodeSet nodes; // no input nodes anEditor.FindCoincidentNodes( nodes, Tolerance, aListOfListOfNodes ); GroupsOfNodes = new SMESH::array_of_long_array; @@ -3542,33 +3889,9 @@ void SMESH_MeshEditor_i::FindCoincidentNodesOnPart(SMESH::SMESH_IDSource_ptr SMESH::array_of_long_array_out GroupsOfNodes) { initData(); - SMESH::long_array_var aElementsId = theObject->GetIDs(); - - SMESHDS_Mesh* aMesh = GetMeshDS(); - set nodes; - - SMESH::SMESH_GroupBase_var group = SMESH::SMESH_GroupBase::_narrow(theObject); - if ( !group->_is_nil() && group->GetType() == SMESH::NODE) - { - for(int i = 0; i < aElementsId->length(); i++) { - CORBA::Long ind = aElementsId[i]; - const SMDS_MeshNode * elem = aMesh->FindNode(ind); - if(elem) - nodes.insert(elem); - } - } - else { - for(int i = 0; i < aElementsId->length(); i++) { - CORBA::Long ind = aElementsId[i]; - const SMDS_MeshElement * elem = aMesh->FindElement(ind); - if(elem) { - SMDS_ElemIteratorPtr nIt = elem->nodesIterator(); - while ( nIt->more() ) - nodes.insert( nodes.end(),static_cast(nIt->next())); - } - } - } + TIDSortedNodeSet nodes; + idSourceToNodeSet( theObject, GetMeshDS(), nodes ); ::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes; ::SMESH_MeshEditor anEditor( myMesh ); @@ -3578,7 +3901,8 @@ void SMESH_MeshEditor_i::FindCoincidentNodesOnPart(SMESH::SMESH_IDSource_ptr GroupsOfNodes = new SMESH::array_of_long_array; GroupsOfNodes->length( aListOfListOfNodes.size() ); ::SMESH_MeshEditor::TListOfListOfNodes::iterator llIt = aListOfListOfNodes.begin(); - for ( CORBA::Long i = 0; llIt != aListOfListOfNodes.end(); llIt++, i++ ) { + for ( CORBA::Long i = 0; llIt != aListOfListOfNodes.end(); llIt++, i++ ) + { list< const SMDS_MeshNode* >& aListOfNodes = *llIt; list< const SMDS_MeshNode* >::iterator lIt = aListOfNodes.begin();; SMESH::long_array& aGroup = (*GroupsOfNodes)[ i ]; @@ -3591,6 +3915,55 @@ void SMESH_MeshEditor_i::FindCoincidentNodesOnPart(SMESH::SMESH_IDSource_ptr << Tolerance << " )"; } +//================================================================================ +/*! + * \brief Finds nodes coinsident with Tolerance within Object excluding nodes within + * ExceptSubMeshOrGroups + */ +//================================================================================ + +void SMESH_MeshEditor_i:: +FindCoincidentNodesOnPartBut(SMESH::SMESH_IDSource_ptr theObject, + CORBA::Double theTolerance, + SMESH::array_of_long_array_out theGroupsOfNodes, + const SMESH::ListOfIDSources& theExceptSubMeshOrGroups) +{ + initData(); + + TIDSortedNodeSet nodes; + idSourceToNodeSet( theObject, GetMeshDS(), nodes ); + + for ( int i = 0; i < theExceptSubMeshOrGroups.length(); ++i ) + { + TIDSortedNodeSet exceptNodes; + idSourceToNodeSet( theExceptSubMeshOrGroups[i], GetMeshDS(), exceptNodes ); + TIDSortedNodeSet::iterator avoidNode = exceptNodes.begin(); + for ( ; avoidNode != exceptNodes.end(); ++avoidNode) + nodes.erase( *avoidNode ); + } + ::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes; + ::SMESH_MeshEditor anEditor( myMesh ); + if(!nodes.empty()) + anEditor.FindCoincidentNodes( nodes, theTolerance, aListOfListOfNodes ); + + theGroupsOfNodes = new SMESH::array_of_long_array; + theGroupsOfNodes->length( aListOfListOfNodes.size() ); + ::SMESH_MeshEditor::TListOfListOfNodes::iterator llIt = aListOfListOfNodes.begin(); + for ( CORBA::Long i = 0; llIt != aListOfListOfNodes.end(); llIt++, i++ ) + { + list< const SMDS_MeshNode* >& aListOfNodes = *llIt; + list< const SMDS_MeshNode* >::iterator lIt = aListOfNodes.begin();; + SMESH::long_array& aGroup = (*theGroupsOfNodes)[ i ]; + aGroup.length( aListOfNodes.size() ); + for ( int j = 0; lIt != aListOfNodes.end(); lIt++, j++ ) + aGroup[ j ] = (*lIt)->GetID(); + } + TPythonDump() << "coincident_nodes_on_part = " << this << ".FindCoincidentNodesOnPartBut( " + << theObject<<", " + << theTolerance << ", " + << theExceptSubMeshOrGroups << " )"; +} + //======================================================================= //function : MergeNodes //purpose : @@ -3627,7 +4000,7 @@ void SMESH_MeshEditor_i::MergeNodes (const SMESH::array_of_long_array& GroupsOfN anEditor.MergeNodes( aListOfListOfNodes ); aTPythonDump << "])"; - + myMesh->GetMeshDS()->Modified(); myMesh->SetIsModified( true ); } @@ -3709,7 +4082,7 @@ void SMESH_MeshEditor_i::MergeElements(const SMESH::array_of_long_array& GroupsO ::SMESH_MeshEditor anEditor( myMesh ); anEditor.MergeElements(aListOfListOfElementsID); - + myMesh->GetMeshDS()->Modified(); myMesh->SetIsModified( true ); aTPythonDump << "] )"; @@ -3750,16 +4123,39 @@ CORBA::Boolean SMESH_MeshEditor_i::MoveNode(CORBA::Long NodeID, if ( theNodeSearcher ) theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other - if ( theNodeSearcher ) // move node and update theNodeSearcher data accordingly + if ( myPreviewMode ) // make preview data + { + // in a preview mesh, make edges linked to a node + TPreviewMesh tmpMesh; + TIDSortedElemSet linkedNodes; + ::SMESH_MeshEditor::GetLinkedNodes( node, linkedNodes ); + TIDSortedElemSet::iterator nIt = linkedNodes.begin(); + SMDS_MeshNode *nodeCpy1 = tmpMesh.Copy(node); + for ( ; nIt != linkedNodes.end(); ++nIt ) + { + SMDS_MeshNode *nodeCpy2 = tmpMesh.Copy ( cast2Node( *nIt )); + tmpMesh.GetMeshDS()->AddEdge(nodeCpy1, nodeCpy2); + } + // move copied node + if ( nodeCpy1 ) + tmpMesh.GetMeshDS()->MoveNode(nodeCpy1, x, y, z); + // fill preview data + ::SMESH_MeshEditor anEditor( & tmpMesh ); + storeResult( anEditor ); + } + else if ( theNodeSearcher ) // move node and update theNodeSearcher data accordingly theNodeSearcher->MoveNode(node, gp_Pnt( x,y,z )); else GetMeshDS()->MoveNode(node, x, y, z); - // Update Python script - TPythonDump() << "isDone = " << this << ".MoveNode( " - << NodeID << ", " << x << ", " << y << ", " << z << " )"; - - myMesh->SetIsModified( true ); + if ( !myPreviewMode ) + { + // Update Python script + TPythonDump() << "isDone = " << this << ".MoveNode( " + << NodeID << ", " << x << ", " << y << ", " << z << " )"; + myMesh->GetMeshDS()->Modified(); + myMesh->SetIsModified( true ); + } return true; } @@ -3829,7 +4225,7 @@ CORBA::Long SMESH_MeshEditor_i::MoveClosestNodeToPoint(CORBA::Double x, TIDSortedElemSet::iterator nIt = linkedNodes.begin(); for ( ; nIt != linkedNodes.end(); ++nIt ) { - SMDS_MeshEdge edge( node, cast2Node( *nIt )); + SMDS_LinearEdge edge( node, cast2Node( *nIt )); tmpMesh.Copy( &edge ); } // move copied node @@ -3856,6 +4252,7 @@ CORBA::Long SMESH_MeshEditor_i::MoveClosestNodeToPoint(CORBA::Double x, << ".MoveClosestNodeToPoint( "<< x << ", " << y << ", " << z << ", " << nodeID << " )"; + myMesh->GetMeshDS()->Modified(); myMesh->SetIsModified( true ); } @@ -4001,6 +4398,7 @@ SMESH_MeshEditor_i::SewFreeBorders(CORBA::Long FirstNodeID1, storeResult(anEditor); + myMesh->GetMeshDS()->Modified(); myMesh->SetIsModified( true ); return error; @@ -4058,6 +4456,7 @@ SMESH_MeshEditor_i::SewConformFreeBorders(CORBA::Long FirstNodeID1, storeResult(anEditor); + myMesh->GetMeshDS()->Modified(); myMesh->SetIsModified( true ); return error; @@ -4120,6 +4519,7 @@ SMESH_MeshEditor_i::SewBorderToSide(CORBA::Long FirstNodeIDOnFreeBorder, storeResult(anEditor); + myMesh->GetMeshDS()->Modified(); myMesh->SetIsModified( true ); return error; @@ -4177,6 +4577,7 @@ SMESH_MeshEditor_i::SewSideElements(const SMESH::long_array& IDsOfSide1Elements, storeResult(anEditor); + myMesh->GetMeshDS()->Modified(); myMesh->SetIsModified( true ); return error; @@ -4213,8 +4614,10 @@ CORBA::Boolean SMESH_MeshEditor_i::ChangeElemNodes(CORBA::Long ide, TPythonDump() << "isDone = " << this << ".ChangeElemNodes( " << ide << ", " << newIDs << " )"; + MESSAGE("ChangeElementNodes"); bool res = GetMeshDS()->ChangeElementNodes( elem, & aNodes[0], nbn1+1 ); + myMesh->GetMeshDS()->Modified(); if ( res ) myMesh->SetIsModified( true ); @@ -4230,7 +4633,7 @@ CORBA::Boolean SMESH_MeshEditor_i::ChangeElemNodes(CORBA::Long ide, void SMESH_MeshEditor_i::storeResult(::SMESH_MeshEditor& anEditor) { - if ( myPreviewMode ) { // --- MeshPreviewStruct filling --- + if ( myPreviewMode ) { // --- MeshPreviewStruct filling --- list aNodesConnectivity; typedef map TNodesMap; @@ -4261,7 +4664,7 @@ void SMESH_MeshEditor_i::storeResult(::SMESH_MeshEditor& anEditor) SMDS_ElemIteratorPtr itElemNodes = aMeshElem->nodesIterator(); while ( itElemNodes->more() ) { - const SMDS_MeshNode* aMeshNode = + const SMDS_MeshNode* aMeshNode = static_cast( itElemNodes->next() ); int aNodeID = aMeshNode->GetID(); TNodesMap::iterator anIter = nodesMap.find(aNodeID); @@ -4306,18 +4709,22 @@ void SMESH_MeshEditor_i::storeResult(::SMESH_MeshEditor& anEditor) } { - // add new nodes into myLastCreatedNodes + // append new nodes into myLastCreatedNodes const SMESH_SequenceOfElemPtr& aSeq = anEditor.GetLastCreatedNodes(); - myLastCreatedNodes->length(aSeq.Length()); - for(int i=0; iGetID(); + int j = myLastCreatedNodes->length(); + int newLen = j + aSeq.Length(); + myLastCreatedNodes->length( newLen ); + for(int i=0; jGetID(); } { - // add new elements into myLastCreatedElems + // append new elements into myLastCreatedElems const SMESH_SequenceOfElemPtr& aSeq = anEditor.GetLastCreatedElems(); - myLastCreatedElems->length(aSeq.Length()); - for(int i=0; iGetID(); + int j = myLastCreatedElems->length(); + int newLen = j + aSeq.Length(); + myLastCreatedElems->length( newLen ); + for(int i=0; jGetID(); } } @@ -4366,12 +4773,13 @@ void SMESH_MeshEditor_i::ConvertToQuadratic(CORBA::Boolean theForce3d) ::SMESH_MeshEditor anEditor( myMesh ); anEditor.ConvertToQuadratic(theForce3d); TPythonDump() << this << ".ConvertToQuadratic( " << theForce3d << " )"; + myMesh->GetMeshDS()->Modified(); myMesh->SetIsModified( true ); } //======================================================================= //function : ConvertFromQuadratic -//purpose : +//purpose : //======================================================================= CORBA::Boolean SMESH_MeshEditor_i::ConvertFromQuadratic() @@ -4379,34 +4787,103 @@ CORBA::Boolean SMESH_MeshEditor_i::ConvertFromQuadratic() ::SMESH_MeshEditor anEditor( myMesh ); CORBA::Boolean isDone = anEditor.ConvertFromQuadratic(); TPythonDump() << this << ".ConvertFromQuadratic()"; + myMesh->GetMeshDS()->Modified(); if ( isDone ) myMesh->SetIsModified( true ); return isDone; } +//================================================================================ +/*! + * \brief Makes a part of the mesh quadratic + */ +//================================================================================ -//======================================================================= -//function : makeMesh -//purpose : create a named imported mesh -//======================================================================= - -SMESH::SMESH_Mesh_ptr SMESH_MeshEditor_i::makeMesh(const char* theMeshName) -{ - SMESH_Gen_i* gen = SMESH_Gen_i::GetSMESHGen(); - SMESH::SMESH_Mesh_var mesh = gen->CreateEmptyMesh(); - SALOMEDS::Study_var study = gen->GetCurrentStudy(); - SALOMEDS::SObject_var meshSO = gen->ObjectToSObject( study, mesh ); - gen->SetName( meshSO, theMeshName, "Mesh" ); - gen->SetPixMap( meshSO, "ICON_SMESH_TREE_MESH_IMPORTED"); - - return mesh._retn(); -} - -//======================================================================= -//function : DumpGroupsList -//purpose : -//======================================================================= -void SMESH_MeshEditor_i::DumpGroupsList(TPythonDump & theDumpPython, - const SMESH::ListOfGroups * theGroupList) +void SMESH_MeshEditor_i::ConvertToQuadraticObject(CORBA::Boolean theForce3d, + SMESH::SMESH_IDSource_ptr theObject) + throw (SALOME::SALOME_Exception) +{ + Unexpect aCatch(SALOME_SalomeException); + TPythonDump pyDump; + TIDSortedElemSet elems; + if ( idSourceToSet( theObject, GetMeshDS(), elems, SMDSAbs_All, /*emptyIfIsMesh=*/true )) + { + if ( elems.empty() ) + { + ConvertToQuadratic( theForce3d ); + } + else if ( (*elems.begin())->GetType() == SMDSAbs_Node ) + { + THROW_SALOME_CORBA_EXCEPTION("Group of nodes is not allowed", SALOME::BAD_PARAM); + } + else + { + ::SMESH_MeshEditor anEditor( myMesh ); + anEditor.ConvertToQuadratic(theForce3d, elems); + } + } + myMesh->GetMeshDS()->Modified(); + myMesh->SetIsModified( true ); + + pyDump << this << ".ConvertToQuadraticObject( "<GetType() == SMDSAbs_Node ) + { + THROW_SALOME_CORBA_EXCEPTION("Group of nodes is not allowed", SALOME::BAD_PARAM); + } + else + { + ::SMESH_MeshEditor anEditor( myMesh ); + anEditor.ConvertFromQuadratic(elems); + } + } + myMesh->GetMeshDS()->Modified(); + myMesh->SetIsModified( true ); + + pyDump << this << ".ConvertFromQuadraticObject( "<CreateEmptyMesh(); + SALOMEDS::Study_var study = gen->GetCurrentStudy(); + SALOMEDS::SObject_var meshSO = gen->ObjectToSObject( study, mesh ); + gen->SetName( meshSO, theMeshName, "Mesh" ); + gen->SetPixMap( meshSO, "ICON_SMESH_TREE_MESH_IMPORTED"); + + return mesh._retn(); +} + +//======================================================================= +//function : DumpGroupsList +//purpose : +//======================================================================= +void SMESH_MeshEditor_i::DumpGroupsList(TPythonDump & theDumpPython, + const SMESH::ListOfGroups * theGroupList) { bool isDumpGroupList = theGroupList && theGroupList->length() > 0; if(isDumpGroupList) { @@ -4414,19 +4891,59 @@ void SMESH_MeshEditor_i::DumpGroupsList(TPythonDump & theDumpPytho } } +//================================================================================ +/*! + \brief Generates the unique group name. + \param thePrefix name prefix + \return unique name +*/ +//================================================================================ +string SMESH_MeshEditor_i::generateGroupName(const string& thePrefix) +{ + SMESH::ListOfGroups_var groups = myMesh_i->GetGroups(); + set groupNames; + + // Get existing group names + for (int i = 0, nbGroups = groups->length(); i < nbGroups; i++ ) { + SMESH::SMESH_GroupBase_var aGroup = groups[i]; + if (CORBA::is_nil(aGroup)) + continue; + + groupNames.insert(aGroup->GetName()); + } + + // Find new name + string name = thePrefix; + int index = 0; + + while (!groupNames.insert(name).second) { + if (index == 0) { + name += "_1"; + } + else { + TCollection_AsciiString nbStr(index+1); + name.resize( name.rfind('_')+1 ); + name += nbStr.ToCString(); + } + ++index; + } + + return name; +} + //================================================================================ /*! \brief Creates a hole in a mesh by doubling the nodes of some particular elements \param theNodes - identifiers of nodes to be doubled - \param theModifiedElems - identifiers of elements to be updated by the new (doubled) - nodes. If list of element identifiers is empty then nodes are doubled but + \param theModifiedElems - identifiers of elements to be updated by the new (doubled) + nodes. If list of element identifiers is empty then nodes are doubled but they not assigned to elements \return TRUE if operation has been completed successfully, FALSE otherwise \sa DoubleNode(), DoubleNodeGroup(), DoubleNodeGroups() */ //================================================================================ -CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theNodes, +CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theNodes, const SMESH::long_array& theModifiedElems ) { initData(); @@ -4443,10 +4960,14 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theNode bool aResult = aMeshEditor.DoubleNodes( aListOfNodes, aListOfElems ); + myMesh->GetMeshDS()->Modified(); storeResult( aMeshEditor) ; if ( aResult ) myMesh->SetIsModified( true ); + // Update Python script + TPythonDump() << this << ".DoubleNodes( " << theNodes << ", "<< theModifiedElems << " )"; + return aResult; } @@ -4461,15 +4982,19 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theNode */ //================================================================================ -CORBA::Boolean SMESH_MeshEditor_i::DoubleNode( CORBA::Long theNodeId, +CORBA::Boolean SMESH_MeshEditor_i::DoubleNode( CORBA::Long theNodeId, const SMESH::long_array& theModifiedElems ) { SMESH::long_array_var aNodes = new SMESH::long_array; aNodes->length( 1 ); aNodes[ 0 ] = theNodeId; - bool done = DoubleNodes( aNodes, theModifiedElems ); - if ( done ) - myMesh->SetIsModified( true ); + + TPythonDump pyDump; // suppress dump by the next line + + CORBA::Boolean done = DoubleNodes( aNodes, theModifiedElems ); + + pyDump << this << ".DoubleNode( " << theNodeId << ", " << theModifiedElems << " )"; + return done; } @@ -4484,9 +5009,8 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNode( CORBA::Long theNodeI */ //================================================================================ -CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroup( - SMESH::SMESH_GroupBase_ptr theNodes, - SMESH::SMESH_GroupBase_ptr theModifiedElems ) +CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroup(SMESH::SMESH_GroupBase_ptr theNodes, + SMESH::SMESH_GroupBase_ptr theModifiedElems ) { if ( CORBA::is_nil( theNodes ) && theNodes->GetType() != SMESH::NODE ) return false; @@ -4495,20 +5019,69 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroup( SMESH::long_array_var aModifiedElems; if ( !CORBA::is_nil( theModifiedElems ) ) aModifiedElems = theModifiedElems->GetListOfID(); - else + else { aModifiedElems = new SMESH::long_array; aModifiedElems->length( 0 ); } + TPythonDump pyDump; // suppress dump by the next line + bool done = DoubleNodes( aNodes, aModifiedElems ); - if ( done ) - myMesh->SetIsModified( true ); + pyDump << this << ".DoubleNodeGroup( " << theNodes << ", " << theModifiedElems << " )"; return done; } +/*! + * \brief Creates a hole in a mesh by doubling the nodes of some particular elements. + * Works as DoubleNodeGroup(), but returns a new group with newly created nodes. + * \param theNodes - group of nodes to be doubled. + * \param theModifiedElems - group of elements to be updated. + * \return a new group with newly created nodes + * \sa DoubleNodeGroup() + */ +SMESH::SMESH_Group_ptr SMESH_MeshEditor_i::DoubleNodeGroupNew( SMESH::SMESH_GroupBase_ptr theNodes, + SMESH::SMESH_GroupBase_ptr theModifiedElems ) +{ + if ( CORBA::is_nil( theNodes ) && theNodes->GetType() != SMESH::NODE ) + return false; + + SMESH::SMESH_Group_var aNewGroup; + + // Duplicate nodes + SMESH::long_array_var aNodes = theNodes->GetListOfID(); + SMESH::long_array_var aModifiedElems; + if ( !CORBA::is_nil( theModifiedElems ) ) + aModifiedElems = theModifiedElems->GetListOfID(); + else { + aModifiedElems = new SMESH::long_array; + aModifiedElems->length( 0 ); + } + + TPythonDump pyDump; // suppress dump by the next line + + bool aResult = DoubleNodes( aNodes, aModifiedElems ); + + if ( aResult ) + { + // Create group with newly created nodes + SMESH::long_array_var anIds = GetLastCreatedNodes(); + if (anIds->length() > 0) { + string anUnindexedName (theNodes->GetName()); + string aNewName = generateGroupName(anUnindexedName + "_double"); + aNewGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str()); + aNewGroup->Add(anIds); + } + } + + pyDump << "createdNodes = " << this << ".DoubleNodeGroupNew( " << theNodes << ", " + << theModifiedElems << " )"; + + return aNewGroup._retn(); +} + //================================================================================ /*! \brief Creates a hole in a mesh by doubling the nodes of some particular elements @@ -4520,9 +5093,8 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroup( */ //================================================================================ -CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups( - const SMESH::ListOfGroups& theNodes, - const SMESH::ListOfGroups& theModifiedElems ) +CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups(const SMESH::ListOfGroups& theNodes, + const SMESH::ListOfGroups& theModifiedElems ) { initData(); @@ -4557,26 +5129,69 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups( storeResult( aMeshEditor) ; + myMesh->GetMeshDS()->Modified(); if ( aResult ) myMesh->SetIsModified( true ); + + TPythonDump() << this << ".DoubleNodeGroups( " << theNodes << ", " << theModifiedElems << " )"; + return aResult; } +//================================================================================ +/*! + * \brief Creates a hole in a mesh by doubling the nodes of some particular elements. + * Works as DoubleNodeGroups(), but returns a new group with newly created nodes. + * \param theNodes - group of nodes to be doubled. + * \param theModifiedElems - group of elements to be updated. + * \return a new group with newly created nodes + * \sa DoubleNodeGroups() + */ +//================================================================================ + +SMESH::SMESH_Group_ptr SMESH_MeshEditor_i::DoubleNodeGroupsNew( const SMESH::ListOfGroups& theNodes, + const SMESH::ListOfGroups& theModifiedElems ) +{ + SMESH::SMESH_Group_var aNewGroup; + + TPythonDump pyDump; // suppress dump by the next line + + bool aResult = DoubleNodeGroups( theNodes, theModifiedElems ); + + if ( aResult ) + { + // Create group with newly created nodes + SMESH::long_array_var anIds = GetLastCreatedNodes(); + if (anIds->length() > 0) { + string anUnindexedName (theNodes[0]->GetName()); + string aNewName = generateGroupName(anUnindexedName + "_double"); + aNewGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str()); + aNewGroup->Add(anIds); + } + } + + pyDump << "createdNodes = " << this << ".DoubleNodeGroupsNew( " << theNodes << ", " + << theModifiedElems << " )"; + + return aNewGroup._retn(); +} + + //================================================================================ /*! \brief Creates a hole in a mesh by doubling the nodes of some particular elements \param theElems - the list of elements (edges or faces) to be replicated The nodes for duplication could be found from these elements \param theNodesNot - list of nodes to NOT replicate - \param theAffectedElems - the list of elements (cells and edges) to which the + \param theAffectedElems - the list of elements (cells and edges) to which the replicated nodes should be associated to. \return TRUE if operation has been completed successfully, FALSE otherwise \sa DoubleNodeGroup(), DoubleNodeGroups() */ //================================================================================ -CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElem( const SMESH::long_array& theElems, +CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElem( const SMESH::long_array& theElems, const SMESH::long_array& theNodesNot, const SMESH::long_array& theAffectedElems ) @@ -4595,12 +5210,13 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElem( const SMESH::long_array& theE storeResult( aMeshEditor) ; + myMesh->GetMeshDS()->Modified(); if ( aResult ) myMesh->SetIsModified( true ); // Update Python script - TPythonDump() << "isDone = " << this << ".DoubleNodes( " << theElems << ", " - << theNodesNot << ", " << theAffectedElems << " )"; + TPythonDump() << this << ".DoubleNodeElem( " << theElems << ", " + << theNodesNot << ", " << theAffectedElems << " )"; return aResult; } @@ -4618,10 +5234,9 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElem( const SMESH::long_array& theE */ //================================================================================ -CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemInRegion -( const SMESH::long_array& theElems, - const SMESH::long_array& theNodesNot, - GEOM::GEOM_Object_ptr theShape ) +CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemInRegion ( const SMESH::long_array& theElems, + const SMESH::long_array& theNodesNot, + GEOM::GEOM_Object_ptr theShape ) { initData(); @@ -4638,12 +5253,13 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemInRegion storeResult( aMeshEditor) ; + myMesh->GetMeshDS()->Modified(); if ( aResult ) myMesh->SetIsModified( true ); // Update Python script - TPythonDump() << "isDone = " << this << ".DoubleNodesInRegion( " << theElems << ", " - << theNodesNot << ", " << theShape << " )"; + TPythonDump() << "isDone = " << this << ".DoubleNodeElemInRegion( " << theElems << ", " + << theNodesNot << ", " << theShape << " )"; return aResult; } @@ -4659,18 +5275,6 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemInRegion */ //================================================================================ -static void groupToSet(SMESH::SMESH_GroupBase_ptr theGrp, - SMESHDS_Mesh* theMeshDS, - TIDSortedElemSet& theElemSet, - const SMDSAbs_ElementType theType) - -{ - if ( CORBA::is_nil( theGrp ) ) - return; - SMESH::long_array_var anIDs = theGrp->GetIDs(); - arrayToSet( anIDs, theMeshDS, theElemSet, theType); -} - CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemGroup(SMESH::SMESH_GroupBase_ptr theElems, SMESH::SMESH_GroupBase_ptr theNodesNot, SMESH::SMESH_GroupBase_ptr theAffectedElems) @@ -4684,23 +5288,78 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemGroup(SMESH::SMESH_GroupBase_pt SMESHDS_Mesh* aMeshDS = GetMeshDS(); TIDSortedElemSet anElems, aNodes, anAffected; - groupToSet( theElems, aMeshDS, anElems, SMDSAbs_All ); - groupToSet( theNodesNot, aMeshDS, aNodes, SMDSAbs_Node ); - groupToSet( theAffectedElems, aMeshDS, anAffected, SMDSAbs_All ); + idSourceToSet( theElems, aMeshDS, anElems, SMDSAbs_All ); + idSourceToSet( theNodesNot, aMeshDS, aNodes, SMDSAbs_Node ); + idSourceToSet( theAffectedElems, aMeshDS, anAffected, SMDSAbs_All ); bool aResult = aMeshEditor.DoubleNodes( anElems, aNodes, anAffected ); storeResult( aMeshEditor) ; + myMesh->GetMeshDS()->Modified(); if ( aResult ) myMesh->SetIsModified( true ); // Update Python script - TPythonDump() << "isDone = " << this << ".DoubleNodeGroup( " << theElems << ", " - << theNodesNot << ", " << theAffectedElems << " )"; + TPythonDump() << "isDone = " << this << ".DoubleNodeElemGroup( " << theElems << ", " + << theNodesNot << ", " << theAffectedElems << " )"; return aResult; } +/*! + * \brief Creates a hole in a mesh by doubling the nodes of some particular elements + * Works as DoubleNodeElemGroup(), but returns a new group with newly created elements. + * \param theElems - group of of elements (edges or faces) to be replicated + * \param theNodesNot - group of nodes not to replicated + * \param theAffectedElems - group of elements to which the replicated nodes + * should be associated to. + * \return a new group with newly created elements + * \sa DoubleNodeElemGroup() + */ +SMESH::SMESH_Group_ptr SMESH_MeshEditor_i::DoubleNodeElemGroupNew(SMESH::SMESH_GroupBase_ptr theElems, + SMESH::SMESH_GroupBase_ptr theNodesNot, + SMESH::SMESH_GroupBase_ptr theAffectedElems) +{ + if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE ) + return false; + + SMESH::SMESH_Group_var aNewGroup; + + initData(); + + ::SMESH_MeshEditor aMeshEditor( myMesh ); + + SMESHDS_Mesh* aMeshDS = GetMeshDS(); + TIDSortedElemSet anElems, aNodes, anAffected; + idSourceToSet( theElems, aMeshDS, anElems, SMDSAbs_All ); + idSourceToSet( theNodesNot, aMeshDS, aNodes, SMDSAbs_Node ); + idSourceToSet( theAffectedElems, aMeshDS, anAffected, SMDSAbs_All ); + + + bool aResult = aMeshEditor.DoubleNodes( anElems, aNodes, anAffected ); + + storeResult( aMeshEditor) ; + + if ( aResult ) { + myMesh->SetIsModified( true ); + + // Create group with newly created elements + SMESH::long_array_var anIds = GetLastCreatedElems(); + if (anIds->length() > 0) { + SMESH::ElementType aGroupType = myMesh_i->GetElementType(anIds[0], true); + string anUnindexedName (theElems->GetName()); + string aNewName = generateGroupName(anUnindexedName + "_double"); + aNewGroup = myMesh_i->CreateGroup(aGroupType, aNewName.c_str()); + aNewGroup->Add(anIds); + } + } + + // Update Python script + TPythonDump() << "createdElems = " << this << ".DoubleNodeElemGroupNew( " << theElems << ", " + << theNodesNot << ", " << theAffectedElems << " )"; + return aNewGroup._retn(); +} + //================================================================================ /*! \brief Creates a hole in a mesh by doubling the nodes of some particular elements @@ -4714,8 +5373,7 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemGroup(SMESH::SMESH_GroupBase_pt */ //================================================================================ -CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemGroupInRegion( - SMESH::SMESH_GroupBase_ptr theElems, +CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemGroupInRegion(SMESH::SMESH_GroupBase_ptr theElems, SMESH::SMESH_GroupBase_ptr theNodesNot, GEOM::GEOM_Object_ptr theShape ) @@ -4729,20 +5387,21 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemGroupInRegion( SMESHDS_Mesh* aMeshDS = GetMeshDS(); TIDSortedElemSet anElems, aNodes, anAffected; - groupToSet( theElems, aMeshDS, anElems, SMDSAbs_All ); - groupToSet( theNodesNot, aMeshDS, aNodes, SMDSAbs_Node ); + idSourceToSet( theElems, aMeshDS, anElems, SMDSAbs_All ); + idSourceToSet( theNodesNot, aMeshDS, aNodes, SMDSAbs_Node ); TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape ); bool aResult = aMeshEditor.DoubleNodesInRegion( anElems, aNodes, aShape ); storeResult( aMeshEditor) ; + myMesh->GetMeshDS()->Modified(); if ( aResult ) myMesh->SetIsModified( true ); // Update Python script - TPythonDump() << "isDone = " << this << ".DoubleNodeGroupInRegion( " << theElems << ", " - << theNodesNot << ", " << theShape << " )"; + TPythonDump() << "isDone = " << this << ".DoubleNodeElemGroupInRegion( " << theElems << ", " + << theNodesNot << ", " << theShape << " )"; return aResult; } @@ -4755,7 +5414,7 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemGroupInRegion( \param theAffectedElems - group of elements to which the replicated nodes should be associated to. \return TRUE if operation has been completed successfully, FALSE otherwise - \sa DoubleNodeGroup(), DoubleNodes() + \sa DoubleNodeGroup(), DoubleNodes(), DoubleNodeElemGroupsNew() */ //================================================================================ @@ -4767,7 +5426,7 @@ static void listOfGroupToSet(const SMESH::ListOfGroups& theGrpList, for ( int i = 0, n = theGrpList.length(); i < n; i++ ) { SMESH::SMESH_GroupBase_var aGrp = theGrpList[ i ]; - if ( !CORBA::is_nil( aGrp ) && (theIsNodeGrp ? aGrp->GetType() == SMESH::NODE + if ( !CORBA::is_nil( aGrp ) && (theIsNodeGrp ? aGrp->GetType() == SMESH::NODE : aGrp->GetType() != SMESH::NODE ) ) { SMESH::long_array_var anIDs = aGrp->GetIDs(); @@ -4794,15 +5453,70 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemGroups(const SMESH::ListOfGroup storeResult( aMeshEditor) ; + myMesh->GetMeshDS()->Modified(); if ( aResult ) myMesh->SetIsModified( true ); // Update Python script TPythonDump() << "isDone = " << this << ".DoubleNodeElemGroups( " << &theElems << ", " - << &theNodesNot << ", " << &theAffectedElems << " )"; + << &theNodesNot << ", " << &theAffectedElems << " )"; return aResult; } +//================================================================================ +/*! + * \brief Creates a hole in a mesh by doubling the nodes of some particular elements + * Works as DoubleNodeElemGroups(), but returns a new group with newly created elements. + \param theElems - list of groups of elements (edges or faces) to be replicated + \param theNodesNot - list of groups of nodes not to replicated + \param theAffectedElems - group of elements to which the replicated nodes + should be associated to. + * \return a new group with newly created elements + * \sa DoubleNodeElemGroups() + */ +//================================================================================ + +SMESH::SMESH_Group_ptr SMESH_MeshEditor_i::DoubleNodeElemGroupsNew(const SMESH::ListOfGroups& theElems, + const SMESH::ListOfGroups& theNodesNot, + const SMESH::ListOfGroups& theAffectedElems) +{ + SMESH::SMESH_Group_var aNewGroup; + + initData(); + + ::SMESH_MeshEditor aMeshEditor( myMesh ); + + SMESHDS_Mesh* aMeshDS = GetMeshDS(); + TIDSortedElemSet anElems, aNodes, anAffected; + listOfGroupToSet(theElems, aMeshDS, anElems, false ); + listOfGroupToSet(theNodesNot, aMeshDS, aNodes, true ); + listOfGroupToSet(theAffectedElems, aMeshDS, anAffected, false ); + + bool aResult = aMeshEditor.DoubleNodes( anElems, aNodes, anAffected ); + + storeResult( aMeshEditor) ; + + myMesh->GetMeshDS()->Modified(); + if ( aResult ) { + myMesh->SetIsModified( true ); + + // Create group with newly created elements + SMESH::long_array_var anIds = GetLastCreatedElems(); + if (anIds->length() > 0) { + SMESH::ElementType aGroupType = myMesh_i->GetElementType(anIds[0], true); + string anUnindexedName (theElems[0]->GetName()); + string aNewName = generateGroupName(anUnindexedName + "_double"); + aNewGroup = myMesh_i->CreateGroup(aGroupType, aNewName.c_str()); + aNewGroup->Add(anIds); + } + } + + // Update Python script + TPythonDump() << "createdElems = " << this << ".DoubleNodeElemGroupsNew( " << &theElems << ", " + << &theNodesNot << ", " << &theAffectedElems << " )"; + return aNewGroup._retn(); +} + //================================================================================ /*! \brief Creates a hole in a mesh by doubling the nodes of some particular elements @@ -4836,12 +5550,13 @@ SMESH_MeshEditor_i::DoubleNodeElemGroupsInRegion(const SMESH::ListOfGroups& theE storeResult( aMeshEditor) ; + myMesh->GetMeshDS()->Modified(); if ( aResult ) myMesh->SetIsModified( true ); // Update Python script - TPythonDump() << "isDone = " << this << ".DoubleNodeGroupsInRegion( " << &theElems << ", " - << &theNodesNot << ", " << theShape << " )"; + TPythonDump() << "isDone = " << this << ".DoubleNodeElemGroupsInRegion( " << &theElems << ", " + << &theNodesNot << ", " << theShape << " )"; return aResult; } @@ -4860,7 +5575,343 @@ CORBA::Boolean SMESH_MeshEditor_i::Make2DMeshFrom3D() ::SMESH_MeshEditor aMeshEditor( myMesh ); bool aResult = aMeshEditor.Make2DMeshFrom3D(); storeResult( aMeshEditor) ; - + myMesh->GetMeshDS()->Modified(); TPythonDump() << "isDone = " << this << ".Make2DMeshFrom3D()"; return aResult; } + +//================================================================================ +/*! + * \brief Double nodes on shared faces between groups of volumes and create flat elements on demand. + * The list of groups must describe a partition of the mesh volumes. + * The nodes of the internal faces at the boundaries of the groups are doubled. + * In option, the internal faces are replaced by flat elements. + * Triangles are transformed in prisms, and quadrangles in hexahedrons. + * The flat elements are stored in groups of volumes. + * @param theDomains - list of groups of volumes + * @param createJointElems - if TRUE, create the elements + * @return TRUE if operation has been completed successfully, FALSE otherwise + */ +//================================================================================ + +CORBA::Boolean SMESH_MeshEditor_i::DoubleNodesOnGroupBoundaries( const SMESH::ListOfGroups& theDomains, + CORBA::Boolean createJointElems ) +{ + initData(); + + ::SMESH_MeshEditor aMeshEditor( myMesh ); + + SMESHDS_Mesh* aMeshDS = GetMeshDS(); + + vector domains; + domains.clear(); + + for ( int i = 0, n = theDomains.length(); i < n; i++ ) + { + SMESH::SMESH_GroupBase_var aGrp = theDomains[ i ]; + if ( !CORBA::is_nil( aGrp ) && ( aGrp->GetType() != SMESH::NODE ) ) + { + TIDSortedElemSet domain; + domain.clear(); + domains.push_back(domain); + SMESH::long_array_var anIDs = aGrp->GetIDs(); + arrayToSet( anIDs, aMeshDS, domains[ i ], SMDSAbs_All ); + } + } + + bool aResult = aMeshEditor.DoubleNodesOnGroupBoundaries( domains, createJointElems ); + // TODO publish the groups of flat elements in study + + storeResult( aMeshEditor) ; + myMesh->GetMeshDS()->Modified(); + + // Update Python script + TPythonDump() << "isDone = " << this << ".DoubleNodesOnGroupBoundaries( " << &theDomains + << ", " << createJointElems << " )"; + return aResult; +} + +//================================================================================ +/*! + * \brief Double nodes on some external faces and create flat elements. + * Flat elements are mainly used by some types of mechanic calculations. + * + * Each group of the list must be constituted of faces. + * Triangles are transformed in prisms, and quadrangles in hexahedrons. + * @param theGroupsOfFaces - list of groups of faces + * @return TRUE if operation has been completed successfully, FALSE otherwise + */ +//================================================================================ + +CORBA::Boolean SMESH_MeshEditor_i::CreateFlatElementsOnFacesGroups( const SMESH::ListOfGroups& theGroupsOfFaces ) +{ + initData(); + + ::SMESH_MeshEditor aMeshEditor( myMesh ); + + SMESHDS_Mesh* aMeshDS = GetMeshDS(); + + vector faceGroups; + faceGroups.clear(); + + for ( int i = 0, n = theGroupsOfFaces.length(); i < n; i++ ) + { + SMESH::SMESH_GroupBase_var aGrp = theGroupsOfFaces[ i ]; + if ( !CORBA::is_nil( aGrp ) && ( aGrp->GetType() != SMESH::NODE ) ) + { + TIDSortedElemSet faceGroup; + faceGroup.clear(); + faceGroups.push_back(faceGroup); + SMESH::long_array_var anIDs = aGrp->GetIDs(); + arrayToSet( anIDs, aMeshDS, faceGroups[ i ], SMDSAbs_All ); + } + } + + bool aResult = aMeshEditor.CreateFlatElementsOnFacesGroups( faceGroups ); + // TODO publish the groups of flat elements in study + + storeResult( aMeshEditor) ; + myMesh->GetMeshDS()->Modified(); + + // Update Python script + TPythonDump() << "isDone = " << this << ".CreateFlatElementsOnFacesGroups( " << &theGroupsOfFaces << " )"; + return aResult; +} + +// issue 20749 =================================================================== +/*! + * \brief Creates missing boundary elements + * \param elements - elements whose boundary is to be checked + * \param dimension - defines type of boundary elements to create + * \param groupName - a name of group to store created boundary elements in, + * "" means not to create the group + * \param meshName - a name of new mesh to store created boundary elements in, + * "" means not to create the new mesh + * \param toCopyElements - if true, the checked elements will be copied into the new mesh + * \param toCopyExistingBondary - if true, not only new but also pre-existing + * boundary elements will be copied into the new mesh + * \param group - returns the create group, if any + * \retval SMESH::SMESH_Mesh - the mesh where elements were added to + */ +// ================================================================================ + +SMESH::SMESH_Mesh_ptr +SMESH_MeshEditor_i::MakeBoundaryMesh(SMESH::SMESH_IDSource_ptr idSource, + SMESH::Bnd_Dimension dim, + const char* groupName, + const char* meshName, + CORBA::Boolean toCopyElements, + CORBA::Boolean toCopyExistingBondary, + SMESH::SMESH_Group_out group) +{ + initData(); + + if ( dim > SMESH::BND_1DFROM2D ) + THROW_SALOME_CORBA_EXCEPTION("Invalid boundary dimension", SALOME::BAD_PARAM); + + SMESHDS_Mesh* aMeshDS = GetMeshDS(); + + SMESH::SMESH_Mesh_var mesh_var; + SMESH::SMESH_Group_var group_var; + + TPythonDump pyDump; + + TIDSortedElemSet elements; + SMDSAbs_ElementType elemType = (dim == SMESH::BND_1DFROM2D) ? SMDSAbs_Face : SMDSAbs_Volume; + if ( idSourceToSet( idSource, aMeshDS, elements, elemType,/*emptyIfIsMesh=*/true )) + { + // mesh to fill in + mesh_var = + strlen(meshName) ? makeMesh(meshName) : SMESH::SMESH_Mesh::_duplicate(myMesh_i->_this()); + SMESH_Mesh_i* mesh_i = SMESH::DownCast( mesh_var ); + // other mesh + SMESH_Mesh* smesh_mesh = (mesh_i==myMesh_i) ? (SMESH_Mesh*)0 : &mesh_i->GetImpl(); + + // group of new boundary elements + SMESH_Group* smesh_group = 0; + if ( strlen(groupName) ) + { + group_var = mesh_i->CreateGroup( SMESH::ElementType(int(elemType)-1),groupName); + if ( SMESH_GroupBase_i* group_i = SMESH::DownCast( group_var )) + smesh_group = group_i->GetSmeshGroup(); + } + + // do it + ::SMESH_MeshEditor aMeshEditor( myMesh ); + aMeshEditor.MakeBoundaryMesh( elements, + ::SMESH_MeshEditor::Bnd_Dimension(dim), + smesh_group, + smesh_mesh, + toCopyElements, + toCopyExistingBondary); + storeResult( aMeshEditor ); + + if ( smesh_mesh ) + smesh_mesh->GetMeshDS()->Modified(); + } + + const char* dimName[] = { "BND_2DFROM3D", "BND_1DFROM3D", "BND_1DFROM2D" }; + + // result of MakeBoundaryMesh() is a tuple (mesh, group) + if ( mesh_var->_is_nil() ) + pyDump << myMesh_i->_this() << ", "; + else + pyDump << mesh_var << ", "; + if ( group_var->_is_nil() ) + pyDump << "_NoneGroup = "; // assignment to None is forbiden + else + pyDump << group_var << " = "; + pyDump << this << ".MakeBoundaryMesh( " + << idSource << ", " + << "SMESH." << dimName[int(dim)] << ", " + << "'" << groupName << "', " + << "'" << meshName<< "', " + << toCopyElements << ", " + << toCopyExistingBondary << ")"; + + group = group_var._retn(); + return mesh_var._retn(); +} + +//================================================================================ +/*! + * \brief Creates missing boundary elements + * \param dimension - defines type of boundary elements to create + * \param groupName - a name of group to store all boundary elements in, + * "" means not to create the group + * \param meshName - a name of a new mesh, which is a copy of the initial + * mesh + created boundary elements; "" means not to create the new mesh + * \param toCopyAll - if true, the whole initial mesh will be copied into + * the new mesh else only boundary elements will be copied into the new mesh + * \param groups - optional groups of elements to make boundary around + * \param mesh - returns the mesh where elements were added to + * \param group - returns the created group, if any + * \retval long - number of added boundary elements + */ +//================================================================================ + +CORBA::Long SMESH_MeshEditor_i::MakeBoundaryElements(SMESH::Bnd_Dimension dim, + const char* groupName, + const char* meshName, + CORBA::Boolean toCopyAll, + const SMESH::ListOfIDSources& groups, + SMESH::SMESH_Mesh_out mesh, + SMESH::SMESH_Group_out group) + throw (SALOME::SALOME_Exception) +{ + Unexpect aCatch(SALOME_SalomeException); + + initData(); + + if ( dim > SMESH::BND_1DFROM2D ) + THROW_SALOME_CORBA_EXCEPTION("Invalid boundary dimension", SALOME::BAD_PARAM); + + // check that groups belongs to to this mesh and is not this mesh + const int nbGroups = groups.length(); + for ( int i = 0; i < nbGroups; ++i ) + { + SMESH::SMESH_Mesh_var m = groups[i]->GetMesh(); + if ( myMesh_i != SMESH::DownCast( m )) + THROW_SALOME_CORBA_EXCEPTION("group does not belong to this mesh", SALOME::BAD_PARAM); + if ( SMESH::DownCast( groups[i] )) + THROW_SALOME_CORBA_EXCEPTION("expect a group but recieve a mesh", SALOME::BAD_PARAM); + } + + TPythonDump pyDump; + + int nbAdded = 0; + SMESH::SMESH_Mesh_var mesh_var; + SMESH::SMESH_Group_var group_var; + + // get mesh to fill + mesh_var = SMESH::SMESH_Mesh::_duplicate( myMesh_i->_this() ); + const bool toCopyMesh = ( strlen( meshName ) > 0 ); + if ( toCopyMesh ) + { + if ( toCopyAll ) + mesh_var = SMESH_Gen_i::GetSMESHGen()->CopyMesh(mesh_var, + meshName, + /*toCopyGroups=*/false, + /*toKeepIDs=*/true); + else + mesh_var = makeMesh(meshName); + } + SMESH_Mesh_i* mesh_i = SMESH::DownCast( mesh_var ); + SMESH_Mesh* tgtMesh = &mesh_i->GetImpl(); + + // source mesh + SMESH_Mesh* srcMesh = ( toCopyMesh && !toCopyAll ) ? myMesh : tgtMesh; + SMESHDS_Mesh* srcMeshDS = srcMesh->GetMeshDS(); + + // group of boundary elements + SMESH_Group* smesh_group = 0; + SMDSAbs_ElementType elemType = (dim == SMESH::BND_2DFROM3D) ? SMDSAbs_Volume : SMDSAbs_Face; + if ( strlen(groupName) ) + { + SMESH::ElementType groupType = SMESH::ElementType( int(elemType)-1 ); + group_var = mesh_i->CreateGroup( groupType, groupName ); + if ( SMESH_GroupBase_i* group_i = SMESH::DownCast( group_var )) + smesh_group = group_i->GetSmeshGroup(); + } + + TIDSortedElemSet elements; + + if ( nbGroups > 0 ) + { + for ( int i = 0; i < nbGroups; ++i ) + { + elements.clear(); + if ( idSourceToSet( groups[i], srcMeshDS, elements, elemType,/*emptyIfIsMesh=*/false )) + { + SMESH::Bnd_Dimension bdim = + ( elemType == SMDSAbs_Volume ) ? SMESH::BND_2DFROM3D : SMESH::BND_1DFROM2D; + ::SMESH_MeshEditor aMeshEditor( srcMesh ); + nbAdded += aMeshEditor.MakeBoundaryMesh( elements, + ::SMESH_MeshEditor::Bnd_Dimension(bdim), + smesh_group, + tgtMesh, + /*toCopyElements=*/false, + /*toCopyExistingBondary=*/srcMesh != tgtMesh, + /*toAddExistingBondary=*/true, + /*aroundElements=*/true); + storeResult( aMeshEditor ); + } + } + } + else + { + ::SMESH_MeshEditor aMeshEditor( srcMesh ); + nbAdded += aMeshEditor.MakeBoundaryMesh( elements, + ::SMESH_MeshEditor::Bnd_Dimension(dim), + smesh_group, + tgtMesh, + /*toCopyElements=*/false, + /*toCopyExistingBondary=*/srcMesh != tgtMesh, + /*toAddExistingBondary=*/true); + storeResult( aMeshEditor ); + } + tgtMesh->GetMeshDS()->Modified(); + + const char* dimName[] = { "BND_2DFROM3D", "BND_1DFROM3D", "BND_1DFROM2D" }; + + // result of MakeBoundaryElements() is a tuple (nb, mesh, group) + pyDump << "nbAdded, "; + if ( mesh_var->_is_nil() ) + pyDump << myMesh_i->_this() << ", "; + else + pyDump << mesh_var << ", "; + if ( group_var->_is_nil() ) + pyDump << "_NoneGroup = "; // assignment to None is forbiden + else + pyDump << group_var << " = "; + pyDump << this << ".MakeBoundaryElements( " + << "SMESH." << dimName[int(dim)] << ", " + << "'" << groupName << "', " + << "'" << meshName<< "', " + << toCopyAll << ", " + << groups << ")"; + + mesh = mesh_var._retn(); + group = group_var._retn(); + return nbAdded; +}