ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-02-27 02:35:36 +05:00
Code Issues Packages Projects Releases Wiki Activity

IMP20439 Create hole by element and nodes duplication

Browse Source
This commit is contained in:
ptv 2009-08-11 12:01:49 +00:00
parent eee601b7b1
commit 787fff0067
6 changed files with 546 additions and 193 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
idl/SMESH_MeshEditor.idl
View File

@ -687,46 +687,90 @@ module SMESH
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
* \param theNodes - identifiers of nodes to be doubled * \param theElems - the list of elements (edges or faces) to be replicated
* \param theModifiedElems - identifiers of elements to be updated by the new (doubled) * The nodes for duplication could be found from these elements
* nodes. If list of element identifiers is empty then nodes are doubled but * \param theNodesNot - list of nodes to NOT replicate
* they not assigned to elements * \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 * \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNode(), DoubleNodeGroup(), DoubleNodeGroups() * \sa DoubleNodeGroup(), DoubleNodeGroups()
*/ */
boolean DoubleNodes( in long_array theNodes, in long_array theModifiedElems ); boolean DoubleNodes( in long_array theElems,
in long_array theNodesNot,
in long_array theAffectedElems );
/*!
* \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 theShape - shape to detect affected elements (element which geometric center
* located on or inside shape).
* The replicated nodes should be associated to affected elements.
* \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodeGroupInRegion(), DoubleNodeGroupsInRegion()
*/
boolean DoubleNodesInRegion( in long_array theElems,
in long_array theNodesNot,
in GEOM::GEOM_Object theShape );
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
* This method provided for convenience works as DoubleNodes() described above. * This method provided for convenience works as DoubleNodes() described above.
* \param theNodeId - identifier of node to be doubled. * \param theElems - group of of elements (edges or faces) to be replicated
* \param theModifiedElems - identifiers of elements to be updated. * \param theNodesNot - group of nodes not to replicated
* \param theAffectedElems - group of elements to which the replicated nodes
* should be associated to.
* \return TRUE if operation has been completed successfully, FALSE otherwise * \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodes(), DoubleNodeGroup(), DoubleNodeGroups() * \sa DoubleNodes(), DoubleNodeGroups()
*/ */
boolean DoubleNode( in long theNodeId, in long_array theModifiedElems ); boolean DoubleNodeGroup( in SMESH_GroupBase theElems,
in SMESH_GroupBase theNodesNot,
in SMESH_GroupBase theAffectedElems );
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
* This method provided for convenience works as DoubleNodes() described above. * This method provided for convenience works as DoubleNodes() described above.
* \param theNodes - group of nodes to be doubled. * \param theElems - group of elements (edges or faces) to be replicated
* \param theModifiedElems - group of elements to be updated. * \param theNodesNot - group of nodes not to replicated
* \param theShape - shape to detect affected elements (element which geometric center
* located on or inside shape).
* The replicated nodes should be associated to affected elements.
* \return TRUE if operation has been completed successfully, FALSE otherwise * \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNode(), DoubleNodes(), DoubleNodeGroups() * \sa DoubleNodesInRegion(), DoubleNodeGroupsInRegion()
*/ */
boolean DoubleNodeGroup( in SMESH_GroupBase theNodes, boolean DoubleNodeGroupInRegion( in SMESH_GroupBase theElems,
in SMESH_GroupBase theModifiedElems ); in SMESH_GroupBase theNodesNot,
in GEOM::GEOM_Object theShape );
/*! /*!
\brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
This method provided for convenience works as DoubleNodes() described above. * This method provided for convenience works as DoubleNodes() described above.
\param theNodes - list of groups of nodes to be doubled * \param theElems - list of groups of elements (edges or faces) to be replicated
\param theModifiedElems - list of groups of elements to be updated. * \param theNodesNot - list of groups of nodes not to replicated
\return TRUE if operation has been completed successfully, FALSE otherwise * \param theAffectedElems - group of elements to which the replicated nodes
\sa DoubleNode(), DoubleNodeGroup(), DoubleNodes() * should be associated to.
* \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodeGroup(), DoubleNodes()
*/ */
boolean DoubleNodeGroups( in ListOfGroups theNodes, boolean DoubleNodeGroups( in ListOfGroups theElems,
in ListOfGroups theModifiedElems ); in ListOfGroups theNodesNot,
in ListOfGroups theAffectedElems );
/*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements
* This method provided for convenience works as DoubleNodes() described above.
* \param theElems - list of groups of elements (edges or faces) to be replicated
* \param theNodesNot - list of groups of nodes not to replicated
* \param theShape - shape to detect affected elements (element which geometric center
* located on or inside shape).
* The replicated nodes should be associated to affected elements.
* \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodeGroupInRegion(), DoubleNodesInRegion()
*/
boolean DoubleNodeGroupsInRegion( in ListOfGroups theElems,
in ListOfGroups theNodesNot,
in GEOM::GEOM_Object theShape );
}; };
}; };

196
src/SMESH/SMESH_MeshEditor.cxx
View File

