-// 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"
#endif
#include <sstream>
+#include <limits>
#define cast2Node(elem) static_cast<const SMDS_MeshNode*>( elem )
SMDS_MeshElement* anElemCopy = 0;
if ( anElem->IsPoly() && anElem->GetType() == SMDSAbs_Volume )
{
- const SMDS_PolyhedralVolumeOfNodes* ph =
- dynamic_cast<const SMDS_PolyhedralVolumeOfNodes*> (anElem);
+ const SMDS_VtkVolume* ph =
+ dynamic_cast<const SMDS_VtkVolume*> (anElem);
if ( ph )
anElemCopy = _myMeshDS->AddPolyhedralVolumeWithID
- (anElemNodesID, ph->GetQuanities(),anElem->GetID());
+ (anElemNodesID, ph->GetQuantities(),anElem->GetID());
}
else {
anElemCopy = ::SMESH_MeshEditor(this).AddElement( anElemNodesID,
//!< 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
}
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; i<IDs.length(); i++) {
+ CORBA::Long ind = IDs[i];
+ const SMDS_MeshElement * elem =
+ (aType == SMDSAbs_Node ? aMesh->FindNode(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<SMESH_Mesh_i*>( 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<SMESH_Mesh_i*>( 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 );
+ }
+ }
+ }
+ }
+ }
}
//=============================================================================
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();
}
// 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;
}
//=============================================================================
// 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;
}
//=============================================================================
TPythonDump() << "nodeID = " << this << ".AddNode( "
<< x << ", " << y << ", " << z << " )";
+ myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true ); // issue 0020693
-
return N->GetID();
}
// Update Python script
TPythonDump() << "elem0d = " << this << ".Add0DElement( " << IDOfNode <<" )";
+ myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true ); // issue 0020693
if (elem)
<<n1<<", "<<n2<<", "<<n12<<" ])";
}
+ myMesh->GetMeshDS()->Modified();
if(elem)
return myMesh->SetIsModified( true ), elem->GetID();
// Update Python script
TPythonDump() << "faceID = " << this << ".AddFace( " << IDsOfNodes << " )";
+ myMesh->GetMeshDS()->Modified();
if(elem)
return myMesh->SetIsModified( true ), elem->GetID();
// Update Python script
TPythonDump() <<"faceID = "<<this<<".AddPolygonalFace( "<<IDsOfNodes<<" )";
+ myMesh->GetMeshDS()->Modified();
return elem ? ( myMesh->SetIsModified( true ), elem->GetID()) : 0;
}
// Update Python script
TPythonDump() << "volID = " << this << ".AddVolume( " << IDsOfNodes << " )";
+ myMesh->GetMeshDS()->Modified();
if(elem)
return myMesh->SetIsModified( true ), elem->GetID();
int NbNodes = IDsOfNodes.length();
std::vector<const SMDS_MeshNode*> 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<int> q (NbFaces);
// Update Python script
TPythonDump() << "volID = " << this << ".AddPolyhedralVolume( "
<< IDsOfNodes << ", " << Quantities << " )";
+ myMesh->GetMeshDS()->Modified();
return elem ? ( myMesh->SetIsModified( true ), elem->GetID()) : 0;
}
// Update Python script
TPythonDump() << "volID = " << this << ".AddPolyhedralVolumeByFaces( "
<< IdsOfFaces << " )";
+ myMesh->GetMeshDS()->Modified();
return elem ? ( myMesh->SetIsModified( true ), elem->GetID()) : 0;
}
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 );
}
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;
}
//=============================================================================
bool stat = aMeshEditor.DeleteDiag ( n1, n2 );
+ myMesh->GetMeshDS()->Modified();
if ( stat )
myMesh->SetIsModified( true ); // issue 0020693
-
+
storeResult(aMeshEditor);
return stat;
// Update Python script
TPythonDump() << "isDone = " << this << ".Reorient( " << IDsOfElements << " )";
+ myMesh->GetMeshDS()->Modified();
if ( IDsOfElements.length() )
myMesh->SetIsModified( true ); // issue 0020693
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; i<IDs.length(); i++) {
- CORBA::Long ind = IDs[i];
- const SMDS_MeshElement * elem =
- (aType == SMDSAbs_Node ? aMesh->FindNode(ind)
- : aMesh->FindElement(ind));
- if ( elem && ( aType == SMDSAbs_All || elem->GetType() == aType ))
- aMap.insert( elem );
- }
- }
-}
-
//=============================================================================
/*!
*
::SMESH_MeshEditor anEditor( myMesh );
bool stat = anEditor.TriToQuad( faces, aCrit, MaxAngle );
+ myMesh->GetMeshDS()->Modified();
if ( stat )
myMesh->SetIsModified( true ); // issue 0020693
::SMESH_MeshEditor anEditor( myMesh );
CORBA::Boolean stat = anEditor.QuadToTri( faces, aCrit );
+ myMesh->GetMeshDS()->Modified();
if ( stat )
myMesh->SetIsModified( true ); // issue 0020693
::SMESH_MeshEditor anEditor( myMesh );
CORBA::Boolean stat = anEditor.QuadToTri( faces, Diag13 );
+ myMesh->GetMeshDS()->Modified();
if ( stat )
myMesh->SetIsModified( true ); // issue 0020693
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)
{
{
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);
anEditor.Smooth(elements, fixedNodes, method,
MaxNbOfIterations, MaxAspectRatio, IsParametric );
+ myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true ); // issue 0020693
storeResult(anEditor);
//=======================================================================
//function : rotationSweep
-//purpose :
+//purpose :
//=======================================================================
SMESH::ListOfGroups*
anEditor.RotationSweep (*workElements, Ax1, theAngleInRadians,
theNbOfSteps, theTolerance, theMakeGroups, makeWalls);
storeResult(anEditor);
+ myMesh->GetMeshDS()->Modified();
// myMesh->SetIsModified( true ); -- it does not influence Compute()
//=======================================================================
//function : RotationSweepMakeGroups
-//purpose :
+//purpose :
//=======================================================================
SMESH::ListOfGroups*
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;
}
//=======================================================================
//function : RotationSweepObjectMakeGroups
-//purpose :
+//purpose :
//=======================================================================
SMESH::ListOfGroups*
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,
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*
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,
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*
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,
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;
}
//=======================================================================
//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;
CORBA::Long theNbOfSteps)
{
extrusionSweep (theIDsOfElements, theStepVector, theNbOfSteps, false );
- if ( !myPreviewMode ) {
+ if (!myPreviewMode) {
TPythonDump() << this << ".ExtrusionSweep( "
<< theIDsOfElements << ", " << theStepVector <<", " << theNbOfSteps << " )";
}
{
SMESH::long_array_var anElementsId = theObject->GetIDs();
extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false );
- if ( !myPreviewMode ) {
+ if (!myPreviewMode) {
TPythonDump() << this << ".ExtrusionSweepObject( "
<< theObject << ", " << theStepVector << ", " << theNbOfSteps << " )";
}
//=======================================================================
//function : ExtrusionSweepMakeGroups
-//purpose :
+//purpose :
//=======================================================================
SMESH::ListOfGroups*
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*
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*
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*
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;
}
//=======================================================================
//function : advancedExtrusion
-//purpose :
+//purpose :
//=======================================================================
SMESH::ListOfGroups*
//=======================================================================
//function : AdvancedExtrusionMakeGroups
-//purpose :
+//purpose :
//=======================================================================
-
SMESH::ListOfGroups*
SMESH_MeshEditor_i::AdvancedExtrusionMakeGroups(const SMESH::long_array& theIDsOfElements,
const SMESH::DirStruct& theStepVector,
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,
theSewTolerance,
true);
- if ( !myPreviewMode ) {
- TPythonDump() << "stepVector = " << theStepVector;
- TPythonDump aPythonDump;
- DumpGroupsList(aPythonDump,aGroups);
+ if (!myPreviewMode) {
+ DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".AdvancedExtrusionMakeGroups("
<< theIDsOfElements
<< ", stepVector, "
//=======================================================================
//function : extrusionAlongPath
-//purpose :
+//purpose :
//=======================================================================
-
SMESH::ListOfGroups*
SMESH_MeshEditor_i::extrusionAlongPath(const SMESH::long_array & theIDsOfElements,
SMESH::SMESH_Mesh_ptr thePathMesh,
SMESH::SMESH_MeshEditor::Extrusion_Error & theError,
const SMDSAbs_ElementType theElementType)
{
+ MESSAGE("extrusionAlongPath");
initData();
if ( thePathMesh->_is_nil() || thePathShape->_is_nil() ) {
anEditor.ExtrusionAlongTrack( elements, aSubMesh, nodeStart,
theHasAngles, angles, false,
theHasRefPoint, refPnt, theMakeGroups );
+ myMesh->GetMeshDS()->Modified();
storeResult(anEditor);
theError = convExtrError( error );
//=======================================================================
//function : extrusionAlongPathX
-//purpose :
+//purpose :
//=======================================================================
-
SMESH::ListOfGroups*
SMESH_MeshEditor_i::extrusionAlongPathX(const SMESH::long_array & IDsOfElements,
SMESH::SMESH_IDSource_ptr Path,
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)
{
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<SMESH_Mesh_i*>( Path );
- if(aMeshImp) {
+ if ( SMESH_Mesh_i* aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( 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<SMESH_subMesh_i*>( Path );
- if(aSubMeshImp) {
- // path as submesh
- SMESH::SMESH_Mesh_ptr aPathMesh = aSubMeshImp->GetFather();
- aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( 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<SMESH_Group_i*>( 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<SMESH_subMesh_i*>( Path ))
+ {
+ // path as submesh
+ SMESH::SMESH_Mesh_ptr aPathMesh = aSubMeshImp->GetFather();
+ aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( 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<SMESH_Group_i*>( Path ))
+ {
+ // path as group of 1D elements
+ // ????????
+ }
+ else
+ {
+ // invalid path
+ Error = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
+ return EmptyGr;
}
storeResult(anEditor);
//function : ExtrusionAlongPath
//purpose :
//=======================================================================
-
SMESH::SMESH_MeshEditor::Extrusion_Error
SMESH_MeshEditor_i::ExtrusionAlongPath(const SMESH::long_array & theIDsOfElements,
SMESH::SMESH_Mesh_ptr thePathMesh,
CORBA::Boolean theHasRefPoint,
const SMESH::PointStruct & theRefPoint)
{
+ MESSAGE("ExtrusionAlongPath");
if ( !myPreviewMode ) {
TPythonDump() << "error = " << this << ".ExtrusionAlongPath( "
<< theIDsOfElements << ", "
//function : ExtrusionAlongPathObject
//purpose :
//=======================================================================
-
SMESH::SMESH_MeshEditor::Extrusion_Error
SMESH_MeshEditor_i::ExtrusionAlongPathObject(SMESH::SMESH_IDSource_ptr theObject,
SMESH::SMESH_Mesh_ptr thePathMesh,
//function : ExtrusionAlongPathObject1D
//purpose :
//=======================================================================
-
SMESH::SMESH_MeshEditor::Extrusion_Error
SMESH_MeshEditor_i::ExtrusionAlongPathObject1D(SMESH::SMESH_IDSource_ptr theObject,
SMESH::SMESH_Mesh_ptr thePathMesh,
//function : ExtrusionAlongPathObject2D
//purpose :
//=======================================================================
-
SMESH::SMESH_MeshEditor::Extrusion_Error
SMESH_MeshEditor_i::ExtrusionAlongPathObject2D(SMESH::SMESH_IDSource_ptr theObject,
SMESH::SMESH_Mesh_ptr thePathMesh,
//=======================================================================
//function : ExtrusionAlongPathMakeGroups
-//purpose :
+//purpose :
//=======================================================================
-
SMESH::ListOfGroups*
SMESH_MeshEditor_i::ExtrusionAlongPathMakeGroups(const SMESH::long_array& theIDsOfElements,
SMESH::SMESH_Mesh_ptr thePathMesh,
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,
theRefPoint,
true,
Error);
- if ( !myPreviewMode ) {
+ if (!myPreviewMode) {
bool isDumpGroups = aGroups && aGroups->length() > 0;
- TPythonDump aPythonDump;
- if(isDumpGroups) {
- aPythonDump << "("<<aGroups;
- }
- if(isDumpGroups)
- aPythonDump << ", error)";
+ if (isDumpGroups)
+ aPythonDump << "(" << aGroups << ", error)";
else
aPythonDump <<"error";
//=======================================================================
//function : ExtrusionAlongPathObjectMakeGroups
-//purpose :
+//purpose :
//=======================================================================
-
SMESH::ListOfGroups* SMESH_MeshEditor_i::
ExtrusionAlongPathObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
SMESH::SMESH_Mesh_ptr thePathMesh,
const SMESH::PointStruct& theRefPoint,
SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
SMESH::long_array_var anElementsId = theObject->GetIDs();
SMESH::ListOfGroups * aGroups = extrusionAlongPath( anElementsId,
thePathMesh,
true,
Error);
- if ( !myPreviewMode ) {
+ if (!myPreviewMode) {
bool isDumpGroups = aGroups && aGroups->length() > 0;
- TPythonDump aPythonDump;
- if(isDumpGroups) {
- aPythonDump << "("<<aGroups;
- }
- if(isDumpGroups)
- aPythonDump << ", error)";
+ if (isDumpGroups)
+ aPythonDump << "(" << aGroups << ", error)";
else
aPythonDump <<"error";
//=======================================================================
//function : ExtrusionAlongPathObject1DMakeGroups
-//purpose :
+//purpose :
//=======================================================================
-
SMESH::ListOfGroups* SMESH_MeshEditor_i::
ExtrusionAlongPathObject1DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
SMESH::SMESH_Mesh_ptr thePathMesh,
const SMESH::PointStruct& theRefPoint,
SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
SMESH::long_array_var anElementsId = theObject->GetIDs();
SMESH::ListOfGroups * aGroups = extrusionAlongPath( anElementsId,
thePathMesh,
Error,
SMDSAbs_Edge);
- if ( !myPreviewMode ) {
+ if (!myPreviewMode) {
bool isDumpGroups = aGroups && aGroups->length() > 0;
- TPythonDump aPythonDump;
- if(isDumpGroups) {
- aPythonDump << "("<<aGroups;
- }
- if(isDumpGroups)
- aPythonDump << ", error)";
+ if (isDumpGroups)
+ aPythonDump << "(" << aGroups << ", error)";
else
- aPythonDump <<"error";
+ aPythonDump << "error";
aPythonDump << " = " << this << ".ExtrusionAlongPathObject1DMakeGroups( "
<< theObject << ", "
//=======================================================================
//function : ExtrusionAlongPathObject2DMakeGroups
-//purpose :
+//purpose :
//=======================================================================
-
SMESH::ListOfGroups* SMESH_MeshEditor_i::
ExtrusionAlongPathObject2DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
SMESH::SMESH_Mesh_ptr thePathMesh,
const SMESH::PointStruct& theRefPoint,
SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
SMESH::long_array_var anElementsId = theObject->GetIDs();
SMESH::ListOfGroups * aGroups = extrusionAlongPath( anElementsId,
thePathMesh,
Error,
SMDSAbs_Face);
- if ( !myPreviewMode ) {
+ if (!myPreviewMode) {
bool isDumpGroups = aGroups && aGroups->length() > 0;
- TPythonDump aPythonDump;
- if(isDumpGroups) {
- aPythonDump << "("<<aGroups;
- }
- if(isDumpGroups)
- aPythonDump << ", error)";
+ if (isDumpGroups)
+ aPythonDump << "(" << aGroups << ", error)";
else
- aPythonDump <<"error";
+ aPythonDump << "error";
aPythonDump << " = " << this << ".ExtrusionAlongPathObject2DMakeGroups( "
<< theObject << ", "
//=======================================================================
//function : ExtrusionAlongPathObjX
-//purpose :
+//purpose :
//=======================================================================
SMESH::ListOfGroups* SMESH_MeshEditor_i::
ExtrusionAlongPathObjX(SMESH::SMESH_IDSource_ptr Object,
SMESH::ElementType ElemType,
SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
SMESH::long_array_var anElementsId = Object->GetIDs();
SMESH::ListOfGroups * aGroups = extrusionAlongPathX(anElementsId,
Path,
(SMDSAbs_ElementType)ElemType,
Error);
- if ( !myPreviewMode ) {
+ if (!myPreviewMode) {
bool isDumpGroups = aGroups && aGroups->length() > 0;
- TPythonDump aPythonDump;
- if(isDumpGroups) {
- aPythonDump << "("<<aGroups;
- }
- if(isDumpGroups)
- aPythonDump << ", error)";
+ if (isDumpGroups)
+ aPythonDump << "(" << *aGroups << ", error)";
else
- aPythonDump <<"error";
+ aPythonDump << "error";
aPythonDump << " = " << this << ".ExtrusionAlongPathObjX( "
<< Object << ", "
//=======================================================================
//function : ExtrusionAlongPathX
-//purpose :
+//purpose :
//=======================================================================
SMESH::ListOfGroups* SMESH_MeshEditor_i::
ExtrusionAlongPathX(const SMESH::long_array& IDsOfElements,
SMESH::ElementType ElemType,
SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
SMESH::ListOfGroups * aGroups = extrusionAlongPathX(IDsOfElements,
Path,
NodeStart,
(SMDSAbs_ElementType)ElemType,
Error);
- if ( !myPreviewMode ) {
+ if (!myPreviewMode) {
bool isDumpGroups = aGroups && aGroups->length() > 0;
- TPythonDump aPythonDump;
- if(isDumpGroups) {
- aPythonDump << "("<<aGroups;
- }
- if(isDumpGroups)
- aPythonDump << ", error)";
+ if (isDumpGroups)
+ aPythonDump << "(" << *aGroups << ", error)";
else
aPythonDump <<"error";
<< ( HasRefPoint ? RefPoint.x : 0 ) << ", "
<< ( HasRefPoint ? RefPoint.y : 0 ) << ", "
<< ( HasRefPoint ? RefPoint.z : 0 ) << " ), "
+ << MakeGroups << ", "
<< ElemType << " )";
}
return aGroups;
/*!
* \brief Compute rotation angles for ExtrusionAlongPath as linear variation
* of given angles along path steps
- * \param PathMesh mesh containing a 1D sub-mesh on the edge, along
+ * \param PathMesh mesh containing a 1D sub-mesh on the edge, along
* which proceeds the extrusion
- * \param PathShape is shape(edge); as the mesh can be complex, the edge
+ * \param PathShape is shape(edge); as the mesh can be complex, the edge
* is used to define the sub-mesh for the path
*/
//================================================================================
//=======================================================================
//function : mirror
-//purpose :
+//purpose :
//=======================================================================
SMESH::ListOfGroups*
-SMESH_MeshEditor_i::mirror(const SMESH::long_array & theIDsOfElements,
+SMESH_MeshEditor_i::mirror(TIDSortedElemSet & theElements,
const SMESH::AxisStruct & theAxis,
SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
CORBA::Boolean theCopy,
- const bool theMakeGroups,
+ bool theMakeGroups,
::SMESH_Mesh* theTargetMesh)
{
initData();
- TIDSortedElemSet elements;
- arrayToSet(theIDsOfElements, GetMeshDS(), elements);
-
gp_Pnt P ( theAxis.x, theAxis.y, theAxis.z );
gp_Vec V ( theAxis.vx, theAxis.vy, theAxis.vz );
+ if ( theTargetMesh )
+ theCopy = false;
+
gp_Trsf aTrsf;
switch ( theMirrorType ) {
case SMESH::SMESH_MeshEditor::POINT:
aTrsf.SetMirror( gp_Ax2( P, V ));
}
- ::SMESH_MeshEditor anEditor( myMesh );
+ TIDSortedElemSet copyElements;
+ TPreviewMesh tmpMesh;
+ TIDSortedElemSet* workElements = & theElements;
+ 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->SetIsModified( true );
-
+ myMesh->GetMeshDS()->Modified();
+ }
return theMakeGroups ? getGroups(groupIds.get()) : 0;
}
<< 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);
+ }
}
<< 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*
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 << ", "
//=======================================================================
//function : MirrorObjectMakeGroups
-//purpose :
+//purpose :
//=======================================================================
SMESH::ListOfGroups*
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 << ", "
//=======================================================================
//function : MirrorMakeMesh
-//purpose :
+//purpose :
//=======================================================================
SMESH::SMESH_Mesh_ptr
mesh = makeMesh( theMeshName );
mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( 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 << ", "
}
//dump "GetGroups"
- if(!myPreviewMode && mesh_i)
+ if (!myPreviewMode && mesh_i)
mesh_i->GetGroups();
return mesh._retn();
//=======================================================================
//function : MirrorObjectMakeMesh
-//purpose :
+//purpose :
//=======================================================================
SMESH::SMESH_Mesh_ptr
mesh = makeMesh( theMeshName );
mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( 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 << ", "
<< theCopyGroups << ", '"
<< theMeshName << "' )";
}
- }
+ }
//dump "GetGroups"
- if(!myPreviewMode && mesh_i)
+ if (!myPreviewMode && mesh_i)
mesh_i->GetGroups();
return mesh._retn();
//=======================================================================
//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;
}
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);
+ }
}
//=======================================================================
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 << " )";
//=======================================================================
//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 << " )";
//=======================================================================
//function : TranslateMakeMesh
-//purpose :
+//purpose :
//=======================================================================
SMESH::SMESH_Mesh_ptr
mesh = makeMesh( theMeshName );
mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( 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();
}
}
//dump "GetGroups"
- if(!myPreviewMode && mesh_i)
+ if (!myPreviewMode && mesh_i)
mesh_i->GetGroups();
return mesh._retn();
//=======================================================================
//function : TranslateObjectMakeMesh
-//purpose :
+//purpose :
//=======================================================================
SMESH::SMESH_Mesh_ptr
mesh = makeMesh( theMeshName );
mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( 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 ) {
}
}
- //dump "GetGroups"
- if(!myPreviewMode && mesh_i)
+ // dump "GetGroups"
+ if (!myPreviewMode && mesh_i)
mesh_i->GetGroups();
return mesh._retn();
//=======================================================================
//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 );
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;
}
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);
+ }
}
//=======================================================================
<< 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*
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 << ", "
//=======================================================================
//function : RotateObjectMakeGroups
-//purpose :
+//purpose :
//=======================================================================
SMESH::ListOfGroups*
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 << ", "
//=======================================================================
//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,
mesh = makeMesh( theMeshName );
mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( 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();
}
}
}
- //dump "GetGroups"
- if(!myPreviewMode && mesh_i)
+ // dump "GetGroups"
+ if (!myPreviewMode && mesh_i && theIDsOfElements.length() > 0 )
mesh_i->GetGroups();
return mesh._retn();
//=======================================================================
//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,
mesh = makeMesh( theMeshName );
mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( 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();
}
}
}
- //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<double> 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<double>::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 :
<< 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*
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(" <<thePoint.x << ","
//=======================================================================
//function : ScaleMakeMesh
-//purpose :
+//purpose :
//=======================================================================
SMESH::SMESH_Mesh_ptr
mesh = makeMesh( theMeshName );
mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( 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 << ", "
<< theScaleFact << ", "
<< theCopyGroups << ", '"
<< theMeshName << "' )";
- }
}
- //dump "GetGroups"
- if(!myPreviewMode && mesh_i)
+ // dump "GetGroups"
+ if (!myPreviewMode && mesh_i)
mesh_i->GetGroups();
return mesh._retn();
::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
::SMESH_MeshEditor anEditor( myMesh );
- set<const SMDS_MeshNode*> nodes; // no input nodes
+ TIDSortedNodeSet nodes; // no input nodes
anEditor.FindCoincidentNodes( nodes, Tolerance, aListOfListOfNodes );
GroupsOfNodes = new SMESH::array_of_long_array;
SMESH::array_of_long_array_out GroupsOfNodes)
{
initData();
- SMESH::long_array_var aElementsId = theObject->GetIDs();
-
- SMESHDS_Mesh* aMesh = GetMeshDS();
- set<const SMDS_MeshNode*> 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<const SMDS_MeshNode*>(nIt->next()));
- }
- }
- }
+ TIDSortedNodeSet nodes;
+ idSourceToNodeSet( theObject, GetMeshDS(), nodes );
::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
::SMESH_MeshEditor anEditor( myMesh );
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 ];
<< 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 :
anEditor.MergeNodes( aListOfListOfNodes );
aTPythonDump << "])";
-
+ myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
}
::SMESH_MeshEditor anEditor( myMesh );
anEditor.MergeElements(aListOfListOfElementsID);
-
+ myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
aTPythonDump << "] )";
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;
}
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
<< ".MoveClosestNodeToPoint( "<< x << ", " << y << ", " << z
<< ", " << nodeID << " )";
+ myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
}
storeResult(anEditor);
+ myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
return error;
storeResult(anEditor);
+ myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
return error;
storeResult(anEditor);
+ myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
return error;
storeResult(anEditor);
+ myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
return error;
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 );
void SMESH_MeshEditor_i::storeResult(::SMESH_MeshEditor& anEditor)
{
- if ( myPreviewMode ) { // --- MeshPreviewStruct filling ---
+ if ( myPreviewMode ) { // --- MeshPreviewStruct filling ---
list<int> aNodesConnectivity;
typedef map<int, int> TNodesMap;
SMDS_ElemIteratorPtr itElemNodes = aMeshElem->nodesIterator();
while ( itElemNodes->more() ) {
- const SMDS_MeshNode* aMeshNode =
+ const SMDS_MeshNode* aMeshNode =
static_cast<const SMDS_MeshNode*>( itElemNodes->next() );
int aNodeID = aMeshNode->GetID();
TNodesMap::iterator anIter = nodesMap.find(aNodeID);
}
{
- // add new nodes into myLastCreatedNodes
+ // append new nodes into myLastCreatedNodes
const SMESH_SequenceOfElemPtr& aSeq = anEditor.GetLastCreatedNodes();
- myLastCreatedNodes->length(aSeq.Length());
- for(int i=0; i<aSeq.Length(); i++)
- myLastCreatedNodes[i] = aSeq.Value(i+1)->GetID();
+ int j = myLastCreatedNodes->length();
+ int newLen = j + aSeq.Length();
+ myLastCreatedNodes->length( newLen );
+ for(int i=0; j<newLen; i++,j++)
+ myLastCreatedNodes[j] = aSeq.Value(i+1)->GetID();
}
{
- // add new elements into myLastCreatedElems
+ // append new elements into myLastCreatedElems
const SMESH_SequenceOfElemPtr& aSeq = anEditor.GetLastCreatedElems();
- myLastCreatedElems->length(aSeq.Length());
- for(int i=0; i<aSeq.Length(); i++)
- myLastCreatedElems[i] = aSeq.Value(i+1)->GetID();
+ int j = myLastCreatedElems->length();
+ int newLen = j + aSeq.Length();
+ myLastCreatedElems->length( newLen );
+ for(int i=0; j<newLen; i++,j++)
+ myLastCreatedElems[j] = aSeq.Value(i+1)->GetID();
}
}
::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()
::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( "<<theForce3d<<", "<<theObject<<" )";
+}
+
+//================================================================================
+/*!
+ * \brief Makes a part of the mesh linear
+ */
+//================================================================================
+
+void SMESH_MeshEditor_i::ConvertFromQuadraticObject(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() )
+ {
+ ConvertFromQuadratic();
+ }
+ 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.ConvertFromQuadratic(elems);
+ }
+ }
+ myMesh->GetMeshDS()->Modified();
+ myMesh->SetIsModified( true );
+
+ pyDump << this << ".ConvertFromQuadraticObject( "<<theObject<<" )";
+}
+
+//=======================================================================
+//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)
{
bool isDumpGroupList = theGroupList && theGroupList->length() > 0;
if(isDumpGroupList) {
}
}
+//================================================================================
+/*!
+ \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<string> 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();
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;
}
*/
//================================================================================
-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;
}
*/
//================================================================================
-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;
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
*/
//================================================================================
-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();
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 )
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;
}
*/
//================================================================================
-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();
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;
}
*/
//================================================================================
-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)
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
*/
//================================================================================
-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 )
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;
}
\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()
*/
//================================================================================
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();
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
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;
}
::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<TIDSortedElemSet> 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<TIDSortedElemSet> 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<SMESH_Mesh_i*>( 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<SMESH_GroupBase_i*>( 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<SMESH_Mesh_i*>( m ))
+ THROW_SALOME_CORBA_EXCEPTION("group does not belong to this mesh", SALOME::BAD_PARAM);
+ if ( SMESH::DownCast<SMESH_Mesh_i*>( 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<SMESH_Mesh_i*>( 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<SMESH_GroupBase_i*>( 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;
+}