@ -47,6 +47,7 @@
#include "utilities.h" #include "utilities.h"
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>
#include <BRepClass3d_SolidClassifier.hxx>
#include <ElCLib.hxx> #include <ElCLib.hxx>
#include <Extrema_GenExtPS.hxx> #include <Extrema_GenExtPS.hxx>
#include <Extrema_POnSurf.hxx> #include <Extrema_POnSurf.hxx>
@ -54,7 +55,9 @@
#include <GeomAdaptor_Surface.hxx> #include <GeomAdaptor_Surface.hxx>
#include <Geom_Curve.hxx> #include <Geom_Curve.hxx>
#include <Geom_Surface.hxx> #include <Geom_Surface.hxx>
#include <Precision.hxx>
#include <TColStd_ListOfInteger.hxx> #include <TColStd_ListOfInteger.hxx>
#include <TopAbs_State.hxx>
#include <TopExp.hxx> #include <TopExp.hxx>
#include <TopExp_Explorer.hxx> #include <TopExp_Explorer.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx> #include <TopTools_ListIteratorOfListOfShape.hxx>
@ -8188,89 +8191,166 @@ SMESH_MeshEditor::FindMatchingNodes(set<const SMDS_MeshElement*>& theSide1,
/*! /*!
\brief Creates a hole in a mesh by doubling the nodes of some particular elements \brief Creates a hole in a mesh by doubling the nodes of some particular elements
\param theNodes - identifiers of nodes to be doubled \param theElems - the list of elements (edges or faces) to be replicated
\param theModifiedElems - identifiers of elements to be updated by the new (doubled) The nodes for duplication could be found from these elements
nodes. If list of element identifiers is empty then nodes are doubled but \param theNodesNot - list of nodes to NOT replicate
they not assigned to elements \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 \return TRUE if operation has been completed successfully, FALSE otherwise
*/ */
bool SMESH_MeshEditor::DoubleNodes( const std::list< int >& theListOfNodes, bool SMESH_MeshEditor::DoubleNodes( const TIDSortedElemSet& theElems,
const std::list< int >& theListOfModifiedElems ) const TIDSortedElemSet& theNodesNot,
const TIDSortedElemSet& theAffectedElems )
{ {
myLastCreatedElems.Clear(); myLastCreatedElems.Clear();
myLastCreatedNodes.Clear(); myLastCreatedNodes.Clear();
if ( theListOfNodes.size() == 0 ) if ( theElems.size() == 0 )
return false; return false;
SMESHDS_Mesh* aMeshDS = GetMeshDS(); SMESHDS_Mesh* aMeshDS = GetMeshDS();
if ( !aMeshDS ) if ( !aMeshDS )
return false; return false;
// iterate through nodes and duplicate them bool res = false;
std::map< const SMDS_MeshNode*, const SMDS_MeshNode* > anOldNodeToNewNode; std::map< const SMDS_MeshNode*, const SMDS_MeshNode* > anOldNodeToNewNode;
// duplicate elements and nodes
res = doubleNodes( aMeshDS, theElems, theNodesNot, anOldNodeToNewNode, true );
// replce nodes by duplications
res = doubleNodes( aMeshDS, theAffectedElems, theNodesNot, anOldNodeToNewNode, false );
return res;
}
std::list< int >::const_iterator aNodeIter; /*!
for ( aNodeIter = theListOfNodes.begin(); aNodeIter != theListOfNodes.end(); ++aNodeIter ) \brief Creates a hole in a mesh by doubling the nodes of some particular elements
\param theMeshDS - mesh instance
\param theElems - the elements replicated or modified (nodes should be changed)
\param theNodesNot - nodes to NOT replicate
\param theNodeNodeMap - relation of old node to new created node
\param theIsDoubleElem - flag os to replicate element or modify
\return TRUE if operation has been completed successfully, FALSE otherwise
*/
bool SMESH_MeshEditor::doubleNodes( SMESHDS_Mesh* theMeshDS,
const TIDSortedElemSet& theElems,
const TIDSortedElemSet& theNodesNot,
std::map< const SMDS_MeshNode*,
const SMDS_MeshNode* >& theNodeNodeMap,
const bool theIsDoubleElem )
{
// iterate on through element and duplicate them (by nodes duplication)
bool res = false;
TIDSortedElemSet::iterator elemItr = theElems.begin();
for ( ; elemItr != theElems.end(); ++elemItr )
{ {
int aCurr = *aNodeIter; const SMDS_MeshElement* anElem = *elemItr;
SMDS_MeshNode* aNode = (SMDS_MeshNode*)aMeshDS->FindNode( aCurr ); if (!anElem)
if ( !aNode )
continue; continue;
// duplicate node bool isDuplicate = false;
// duplicate nodes to duplicate element
const SMDS_MeshNode* aNewNode = aMeshDS->AddNode( aNode->X(), aNode->Y(), aNode->Z() ); std::vector<const SMDS_MeshNode*> newNodes( anElem->NbNodes() );
if ( aNewNode )
{
anOldNodeToNewNode[ aNode ] = aNewNode;
myLastCreatedNodes.Append( aNewNode );
}
}
// Create map of new nodes for modified elements
std::map< SMDS_MeshElement*, vector<const SMDS_MeshNode*> > anElemToNodes;
std::list< int >::const_iterator anElemIter;
for ( anElemIter = theListOfModifiedElems.begin();
anElemIter != theListOfModifiedElems.end(); ++anElemIter )
{
int aCurr = *anElemIter;
SMDS_MeshElement* anElem = (SMDS_MeshElement*)aMeshDS->FindElement( aCurr );
if ( !anElem )
continue;
vector<const SMDS_MeshNode*> aNodeArr( anElem->NbNodes() );
SMDS_ElemIteratorPtr anIter = anElem->nodesIterator(); SMDS_ElemIteratorPtr anIter = anElem->nodesIterator();
int ind = 0; int ind = 0;
while ( anIter->more() ) while ( anIter->more() )
{ {
SMDS_MeshNode* aCurrNode = (SMDS_MeshNode*)anIter->next(); SMDS_MeshNode* aCurrNode = (SMDS_MeshNode*)anIter->next();
if ( aCurr && anOldNodeToNewNode.find( aCurrNode ) != anOldNodeToNewNode.end() ) SMDS_MeshNode* aNewNode = aCurrNode;
if ( theNodeNodeMap.find( aCurrNode ) != theNodeNodeMap.end() )
aNewNode = (SMDS_MeshNode*)theNodeNodeMap[ aCurrNode ];
else if ( theIsDoubleElem && theNodesNot.find( aCurrNode ) == theNodesNot.end() )
{ {
const SMDS_MeshNode* aNewNode = anOldNodeToNewNode[ aCurrNode ]; // duplicate node
aNodeArr[ ind++ ] = aNewNode; aNewNode = theMeshDS->AddNode( aCurrNode->X(), aCurrNode->Y(), aCurrNode->Z() );
theNodeNodeMap[ aCurrNode ] = aNewNode;
myLastCreatedNodes.Append( aNewNode );
} }
isDuplicate |= (aCurrNode == aNewNode);
newNodes[ ind++ ] = aNewNode;
}
if ( !isDuplicate )
continue;
if ( theIsDoubleElem )
myLastCreatedElems.Append( AddElement(newNodes, anElem->GetType(), anElem->IsPoly()) );
else else
aNodeArr[ ind++ ] = aCurrNode; theMeshDS->ChangeElementNodes( anElem, &newNodes[ 0 ], anElem->NbNodes() );
}
anElemToNodes[ anElem ] = aNodeArr;
}
// Change nodes of elements res = true;
std::map< SMDS_MeshElement*, vector<const SMDS_MeshNode*> >::iterator
anElemToNodesIter = anElemToNodes.begin();
for ( ; anElemToNodesIter != anElemToNodes.end(); ++anElemToNodesIter )
{
const SMDS_MeshElement* anElem = anElemToNodesIter->first;
vector<const SMDS_MeshNode*> aNodeArr = anElemToNodesIter->second;
if ( anElem )
aMeshDS->ChangeElementNodes( anElem, &aNodeArr[ 0 ], anElem->NbNodes() );
} }
return res;
return true; }
/*!
\brief Check if element located inside shape
\return TRUE if IN or ON shape, FALSE otherwise
*/
static bool isInside(const SMDS_MeshElement* theElem,
BRepClass3d_SolidClassifier& theBsc3d,
const double theTol)
{
gp_XYZ centerXYZ (0, 0, 0);
SMDS_ElemIteratorPtr aNodeItr = theElem->nodesIterator();
while (aNodeItr->more())
{
SMDS_MeshNode* aNode = (SMDS_MeshNode*)aNodeItr->next();
centerXYZ += gp_XYZ(aNode->X(), aNode->Y(), aNode->Z());
}
gp_Pnt aPnt(centerXYZ);
theBsc3d.Perform(aPnt, theTol);
TopAbs_State aState = theBsc3d.State();
return (aState == TopAbs_IN || aState == TopAbs_ON );
}
/*!
\brief Creates a hole in a mesh by doubling the nodes of some particular elements
\param theElems - group of of elements (edges or faces) to be replicated
\param theNodesNot - group of nodes not to replicated
\param theShape - shape to detect affected elements (element which geometric center
located on or inside shape).
The replicated nodes should be associated to affected elements.
\return TRUE if operation has been completed successfully, FALSE otherwise
*/
bool SMESH_MeshEditor::DoubleNodesInRegion( const TIDSortedElemSet& theElems,
const TIDSortedElemSet& theNodesNot,
const TopoDS_Shape& theShape )
{
SMESHDS_Mesh* aMesh = GetMeshDS();
if (!aMesh)
return false;
if ( theShape.IsNull() )
return false;
const double aTol = Precision::Confusion();
BRepClass3d_SolidClassifier bsc3d(theShape);
bsc3d.PerformInfinitePoint(aTol);
// iterates on indicated elements and get elements by back references from their nodes
TIDSortedElemSet anAffected;
TIDSortedElemSet::iterator elemItr = theElems.begin();
for ( ; elemItr != theElems.end(); ++elemItr )
{
SMDS_MeshElement* anElem = (SMDS_MeshElement*)*elemItr;
if (!anElem)
continue;
SMDS_ElemIteratorPtr nodeItr = anElem->nodesIterator();
while ( nodeItr->more() )
{
const SMDS_MeshNode* aNode = static_cast<const SMDS_MeshNode*>(nodeItr->next());
if ( !aNode || theNodesNot.find(aNode) != theNodesNot.end() )
continue;
SMDS_ElemIteratorPtr backElemItr = aNode->GetInverseElementIterator();
while ( backElemItr->more() )
{
SMDS_MeshElement* curElem = (SMDS_MeshElement*)backElemItr->next();
if ( curElem && theElems.find(curElem) == theElems.end() &&
isInside( curElem, bsc3d, aTol ) )
anAffected.insert( curElem );
}
}
}
return DoubleNodes( theElems, theNodesNot, anAffected );
} }

17
src/SMESH/SMESH_MeshEditor.hxx
View File

@ -41,6 +41,7 @@
#include <list> #include <list>
#include <map> #include <map>
#include <set>
class SMDS_MeshFace; class SMDS_MeshFace;
class SMDS_MeshNode; class SMDS_MeshNode;
@ -576,8 +577,13 @@ public:
const SMESH_SequenceOfElemPtr& GetLastCreatedElems() const { return myLastCreatedElems; } const SMESH_SequenceOfElemPtr& GetLastCreatedElems() const { return myLastCreatedElems; }
bool DoubleNodes( const std::list< int >& theListOfNodes, bool DoubleNodes( const TIDSortedElemSet& theElems,
const std::list< int >& theListOfModifiedElems ); const TIDSortedElemSet& theNodesNot,
const TIDSortedElemSet& theAffectedElems );
bool DoubleNodesInRegion( const TIDSortedElemSet& theElems,
const TIDSortedElemSet& theNodesNot,
const TopoDS_Shape& theShape );
private: private:
@ -661,6 +667,13 @@ private:
void LinearAngleVariation(const int NbSteps, void LinearAngleVariation(const int NbSteps,
list<double>& theAngles); list<double>& theAngles);
bool doubleNodes( SMESHDS_Mesh* theMeshDS,
const TIDSortedElemSet& theElems,
const TIDSortedElemSet& theNodesNot,
std::map< const SMDS_MeshNode*,
const SMDS_MeshNode* >& theNodeNodeMap,
const bool theIsDoubleElem );
private: private:
SMESH_Mesh * myMesh; SMESH_Mesh * myMesh;

257
src/SMESH_I/SMESH_MeshEditor_i.cxx
View File

@ -917,7 +917,9 @@ namespace
{ {
for (int i=0; i<IDs.length(); i++) { for (int i=0; i<IDs.length(); i++) {
CORBA::Long ind = IDs[i]; CORBA::Long ind = IDs[i];
const SMDS_MeshElement * elem = aMesh->FindElement(ind); const SMDS_MeshElement * elem =
(aType == SMDSAbs_Node ? aMesh->FindNode(ind)
: aMesh->FindElement(ind));
if ( elem && ( aType == SMDSAbs_All || elem->GetType() == aType )) if ( elem && ( aType == SMDSAbs_All || elem->GetType() == aType ))
aMap.insert( elem ); aMap.insert( elem );
} }
@ -4137,31 +4139,32 @@ void SMESH_MeshEditor_i::DumpGroupsList(TPythonDump & theDumpPytho
//================================================================================ //================================================================================
/*! /*!
\brief Creates a hole in a mesh by doubling the nodes of some particular elements \brief Creates a hole in a mesh by doubling the nodes of some particular elements
\param theNodes - identifiers of nodes to be doubled \param theElems - the list of elements (edges or faces) to be replicated
\param theModifiedElems - identifiers of elements to be updated by the new (doubled) The nodes for duplication could be found from these elements
nodes. If list of element identifiers is empty then nodes are doubled but \param theNodesNot - list of nodes to NOT replicate
they not assigned to elements \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 \return TRUE if operation has been completed successfully, FALSE otherwise
\sa DoubleNode(), DoubleNodeGroup(), DoubleNodeGroups() \sa DoubleNodeGroup(), DoubleNodeGroups()
*/ */
//================================================================================ //================================================================================
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theNodes, CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theElems,
const SMESH::long_array& theModifiedElems ) const SMESH::long_array& theNodesNot,
const SMESH::long_array& theAffectedElems )
{ {
initData(); initData();
::SMESH_MeshEditor aMeshEditor( myMesh ); ::SMESH_MeshEditor aMeshEditor( myMesh );
list< int > aListOfNodes;
int i, n;
for ( i = 0, n = theNodes.length(); i < n; i++ )
aListOfNodes.push_back( theNodes[ i ] );
list< int > aListOfElems; SMESHDS_Mesh* aMeshDS = GetMeshDS();
for ( i = 0, n = theModifiedElems.length(); i < n; i++ ) TIDSortedElemSet anElems, aNodes, anAffected;
aListOfElems.push_back( theModifiedElems[ i ] ); arrayToSet(theElems, aMeshDS, anElems, SMDSAbs_All);
arrayToSet(theNodesNot, aMeshDS, aNodes, SMDSAbs_Node);
arrayToSet(theAffectedElems, aMeshDS, anAffected, SMDSAbs_All);
bool aResult = aMeshEditor.DoubleNodes( aListOfNodes, aListOfElems ); bool aResult = aMeshEditor.DoubleNodes( anElems, aNodes, anAffected );
storeResult( aMeshEditor) ; storeResult( aMeshEditor) ;
@ -4171,99 +4174,207 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theNode
//================================================================================ //================================================================================
/*! /*!
\brief Creates a hole in a mesh by doubling the nodes of some particular elements \brief Creates a hole in a mesh by doubling the nodes of some particular elements
This method provided for convenience works as DoubleNodes() described above. \param theElems - the list of elements (edges or faces) to be replicated
\param theNodeId - identifier of node to be doubled. The nodes for duplication could be found from these elements
\param theModifiedElems - identifiers of elements to be updated. \param theNodesNot - list of nodes to NOT replicate
\param theShape - shape to detect affected elements (element which geometric center
located on or inside shape).
The replicated nodes should be associated to affected elements.
\return TRUE if operation has been completed successfully, FALSE otherwise \return TRUE if operation has been completed successfully, FALSE otherwise
\sa DoubleNodes(), DoubleNodeGroup(), DoubleNodeGroups() \sa DoubleNodeGroupInRegion(), DoubleNodeGroupsInRegion()
*/ */
//================================================================================ //================================================================================
CORBA::Boolean SMESH_MeshEditor_i::DoubleNode( CORBA::Long theNodeId, CORBA::Boolean SMESH_MeshEditor_i::DoubleNodesInRegion
const SMESH::long_array& theModifiedElems ) ( const SMESH::long_array& theElems,
const SMESH::long_array& theNodesNot,
GEOM::GEOM_Object_ptr theShape )
{ {
SMESH::long_array_var aNodes = new SMESH::long_array; initData();
aNodes->length( 1 );
aNodes[ 0 ] = theNodeId; ::SMESH_MeshEditor aMeshEditor( myMesh );
return DoubleNodes( aNodes, theModifiedElems );
SMESHDS_Mesh* aMeshDS = GetMeshDS();
TIDSortedElemSet anElems, aNodes;
arrayToSet(theElems, aMeshDS, anElems, SMDSAbs_All);
arrayToSet(theNodesNot, aMeshDS, aNodes, SMDSAbs_Node);
TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape );
bool aResult = aMeshEditor.DoubleNodesInRegion( anElems, aNodes, aShape );
storeResult( aMeshEditor) ;
return aResult;
} }
//================================================================================ //================================================================================
/*! /*!
\brief Creates a hole in a mesh by doubling the nodes of some particular elements \brief Creates a hole in a mesh by doubling the nodes of some particular elements
This method provided for convenience works as DoubleNodes() described above. \param theElems - group of of elements (edges or faces) to be replicated
\param theNodes - group of nodes to be doubled. \param theNodesNot - group of nodes not to replicated
\param theModifiedElems - group of elements to be updated. \param theAffectedElems - group of elements to which the replicated nodes
should be associated to.
\return TRUE if operation has been completed successfully, FALSE otherwise \return TRUE if operation has been completed successfully, FALSE otherwise
\sa DoubleNode(), DoubleNodes(), DoubleNodeGroups() \sa DoubleNodes(), DoubleNodeGroups()
*/ */
//================================================================================ //================================================================================
static void groupToSet(SMESH::SMESH_GroupBase_ptr theGrp,
SMESHDS_Mesh* theMeshDS,
TIDSortedElemSet& theElemSet,
const SMDSAbs_ElementType theType)
{
if ( !CORBA::is_nil( theGrp ) )
arrayToSet( *theGrp->GetListOfID(), theMeshDS, theElemSet, theType);
}
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroup( CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroup(
SMESH::SMESH_GroupBase_ptr theNodes, SMESH::SMESH_GroupBase_ptr theElems,
SMESH::SMESH_GroupBase_ptr theModifiedElems ) SMESH::SMESH_GroupBase_ptr theNodesNot,
SMESH::SMESH_GroupBase_ptr theAffectedElems )
{ {
if ( CORBA::is_nil( theNodes ) && theNodes->GetType() != SMESH::NODE ) if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE )
return false; return false;
SMESH::long_array_var aNodes = theNodes->GetListOfID(); initData();
SMESH::long_array_var aModifiedElems;
if ( !CORBA::is_nil( theModifiedElems ) )
aModifiedElems = theModifiedElems->GetListOfID();
else
{
aModifiedElems = new SMESH::long_array;
aModifiedElems->length( 0 );
}
return DoubleNodes( aNodes, aModifiedElems ); ::SMESH_MeshEditor aMeshEditor( myMesh );
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 );
bool aResult = aMeshEditor.DoubleNodes( anElems, aNodes, anAffected );
storeResult( aMeshEditor) ;
return aResult;
}
//================================================================================
/*!
\brief Creates a hole in a mesh by doubling the nodes of some particular elements
\param theElems - group of of elements (edges or faces) to be replicated
\param theNodesNot - group of nodes not to replicated
\param theShape - shape to detect affected elements (element which geometric center
located on or inside shape).
The replicated nodes should be associated to affected elements.
\return TRUE if operation has been completed successfully, FALSE otherwise
\sa DoubleNodesInRegion(), DoubleNodeGroupsInRegion()
*/
//================================================================================
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroupInRegion(
SMESH::SMESH_GroupBase_ptr theElems,
SMESH::SMESH_GroupBase_ptr theNodesNot,
GEOM::GEOM_Object_ptr theShape )
{
if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE )
return false;
initData();
::SMESH_MeshEditor aMeshEditor( myMesh );
SMESHDS_Mesh* aMeshDS = GetMeshDS();
TIDSortedElemSet anElems, aNodes, anAffected;
groupToSet( theElems, aMeshDS, anElems, SMDSAbs_All );
groupToSet( theNodesNot, aMeshDS, aNodes, SMDSAbs_Node );
TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape );
bool aResult = aMeshEditor.DoubleNodesInRegion( anElems, aNodes, aShape );
storeResult( aMeshEditor) ;
return aResult;
} }
//================================================================================ //================================================================================
/*! /*!
\brief Creates a hole in a mesh by doubling the nodes of some particular elements \brief Creates a hole in a mesh by doubling the nodes of some particular elements
This method provided for convenience works as DoubleNodes() described above. This method provided for convenience works as DoubleNodes() described above.
\param theNodes - list of groups of nodes to be doubled \param theElems - list of groups of elements (edges or faces) to be replicated
\param theModifiedElems - list of groups of elements to be updated. \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 TRUE if operation has been completed successfully, FALSE otherwise \return TRUE if operation has been completed successfully, FALSE otherwise
\sa DoubleNode(), DoubleNodeGroup(), DoubleNodes() \sa DoubleNodeGroup(), DoubleNodes()
*/ */
//================================================================================ //================================================================================
static void listOfGroupToSet(const SMESH::ListOfGroups& theGrpList,
SMESHDS_Mesh* theMeshDS,
TIDSortedElemSet& theElemSet,
const bool theIsNodeGrp)
{
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
: aGrp->GetType() != SMESH::NODE ) )
arrayToSet( *aGrp->GetListOfID(), theMeshDS, theElemSet,
theIsNodeGrp ? SMDSAbs_Node : SMDSAbs_All );
}
}
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups( CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups(
const SMESH::ListOfGroups& theNodes, const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theModifiedElems ) const SMESH::ListOfGroups& theNodesNot,
const SMESH::ListOfGroups& theAffectedElems )
{ {
initData(); initData();
::SMESH_MeshEditor aMeshEditor( myMesh ); ::SMESH_MeshEditor aMeshEditor( myMesh );
std::list< int > aNodes; SMESHDS_Mesh* aMeshDS = GetMeshDS();
int i, n, j, m; TIDSortedElemSet anElems, aNodes, anAffected;
for ( i = 0, n = theNodes.length(); i < n; i++ ) listOfGroupToSet(theElems, aMeshDS, anElems, false );
{ listOfGroupToSet(theNodesNot, aMeshDS, aNodes, true );
SMESH::SMESH_GroupBase_var aGrp = theNodes[ i ]; listOfGroupToSet(theAffectedElems, aMeshDS, anAffected, false );
if ( !CORBA::is_nil( aGrp ) && aGrp->GetType() == SMESH::NODE )
{
SMESH::long_array_var aCurr = aGrp->GetListOfID();
for ( j = 0, m = aCurr->length(); j < m; j++ )
aNodes.push_back( aCurr[ j ] );
}
}
std::list< int > anElems; bool aResult = aMeshEditor.DoubleNodes( anElems, aNodes, anAffected );
for ( i = 0, n = theModifiedElems.length(); i < n; i++ )
{ storeResult( aMeshEditor) ;
SMESH::SMESH_GroupBase_var aGrp = theModifiedElems[ i ];
if ( !CORBA::is_nil( aGrp ) && aGrp->GetType() != SMESH::NODE ) return aResult;
{ }
SMESH::long_array_var aCurr = aGrp->GetListOfID();
for ( j = 0, m = aCurr->length(); j < m; j++ ) //================================================================================
anElems.push_back( aCurr[ j ] ); /*!
} \brief Creates a hole in a mesh by doubling the nodes of some particular elements
} This method provided for convenience works as DoubleNodes() described above.
\param theElems - list of groups of elements (edges or faces) to be replicated
bool aResult = aMeshEditor.DoubleNodes( aNodes, anElems ); \param theNodesNot - list of groups of nodes not to replicated
\param theShape - shape to detect affected elements (element which geometric center
located on or inside shape).
The replicated nodes should be associated to affected elements.
\return TRUE if operation has been completed successfully, FALSE otherwise
\sa DoubleNodeGroupInRegion(), DoubleNodesInRegion()
*/
//================================================================================
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroupsInRegion(
const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot,
GEOM::GEOM_Object_ptr theShape )
{
initData();
::SMESH_MeshEditor aMeshEditor( myMesh );
SMESHDS_Mesh* aMeshDS = GetMeshDS();
TIDSortedElemSet anElems, aNodes;
listOfGroupToSet(theElems, aMeshDS, anElems,false );
listOfGroupToSet(theNodesNot, aMeshDS, aNodes, true );
TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape );
bool aResult = aMeshEditor.DoubleNodesInRegion( anElems, aNodes, aShape );
storeResult( aMeshEditor) ; storeResult( aMeshEditor) ;

93
src/SMESH_I/SMESH_MeshEditor_i.hxx
View File

@ -500,19 +500,94 @@ class SMESH_MeshEditor_i: public POA_SMESH::SMESH_MeshEditor
*/ */
int GetMeshId() const { return myMesh->GetId(); } int GetMeshId() const { return myMesh->GetId(); }
CORBA::Boolean DoubleNodes( const SMESH::long_array& theNodes,
const SMESH::long_array& theModifiedElems );
CORBA::Boolean DoubleNode( CORBA::Long theNodeId, /*!
const SMESH::long_array& theModifiedElems ); * \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
* replicated nodes should be associated to.
* \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodeGroup(), DoubleNodeGroups()
*/
CORBA::Boolean DoubleNodes( const SMESH::long_array& theElems,
const SMESH::long_array& theNodesNot,
const SMESH::long_array& theAffectedElems );
CORBA::Boolean DoubleNodeGroup( SMESH::SMESH_GroupBase_ptr theNodes, /*!
SMESH::SMESH_GroupBase_ptr theModifiedElems ); * \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 theShape - shape to detect affected elements (element which geometric center
* located on or inside shape).
* The replicated nodes should be associated to affected elements.
* \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodeGroupInRegion(), DoubleNodeGroupsInRegion()
*/
CORBA::Boolean DoubleNodesInRegion( const SMESH::long_array& theElems,
const SMESH::long_array& theNodesNot,
GEOM::GEOM_Object_ptr theShape );
CORBA::Boolean DoubleNodeGroups( const SMESH::ListOfGroups& theNodes, /*!
const SMESH::ListOfGroups& theModifiedElems); * \brief Creates a hole in a mesh by doubling the nodes of some particular 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 TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodes(), DoubleNodeGroups()
*/
CORBA::Boolean DoubleNodeGroup( SMESH::SMESH_GroupBase_ptr theElems,
SMESH::SMESH_GroupBase_ptr theNodesNot,
SMESH::SMESH_GroupBase_ptr theAffectedElems );
private: //!< private methods /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements
* \param theElems - group of of elements (edges or faces) to be replicated
* \param theNodesNot - group of nodes not to replicated
* \param theShape - shape to detect affected elements (element which geometric center
* located on or inside shape).
* The replicated nodes should be associated to affected elements.
* \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodesInRegion(), DoubleNodeGroupsInRegion()
*/
CORBA::Boolean DoubleNodeGroupInRegion( SMESH::SMESH_GroupBase_ptr theElems,
SMESH::SMESH_GroupBase_ptr theNodesNot,
GEOM::GEOM_Object_ptr theShape );
/*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements
* This method provided for convenience works as DoubleNodes() described above.
* \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 TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodeGroup(), DoubleNodes()
*/
CORBA::Boolean DoubleNodeGroups( const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot,
const SMESH::ListOfGroups& theAffectedElems );
/*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements
* This method provided for convenience works as DoubleNodes() described above.
* \param theElems - list of groups of elements (edges or faces) to be replicated
* \param theNodesNot - list of groups of nodes not to replicated
* \param theShape - shape to detect affected elements (element which geometric center
* located on or inside shape).
* The replicated nodes should be associated to affected elements.
* \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodeGroupInRegion(), DoubleNodesInRegion()
*/
CORBA::Boolean DoubleNodeGroupsInRegion( const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot,
GEOM::GEOM_Object_ptr theShape );
private: //!< private methods
SMESHDS_Mesh * GetMeshDS() { return myMesh->GetMeshDS(); } SMESHDS_Mesh * GetMeshDS() { return myMesh->GetMeshDS(); }

70
src/SMESH_SWIG/smeshDC.py
View File

@ -3319,41 +3319,71 @@ class Mesh:
return self.editor.GetLastCreatedElems() return self.editor.GetLastCreatedElems()
## Creates a hole in a mesh by doubling the nodes of some particular elements ## Creates a hole in a mesh by doubling the nodes of some particular elements
# @param theNodes identifiers of nodes to be doubled # @param theElems - the list of elements (edges or faces) to be replicated
# @param theModifiedElems identifiers of elements to be updated by the new (doubled) # The nodes for duplication could be found from these elements
# nodes. If list of element identifiers is empty then nodes are doubled but # @param theNodesNot - list of nodes to NOT replicate
# they not assigned to elements # @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 # @return TRUE if operation has been completed successfully, FALSE otherwise
# @ingroup l2_modif_edit # @ingroup l2_modif_edit
def DoubleNodes(self, theNodes, theModifiedElems): def DoubleNodes(self, theElems, theNodesNot, theAffectedElems):
return self.editor.DoubleNodes(theNodes, theModifiedElems) return self.editor.DoubleNodes(theElems, theNodesNot)
## 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 theShape - shape to detect affected elements (element which geometric center
# located on or inside shape).
# The replicated nodes should be associated to affected elements.
# @return TRUE if operation has been completed successfully, FALSE otherwise
# @ingroup l2_modif_edit
def DoubleNodesInRegion( self theElems, theNodesNot, theShape ):
return self.editor.DoubleNodesInRegion(theElems, theNodesNot)
## Creates a hole in a mesh by doubling the nodes of some particular elements ## Creates a hole in a mesh by doubling the nodes of some particular elements
# This method provided for convenience works as DoubleNodes() described above. # This method provided for convenience works as DoubleNodes() described above.
# @param theNodes identifiers of node to be doubled # @param theElems - group of of elements (edges or faces) to be replicated
# @param theModifiedElems identifiers of elements to be updated # @param theNodesNot - group of nodes not to replicated
# @return TRUE if operation has been completed successfully, FALSE otherwise # @param theAffectedElems - group of elements to which the replicated nodes
# should be associated to.
# @ingroup l2_modif_edit # @ingroup l2_modif_edit
def DoubleNode(self, theNodeId, theModifiedElems): def DoubleNodeGroup(self, theElems, theNodesNot, theAffectedElems):
return self.editor.DoubleNode(theNodeId, theModifiedElems) return self.editor.DoubleNodeGroup(theElems, theNodesNot, theAffectedElems)
## Creates a hole in a mesh by doubling the nodes of some particular elements ## Creates a hole in a mesh by doubling the nodes of some particular elements
# This method provided for convenience works as DoubleNodes() described above. # This method provided for convenience works as DoubleNodes() described above.
# @param theNodes group of nodes to be doubled # @param theElems - group of of elements (edges or faces) to be replicated
# @param theModifiedElems group of elements to be updated. # @param theNodesNot - group of nodes not to replicated
# @return TRUE if operation has been completed successfully, FALSE otherwise # @param theShape - shape to detect affected elements (element which geometric center
# located on or inside shape).
# The replicated nodes should be associated to affected elements.
# @ingroup l2_modif_edit # @ingroup l2_modif_edit
def DoubleNodeGroup(self, theNodes, theModifiedElems): def DoubleNodeGroupInRegion(self, theElems, theNodesNot, theShape):
return self.editor.DoubleNodeGroup(theNodes, theModifiedElems) return self.editor.DoubleNodeGroup(theElems, theNodesNot, theShape)
## Creates a hole in a mesh by doubling the nodes of some particular elements ## Creates a hole in a mesh by doubling the nodes of some particular elements
# This method provided for convenience works as DoubleNodes() described above. # This method provided for convenience works as DoubleNodes() described above.
# @param theNodes list of groups of nodes to be doubled # @param theElems - list of groups of elements (edges or faces) to be replicated
# @param theModifiedElems list of groups of elements to be updated. # @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 TRUE if operation has been completed successfully, FALSE otherwise # @return TRUE if operation has been completed successfully, FALSE otherwise
# @ingroup l2_modif_edit # @ingroup l2_modif_edit
def DoubleNodeGroups(self, theNodes, theModifiedElems): def DoubleNodeGroups(self, theElems, theNodesNot, theAffectedElems):
return self.editor.DoubleNodeGroups(theNodes, theModifiedElems) return self.editor.DoubleNodeGroups(theElems, theNodesNot, theAffectedElems)
## Creates a hole in a mesh by doubling the nodes of some particular elements
# This method provided for convenience works as DoubleNodes() described above.
# @param theElems - list of groups of elements (edges or faces) to be replicated
# @param theNodesNot - list of groups of nodes not to replicated
# @param theShape - shape to detect affected elements (element which geometric center
# located on or inside shape).
# The replicated nodes should be associated to affected elements.
# @return TRUE if operation has been completed successfully, FALSE otherwise
# @ingroup l2_modif_edit
def DoubleNodeGroupsInRegion(self, theElems, theNodesNot, theShape):
return self.editor.DoubleNodeGroupsInRegion(theElems, theNodesNot, theShape)
## The mother class to define algorithm, it is not recommended to use it directly. ## The mother class to define algorithm, it is not recommended to use it directly.
# #