-// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
//
-// Copyright (C) 2003 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.
-//
-// 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
+// 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
//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// File : SMESH_MeshEditor_i.cxx
// Author : Nicolas REJNERI
// Module : SMESH
-// $Header$
+
+#ifdef WNT
+#define NOMINMAX
+#endif
+
+// A macro used in SMESH_TryCatch.hxx,
+// it re-raises a CORBA SALOME exception thrown by SMESH_MeshEditor_i and caught by SMESH_CATCH
+#define SMY_OWN_CATCH \
+ catch ( SALOME::SALOME_Exception & e ) { throw e; }
#include "SMESH_MeshEditor_i.hxx"
-#include "SMDS_MeshEdge.hxx"
+#include "SMDS_EdgePosition.hxx"
+#include "SMDS_ElemIterator.hxx"
+#include "SMDS_FacePosition.hxx"
+#include "SMDS_IteratorOnIterators.hxx"
+#include "SMDS_LinearEdge.hxx"
+#include "SMDS_Mesh0DElement.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 "SMDS_SetIterator.hxx"
+#include "SMDS_VolumeTool.hxx"
+#include "SMESHDS_Group.hxx"
+#include "SMESHDS_GroupOnGeom.hxx"
+#include "SMESH_ControlsDef.hxx"
#include "SMESH_Filter_i.hxx"
+#include "SMESH_Gen_i.hxx"
+#include "SMESH_Group.hxx"
+#include "SMESH_Group_i.hxx"
+#include "SMESH_MeshAlgos.hxx"
+#include "SMESH_MeshPartDS.hxx"
+#include "SMESH_MesherHelper.hxx"
#include "SMESH_PythonDump.hxx"
+#include "SMESH_subMeshEventListener.hxx"
+#include "SMESH_subMesh_i.hxx"
-#include "utilities.h"
-#include "Utils_ExceptHandlers.hxx"
-#include "Utils_CorbaException.hxx"
+#include <utilities.h>
+#include <Utils_ExceptHandlers.hxx>
+#include <Utils_CorbaException.hxx>
+#include <SALOMEDS_wrap.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRep_Tool.hxx>
#endif
#include <sstream>
+#include <limits>
+
+#include "SMESH_TryCatch.hxx" // include after OCCT headers!
#define cast2Node(elem) static_cast<const SMDS_MeshNode*>( elem )
using namespace std;
using SMESH::TPythonDump;
+using SMESH::TVar;
-namespace {
+namespace MeshEditor_I {
//=============================================================================
/*!
SMDSAbs_ElementType myPreviewType; // type to show
//!< Constructor
TPreviewMesh(SMDSAbs_ElementType previewElements = SMDSAbs_All) {
- _isShapeToMesh = _id =_studyId =_idDoc = 0;
+ _isShapeToMesh = (_id =_studyId = 0);
_myMeshDS = new SMESHDS_Mesh( _id, true );
myPreviewType = previewElements;
}
//!< Destructor
- virtual ~TPreviewMesh() { delete _myMeshDS; }
+ virtual ~TPreviewMesh() { delete _myMeshDS; _myMeshDS = 0; }
//!< Copy a set of elements
void Copy(const TIDSortedElemSet & theElements,
TIDSortedElemSet& theCopyElements,
if ( type == theAvoidType ||
( theSelectType != SMDSAbs_All && type != theSelectType ))
continue;
-
- if ( const SMDS_MeshElement* anElemCopy = Copy( anElem ))
+ const SMDS_MeshElement* anElemCopy;
+ if ( type == SMDSAbs_Node)
+ anElemCopy = Copy( cast2Node(anElem) );
+ else
+ anElemCopy = Copy( anElem );
+ if ( anElemCopy )
theCopyElements.insert( theCopyElements.end(), anElemCopy );
}
}
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
- static SMESH_NodeSearcher * myNodeSearcher = 0;
+ static SMESH_NodeSearcher * theNodeSearcher = 0;
+ static SMESH_ElementSearcher * theElementSearcher = 0;
//=============================================================================
/*!
- * \brief Deleter of myNodeSearcher at any compute event occured
+ * \brief Deleter of theNodeSearcher at any compute event occured
*/
//=============================================================================
- struct TNodeSearcherDeleter : public SMESH_subMeshEventListener
+ struct TSearchersDeleter : public SMESH_subMeshEventListener
{
SMESH_Mesh* myMesh;
+ string myMeshPartIOR;
//!< Constructor
- TNodeSearcherDeleter(): SMESH_subMeshEventListener( false ), // won't be deleted by submesh
- myMesh(0) {}
- //!< Delete myNodeSearcher
+ TSearchersDeleter(): SMESH_subMeshEventListener( false, // won't be deleted by submesh
+ "SMESH_MeshEditor_i::TSearchersDeleter"),
+ myMesh(0) {}
+ //!< Delete theNodeSearcher
static void Delete()
{
- if ( myNodeSearcher ) { delete myNodeSearcher; myNodeSearcher = 0; }
+ if ( theNodeSearcher ) delete theNodeSearcher; theNodeSearcher = 0;
+ if ( theElementSearcher ) delete theElementSearcher; theElementSearcher = 0;
}
typedef map < int, SMESH_subMesh * > TDependsOnMap;
//!< The meshod called by submesh: do my main job
Unset( sm->GetFather() );
}
}
- //!< set self on all submeshes and delete myNodeSearcher if other mesh is set
- void Set(SMESH_Mesh* mesh)
+ //!< set self on all submeshes and delete theNodeSearcher if other mesh is set
+ void Set(SMESH_Mesh* mesh, const string& meshPartIOR = string())
{
- if ( myMesh && myMesh != mesh ) {
- Delete();
- Unset( myMesh );
- }
- myMesh = mesh;
- if ( SMESH_subMesh* myMainSubMesh = mesh->GetSubMeshContaining(1) ) {
- const TDependsOnMap & subMeshes = myMainSubMesh->DependsOn();
- TDependsOnMap::const_iterator sm;
- for (sm = subMeshes.begin(); sm != subMeshes.end(); sm++)
- sm->second->SetEventListener( this, 0, sm->second );
+ if ( myMesh != mesh || myMeshPartIOR != meshPartIOR)
+ {
+ if ( myMesh ) {
+ Delete();
+ Unset( myMesh );
+ }
+ myMesh = mesh;
+ myMeshPartIOR = meshPartIOR;
+ if ( SMESH_subMesh* myMainSubMesh = mesh->GetSubMeshContaining(1) ) {
+ const TDependsOnMap & subMeshes = myMainSubMesh->DependsOn();
+ TDependsOnMap::const_iterator sm;
+ for (sm = subMeshes.begin(); sm != subMeshes.end(); sm++)
+ sm->second->SetEventListener( this, 0, sm->second );
+ }
}
}
//!< delete self from all submeshes
for (sm = subMeshes.begin(); sm != subMeshes.end(); sm++)
sm->second->DeleteEventListener( this );
}
+ myMesh = 0;
}
- };
+
+ } theSearchersDeleter;
TCollection_AsciiString mirrorTypeName( SMESH::SMESH_MeshEditor::MirrorType theMirrorType )
{
}
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 )
+ {
+ SMDS_MeshElement::NonNullFilter filter1;
+ SMDS_MeshElement::TypeFilter filter2( aType );
+ SMDS_MeshElement::Filter & filter =
+ ( aType == SMDSAbs_All ) ? (SMDS_MeshElement::Filter&) filter1 : filter2;
+
+ if ( aType == SMDSAbs_Node )
+ for (int i=0; i<IDs.length(); i++) {
+ const SMDS_MeshElement * elem = aMesh->FindNode( IDs[i] );
+ if ( filter( elem ))
+ aMap.insert( aMap.end(), elem );
+ }
+ else
+ for (int i=0; i<IDs.length(); i++) {
+ const SMDS_MeshElement * elem = aMesh->FindElement( IDs[i] );
+ if ( filter( elem ))
+ aMap.insert( aMap.end(), 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 bool(anIDs->length()) == bool(theElemSet.size());
+ }
+ 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 );
+ }
+ }
+ }
+ }
+ }
+
+ //================================================================================
+ /*!
+ * \brief Return a string used to detect change of mesh part on which theElementSearcher
+ * is going to be used
+ */
+ //================================================================================
+
+ string getPartIOR( SMESH::SMESH_IDSource_ptr theMeshPart, SMESH::ElementType type)
+ {
+ string partIOR = SMESH_Gen_i::GetORB()->object_to_string( theMeshPart );
+ if ( SMESH_Group_i* group_i = SMESH::DownCast<SMESH_Group_i*>( theMeshPart ))
+ // take into account passible group modification
+ partIOR += SMESH_Comment( ((SMESHDS_Group*)group_i->GetGroupDS())->SMDSGroup().Tic() );
+ partIOR += SMESH_Comment( type );
+ return partIOR;
+ }
+
+} // namespace MeshEditor_I
+
+using namespace MeshEditor_I;
//=============================================================================
/*!
*/
//=============================================================================
-SMESH_MeshEditor_i::SMESH_MeshEditor_i(SMESH_Mesh_i* theMesh, bool isPreview)
+SMESH_MeshEditor_i::SMESH_MeshEditor_i(SMESH_Mesh_i* theMesh, bool isPreview):
+ myMesh_i( theMesh ),
+ myMesh( &theMesh->GetImpl() ),
+ myEditor( myMesh ),
+ myIsPreviewMode ( isPreview ),
+ myPreviewMesh( 0 ),
+ myPreviewEditor( 0 )
{
- myMesh_i = theMesh;
- myMesh = & theMesh->GetImpl();
- myPreviewMode = isPreview;
}
//================================================================================
SMESH_MeshEditor_i::~SMESH_MeshEditor_i()
{
+ deleteAuxIDSources();
+ delete myPreviewMesh; myPreviewMesh = 0;
+ delete myPreviewEditor; myPreviewEditor = 0;
}
//================================================================================
*/
//================================================================================
-void SMESH_MeshEditor_i::initData()
+void SMESH_MeshEditor_i::initData(bool deleteSearchers)
{
- if ( myPreviewMode ) {
- myPreviewData = new SMESH::MeshPreviewStruct();
+ if ( myIsPreviewMode ) {
+ if ( myPreviewMesh ) myPreviewMesh->Clear();
}
else {
- myLastCreatedElems = new SMESH::long_array();
- myLastCreatedNodes = new SMESH::long_array();
- TNodeSearcherDeleter::Delete();
+ if ( deleteSearchers )
+ TSearchersDeleter::Delete();
}
+ getEditor().GetError().reset();
+ getEditor().CrearLastCreated();
}
-//=============================================================================
+//================================================================================
/*!
- *
+ * \brief Increment mesh modif time and optionally record that the performed
+ * modification may influence futher mesh re-compute.
+ * \param [in] isReComputeSafe - true if the modification does not infulence
+ * futher mesh re-compute
*/
-//=============================================================================
+//================================================================================
-CORBA::Boolean
- SMESH_MeshEditor_i::RemoveElements(const SMESH::long_array & IDsOfElements)
+void SMESH_MeshEditor_i::declareMeshModified( bool isReComputeSafe )
{
- initData();
-
- ::SMESH_MeshEditor anEditor( myMesh );
- list< int > IdList;
-
- for (int i = 0; i < IDsOfElements.length(); i++)
- IdList.push_back( IDsOfElements[i] );
-
- // Update Python script
- TPythonDump() << "isDone = " << this << ".RemoveElements( " << IDsOfElements << " )";
-#ifdef _DEBUG_
- TPythonDump() << "print 'RemoveElements: ', isDone";
-#endif
- // Remove Elements
- return anEditor.Remove( IdList, false );
+ myMesh->GetMeshDS()->Modified();
+ if ( !isReComputeSafe )
+ myMesh->SetIsModified( true );
}
-//=============================================================================
+//================================================================================
/*!
- *
+ * \brief Return either myEditor or myPreviewEditor depending on myIsPreviewMode.
+ * WARNING: in preview mode call getPreviewMesh() before getEditor()!
*/
-//=============================================================================
+//================================================================================
-CORBA::Boolean SMESH_MeshEditor_i::RemoveNodes(const SMESH::long_array & IDsOfNodes)
+::SMESH_MeshEditor& SMESH_MeshEditor_i::getEditor()
{
- initData();
-
- ::SMESH_MeshEditor anEditor( myMesh );
- list< int > IdList;
- for (int i = 0; i < IDsOfNodes.length(); i++)
- IdList.push_back( IDsOfNodes[i] );
-
- // Update Python script
- TPythonDump() << "isDone = " << this << ".RemoveNodes( " << IDsOfNodes << " )";
-#ifdef _DEBUG_
- TPythonDump() << "print 'RemoveNodes: ', isDone";
-#endif
-
- return anEditor.Remove( IdList, true );
+ if ( myIsPreviewMode && !myPreviewEditor ) {
+ if ( !myPreviewMesh ) getPreviewMesh();
+ myPreviewEditor = new ::SMESH_MeshEditor( myPreviewMesh );
+ }
+ return myIsPreviewMode ? *myPreviewEditor : myEditor;
}
-//=============================================================================
+//================================================================================
/*!
+ * \brief Initialize and return myPreviewMesh
+ * \param previewElements - type of elements to show in preview
*
+ * WARNING: call it once par a method!
*/
-//=============================================================================
+//================================================================================
-CORBA::Long SMESH_MeshEditor_i::AddEdge(const SMESH::long_array & IDsOfNodes)
+TPreviewMesh * SMESH_MeshEditor_i::getPreviewMesh(SMDSAbs_ElementType previewElements)
{
- initData();
-
- int NbNodes = IDsOfNodes.length();
- SMDS_MeshElement* elem = 0;
- if (NbNodes == 2)
+ if ( !myPreviewMesh || myPreviewMesh->myPreviewType != previewElements )
{
- CORBA::Long index1 = IDsOfNodes[0];
- CORBA::Long index2 = IDsOfNodes[1];
- elem = GetMeshDS()->AddEdge(GetMeshDS()->FindNode(index1), GetMeshDS()->FindNode(index2));
-
- // Update Python script
- TPythonDump() << "edge = " << this << ".AddEdge([ "
- << index1 << ", " << index2 <<" ])";
+ delete myPreviewEditor;
+ myPreviewEditor = 0;
+ delete myPreviewMesh;
+ myPreviewMesh = new TPreviewMesh( previewElements );
}
- if (NbNodes == 3) {
- CORBA::Long n1 = IDsOfNodes[0];
- CORBA::Long n2 = IDsOfNodes[1];
- CORBA::Long n12 = IDsOfNodes[2];
- elem = GetMeshDS()->AddEdge(GetMeshDS()->FindNode(n1),
- GetMeshDS()->FindNode(n2),
- GetMeshDS()->FindNode(n12));
- // Update Python script
- TPythonDump() << "edgeID = " << this << ".AddEdge([ "
- <<n1<<", "<<n2<<", "<<n12<<" ])";
- }
-
- if(elem)
- return elem->GetID();
-
- return 0;
+ myPreviewMesh->Clear();
+ return myPreviewMesh;
}
-//=============================================================================
+//================================================================================
/*!
- *
+ * Return data of mesh edition preview
*/
-//=============================================================================
+//================================================================================
-CORBA::Long SMESH_MeshEditor_i::AddNode(CORBA::Double x,
- CORBA::Double y, CORBA::Double z)
-{
- initData();
+SMESH::MeshPreviewStruct* SMESH_MeshEditor_i::GetPreviewData()
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ const bool hasBadElems = ( getEditor().GetError() && getEditor().GetError()->HasBadElems() );
- const SMDS_MeshNode* N = GetMeshDS()->AddNode(x, y, z);
+ if ( myIsPreviewMode || hasBadElems ) { // --- MeshPreviewStruct filling ---
- // Update Python script
- TPythonDump() << "nodeID = " << this << ".AddNode( "
- << x << ", " << y << ", " << z << " )";
+ list<int> aNodesConnectivity;
+ typedef map<int, int> TNodesMap;
+ TNodesMap nodesMap;
- return N->GetID();
-}
+ SMESHDS_Mesh* aMeshDS;
+ std::auto_ptr< SMESH_MeshPartDS > aMeshPartDS;
+ if ( hasBadElems ) {
+ aMeshPartDS.reset( new SMESH_MeshPartDS( getEditor().GetError()->myBadElements ));
+ aMeshDS = aMeshPartDS.get();
+ }
+ else {
+ aMeshDS = getEditor().GetMeshDS();
+ }
+ myPreviewData = new SMESH::MeshPreviewStruct();
+ myPreviewData->nodesXYZ.length(aMeshDS->NbNodes());
-//=============================================================================
-/*!
- * AddFace
- */
-//=============================================================================
+
+ SMDSAbs_ElementType previewType = SMDSAbs_All;
+ if ( !hasBadElems )
+ if (TPreviewMesh * aPreviewMesh = dynamic_cast< TPreviewMesh* >( getEditor().GetMesh() )) {
+ previewType = aPreviewMesh->myPreviewType;
+ switch ( previewType ) {
+ case SMDSAbs_Edge : break;
+ case SMDSAbs_Face : break;
+ case SMDSAbs_Volume: break;
+ default:;
+ if ( aMeshDS->GetMeshInfo().NbElements() == 0 ) previewType = SMDSAbs_Node;
+ }
+ }
-CORBA::Long SMESH_MeshEditor_i::AddFace(const SMESH::long_array & IDsOfNodes)
-{
- initData();
+ myPreviewData->elementTypes.length( aMeshDS->GetMeshInfo().NbElements( previewType ));
+ int i = 0, j = 0;
+ SMDS_ElemIteratorPtr itMeshElems = aMeshDS->elementsIterator(previewType);
- int NbNodes = IDsOfNodes.length();
- if (NbNodes < 3)
- {
- return false;
- }
+ while ( itMeshElems->more() ) {
+ const SMDS_MeshElement* aMeshElem = itMeshElems->next();
+ SMDS_NodeIteratorPtr itElemNodes = aMeshElem->nodeIterator();
+ while ( itElemNodes->more() ) {
+ const SMDS_MeshNode* aMeshNode = itElemNodes->next();
+ int aNodeID = aMeshNode->GetID();
+ TNodesMap::iterator anIter = nodesMap.find(aNodeID);
+ if ( anIter == nodesMap.end() ) {
+ // filling the nodes coordinates
+ myPreviewData->nodesXYZ[j].x = aMeshNode->X();
+ myPreviewData->nodesXYZ[j].y = aMeshNode->Y();
+ myPreviewData->nodesXYZ[j].z = aMeshNode->Z();
+ anIter = nodesMap.insert( make_pair(aNodeID, j) ).first;
+ j++;
+ }
+ aNodesConnectivity.push_back(anIter->second);
+ }
- std::vector<const SMDS_MeshNode*> nodes (NbNodes);
- for (int i = 0; i < NbNodes; i++)
- nodes[i] = GetMeshDS()->FindNode(IDsOfNodes[i]);
+ // filling the elements types
+ SMDSAbs_ElementType aType = aMeshElem->GetType();
+ bool isPoly = aMeshElem->IsPoly();
+ myPreviewData->elementTypes[i].SMDS_ElementType = (SMESH::ElementType) aType;
+ myPreviewData->elementTypes[i].isPoly = isPoly;
+ myPreviewData->elementTypes[i].nbNodesInElement = aMeshElem->NbNodes();
+ i++;
+ }
+ myPreviewData->nodesXYZ.length( j );
- SMDS_MeshElement* elem = 0;
- if (NbNodes == 3) {
- elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2]);
- }
- else if (NbNodes == 4) {
- elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3]);
- }
- else if (NbNodes == 6) {
- elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
- nodes[4], nodes[5]);
- }
- else if (NbNodes == 8) {
- elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
- nodes[4], nodes[5], nodes[6], nodes[7]);
+ // filling the elements connectivities
+ list<int>::iterator aConnIter = aNodesConnectivity.begin();
+ myPreviewData->elementConnectivities.length(aNodesConnectivity.size());
+ for( int i = 0; aConnIter != aNodesConnectivity.end(); aConnIter++, i++ )
+ myPreviewData->elementConnectivities[i] = *aConnIter;
}
+ return myPreviewData._retn();
- // Update Python script
- TPythonDump() << "faceID = " << this << ".AddFace( " << IDsOfNodes << " )";
-
- if(elem)
- return elem->GetID();
-
+ SMESH_CATCH( SMESH::throwCorbaException );
return 0;
}
-//=============================================================================
+//================================================================================
/*!
- * AddPolygonalFace
+ * \brief Returns list of it's IDs of created nodes
+ * \retval SMESH::long_array* - list of node ID
*/
-//=============================================================================
-CORBA::Long SMESH_MeshEditor_i::AddPolygonalFace
- (const SMESH::long_array & IDsOfNodes)
-{
- initData();
-
- int NbNodes = IDsOfNodes.length();
- std::vector<const SMDS_MeshNode*> nodes (NbNodes);
- for (int i = 0; i < NbNodes; i++)
- nodes[i] = GetMeshDS()->FindNode(IDsOfNodes[i]);
+//================================================================================
- const SMDS_MeshElement* elem = GetMeshDS()->AddPolygonalFace(nodes);
-
- // Update Python script
- TPythonDump() <<"faceID = "<<this<<".AddPolygonalFace( "<<IDsOfNodes<<" )";
-#ifdef _DEBUG_
- TPythonDump() << "print 'AddPolygonalFace: ', faceID";
-#endif
+SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedNodes()
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ SMESH::long_array_var myLastCreatedNodes = new SMESH::long_array();
- if(elem)
- return elem->GetID();
+ const SMESH_SequenceOfElemPtr& aSeq = getEditor().GetLastCreatedNodes();
+ myLastCreatedNodes->length( aSeq.Length() );
+ for (int i = 1; i <= aSeq.Length(); i++)
+ myLastCreatedNodes[i-1] = aSeq.Value(i)->GetID();
+ return myLastCreatedNodes._retn();
+ SMESH_CATCH( SMESH::throwCorbaException );
return 0;
}
-//=============================================================================
+//================================================================================
/*!
- *
+ * \brief Returns list of it's IDs of created elements
+ * \retval SMESH::long_array* - list of elements' ID
*/
-//=============================================================================
+//================================================================================
-CORBA::Long SMESH_MeshEditor_i::AddVolume(const SMESH::long_array & IDsOfNodes)
+SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedElems()
+ throw (SALOME::SALOME_Exception)
{
- initData();
+ SMESH_TRY;
+ SMESH::long_array_var myLastCreatedElems = new SMESH::long_array();
- int NbNodes = IDsOfNodes.length();
- vector< const SMDS_MeshNode*> n(NbNodes);
- for(int i=0;i<NbNodes;i++)
- n[i]=GetMeshDS()->FindNode(IDsOfNodes[i]);
+ const SMESH_SequenceOfElemPtr& aSeq = getEditor().GetLastCreatedElems();
+ myLastCreatedElems->length( aSeq.Length() );
+ for ( int i = 1; i <= aSeq.Length(); i++ )
+ myLastCreatedElems[i-1] = aSeq.Value(i)->GetID();
- SMDS_MeshElement* elem = 0;
- switch(NbNodes)
- {
- case 4 :elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3]); break;
- case 5 :elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4]); break;
- case 6 :elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5]); break;
- case 8 :elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7]); break;
- case 10:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],
- n[6],n[7],n[8],n[9]);
- break;
- case 13:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],
- n[7],n[8],n[9],n[10],n[11],n[12]);
- break;
- case 15:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],n[8],
- n[9],n[10],n[11],n[12],n[13],n[14]);
- break;
- case 20:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],
- n[8],n[9],n[10],n[11],n[12],n[13],n[14],
- n[15],n[16],n[17],n[18],n[19]);
- break;
- }
+ return myLastCreatedElems._retn();
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
- // Update Python script
- TPythonDump() << "volID = " << this << ".AddVolume( " << IDsOfNodes << " )";
-#ifdef _DEBUG_
- TPythonDump() << "print 'AddVolume: ', volID";
-#endif
+//=======================================================================
+//function : ClearLastCreated
+//purpose : Clears sequences of last created elements and nodes
+//=======================================================================
+
+void SMESH_MeshEditor_i::ClearLastCreated() throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ getEditor().CrearLastCreated();
+ SMESH_CATCH( SMESH::throwCorbaException );
+}
+
+//=======================================================================
+/*
+ * Returns description of an error/warning occured during the last operation
+ * WARNING: ComputeError.code >= 100 and no corresponding enum in IDL API
+ */
+//=======================================================================
- if(elem)
- return elem->GetID();
+SMESH::ComputeError* SMESH_MeshEditor_i::GetLastError()
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ SMESH::ComputeError_var errOut = new SMESH::ComputeError;
+ SMESH_ComputeErrorPtr& errIn = getEditor().GetError();
+ if ( errIn && !errIn->IsOK() )
+ {
+ errOut->code = -( errIn->myName < 0 ? errIn->myName + 1: errIn->myName ); // -1 -> 0
+ errOut->comment = errIn->myComment.c_str();
+ errOut->subShapeID = -1;
+ errOut->hasBadMesh = !errIn->myBadElements.empty();
+ }
+ else
+ {
+ errOut->code = 0;
+ errOut->subShapeID = -1;
+ errOut->hasBadMesh = false;
+ }
+ return errOut._retn();
+ SMESH_CATCH( SMESH::throwCorbaException );
return 0;
}
-//=============================================================================
-/*!
- * AddPolyhedralVolume
- */
-//=============================================================================
-CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolume
- (const SMESH::long_array & IDsOfNodes,
- const SMESH::long_array & Quantities)
+//=======================================================================
+//function : MakeIDSource
+//purpose : Wrap a sequence of ids in a SMESH_IDSource
+//=======================================================================
+
+struct SMESH_MeshEditor_i::_IDSource : public POA_SMESH::SMESH_IDSource
{
- initData();
+ 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 ); }
+ bool IsMeshInfoCorrect() { return true; }
+ SMESH::array_of_ElementType* GetTypes()
+ {
+ SMESH::array_of_ElementType_var types = new SMESH::array_of_ElementType;
+ if ( _ids.length() > 0 ) {
+ types->length( 1 );
+ types[0] = _type;
+ }
+ return types._retn();
+ }
+};
- int NbNodes = IDsOfNodes.length();
- std::vector<const SMDS_MeshNode*> n (NbNodes);
- for (int i = 0; i < NbNodes; i++)
- n[i] = GetMeshDS()->FindNode(IDsOfNodes[i]);
+SMESH::SMESH_IDSource_ptr SMESH_MeshEditor_i::MakeIDSource(const SMESH::long_array& ids,
+ SMESH::ElementType type)
+{
+ if ( myAuxIDSources.size() > 10 )
+ deleteAuxIDSources();
- int NbFaces = Quantities.length();
- std::vector<int> q (NbFaces);
- for (int j = 0; j < NbFaces; j++)
- q[j] = Quantities[j];
+ _IDSource* idSrc = new _IDSource;
+ idSrc->_mesh = myMesh_i->_this();
+ idSrc->_ids = ids;
+ idSrc->_type = type;
+ myAuxIDSources.push_back( idSrc );
- const SMDS_MeshElement* elem = GetMeshDS()->AddPolyhedralVolume(n, q);
+ SMESH::SMESH_IDSource_var anIDSourceVar = idSrc->_this();
- // Update Python script
- TPythonDump() << "volID = " << this << ".AddPolyhedralVolume( "
- << IDsOfNodes << ", " << Quantities << " )";
-#ifdef _DEBUG_
- TPythonDump() << "print 'AddPolyhedralVolume: ', volID";
-#endif
+ return anIDSourceVar._retn();
+}
- if(elem)
- return elem->GetID();
+bool SMESH_MeshEditor_i::IsTemporaryIDSource( SMESH::SMESH_IDSource_ptr& idSource )
+{
+ return SMESH::DownCast<SMESH_MeshEditor_i::_IDSource*>( idSource );
+}
- return 0;
+void SMESH_MeshEditor_i::deleteAuxIDSources()
+{
+ std::list< _IDSource* >::iterator idSrcIt = myAuxIDSources.begin();
+ for ( ; idSrcIt != myAuxIDSources.end(); ++idSrcIt )
+ delete *idSrcIt;
+ myAuxIDSources.clear();
}
//=============================================================================
/*!
- * AddPolyhedralVolumeByFaces
+ *
*/
//=============================================================================
-CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolumeByFaces
- (const SMESH::long_array & IdsOfFaces)
+
+CORBA::Boolean
+SMESH_MeshEditor_i::RemoveElements(const SMESH::long_array & IDsOfElements)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
- int NbFaces = IdsOfFaces.length();
- std::vector<const SMDS_MeshNode*> poly_nodes;
- std::vector<int> quantities (NbFaces);
-
- for (int i = 0; i < NbFaces; i++) {
- const SMDS_MeshElement* aFace = GetMeshDS()->FindElement(IdsOfFaces[i]);
- quantities[i] = aFace->NbNodes();
-
- SMDS_ElemIteratorPtr It = aFace->nodesIterator();
- while (It->more()) {
- poly_nodes.push_back(static_cast<const SMDS_MeshNode *>(It->next()));
- }
- }
+ list< int > IdList;
- const SMDS_MeshElement* elem = GetMeshDS()->AddPolyhedralVolume(poly_nodes, quantities);
+ for (int i = 0; i < IDsOfElements.length(); i++)
+ IdList.push_back( IDsOfElements[i] );
// Update Python script
- TPythonDump() << "volID = " << this << ".AddPolyhedralVolumeByFaces( "
- << IdsOfFaces << " )";
-#ifdef _DEBUG_
- TPythonDump() << "print 'AddPolyhedralVolume: ', volID";
-#endif
+ TPythonDump() << "isDone = " << this << ".RemoveElements( " << IDsOfElements << " )";
- if(elem)
- return elem->GetID();
+ // Remove Elements
+ bool ret = getEditor().Remove( IdList, false );
+
+ declareMeshModified( /*isReComputeSafe=*/ IDsOfElements.length() == 0 ); // issue 0020693
+ return ret;
+ SMESH_CATCH( SMESH::throwCorbaException );
return 0;
}
//=============================================================================
/*!
- * \brief Bind a node to a vertex
- * \param NodeID - node ID
- * \param VertexID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
- * \retval boolean - false if NodeID or VertexID is invalid
+ *
*/
//=============================================================================
-void SMESH_MeshEditor_i::SetNodeOnVertex(CORBA::Long NodeID, CORBA::Long VertexID)
+CORBA::Boolean SMESH_MeshEditor_i::RemoveNodes(const SMESH::long_array & IDsOfNodes)
throw (SALOME::SALOME_Exception)
{
- Unexpect aCatch(SALOME_SalomeException);
+ SMESH_TRY;
+ initData();
- SMESHDS_Mesh * mesh = GetMeshDS();
- SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
- if ( !node )
- THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);
+ list< int > IdList;
+ for (int i = 0; i < IDsOfNodes.length(); i++)
+ IdList.push_back( IDsOfNodes[i] );
- if ( mesh->MaxShapeIndex() < VertexID )
- THROW_SALOME_CORBA_EXCEPTION("Invalid VertexID", SALOME::BAD_PARAM);
+ // Update Python script
+ TPythonDump() << "isDone = " << this << ".RemoveNodes( " << IDsOfNodes << " )";
- TopoDS_Shape shape = mesh->IndexToShape( VertexID );
- if ( shape.ShapeType() != TopAbs_VERTEX )
- THROW_SALOME_CORBA_EXCEPTION("Invalid VertexID", SALOME::BAD_PARAM);
+ bool ret = getEditor().Remove( IdList, true );
- mesh->SetNodeOnVertex( node, VertexID );
+ declareMeshModified( /*isReComputeSafe=*/ !ret ); // issue 0020693
+ return ret;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=============================================================================
/*!
- * \brief Store node position on an edge
- * \param NodeID - node ID
- * \param EdgeID - edge ID available through GEOM_Object.GetSubShapeIndices()[0]
- * \param paramOnEdge - parameter on edge where the node is located
- * \retval boolean - false if any parameter is invalid
+ *
*/
//=============================================================================
-void SMESH_MeshEditor_i::SetNodeOnEdge(CORBA::Long NodeID, CORBA::Long EdgeID,
- CORBA::Double paramOnEdge)
+CORBA::Long SMESH_MeshEditor_i::RemoveOrphanNodes()
throw (SALOME::SALOME_Exception)
{
- Unexpect aCatch(SALOME_SalomeException);
+ SMESH_TRY;
+ initData();
- SMESHDS_Mesh * mesh = GetMeshDS();
- SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
- if ( !node )
- THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);
+ // Update Python script
+ TPythonDump() << "nbRemoved = " << this << ".RemoveOrphanNodes()";
- if ( mesh->MaxShapeIndex() < EdgeID )
- THROW_SALOME_CORBA_EXCEPTION("Invalid EdgeID", SALOME::BAD_PARAM);
+ // 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 );
- TopoDS_Shape shape = mesh->IndexToShape( EdgeID );
- if ( shape.ShapeType() != TopAbs_EDGE )
- THROW_SALOME_CORBA_EXCEPTION("Invalid EdgeID", SALOME::BAD_PARAM);
+ // remove orphan nodes (if there are any)
+ list< int > IdList;
+ for ( int i = 0; i < seq.size(); i++ )
+ IdList.push_back( seq[i] );
- Standard_Real f,l;
- BRep_Tool::Range( TopoDS::Edge( shape ), f,l);
- if ( paramOnEdge < f || paramOnEdge > l )
- THROW_SALOME_CORBA_EXCEPTION("Invalid paramOnEdge", SALOME::BAD_PARAM);
+ int nbNodesBefore = myMesh->NbNodes();
+ getEditor().Remove( IdList, true );
+ int nbNodesAfter = myMesh->NbNodes();
- mesh->SetNodeOnEdge( node, EdgeID, paramOnEdge );
+ declareMeshModified( /*isReComputeSafe=*/ IdList.size() == 0 ); // issue 0020693
+ return nbNodesBefore - nbNodesAfter;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=============================================================================
/*!
- * \brief Store node position on a face
- * \param NodeID - node ID
- * \param FaceID - face ID available through GEOM_Object.GetSubShapeIndices()[0]
- * \param u - U parameter on face where the node is located
- * \param v - V parameter on face where the node is located
- * \retval boolean - false if any parameter is invalid
+ * Add a new node.
*/
//=============================================================================
-void SMESH_MeshEditor_i::SetNodeOnFace(CORBA::Long NodeID, CORBA::Long FaceID,
- CORBA::Double u, CORBA::Double v)
+CORBA::Long SMESH_MeshEditor_i::AddNode(CORBA::Double x,CORBA::Double y, CORBA::Double z)
throw (SALOME::SALOME_Exception)
{
- Unexpect aCatch(SALOME_SalomeException);
-
- SMESHDS_Mesh * mesh = GetMeshDS();
- SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
- if ( !node )
- THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);
-
- if ( mesh->MaxShapeIndex() < FaceID )
- THROW_SALOME_CORBA_EXCEPTION("Invalid FaceID", SALOME::BAD_PARAM);
+ SMESH_TRY;
+ initData();
- TopoDS_Shape shape = mesh->IndexToShape( FaceID );
- if ( shape.ShapeType() != TopAbs_FACE )
- THROW_SALOME_CORBA_EXCEPTION("Invalid FaceID", SALOME::BAD_PARAM);
+ const SMDS_MeshNode* N = getMeshDS()->AddNode(x, y, z);
- BRepAdaptor_Surface surf( TopoDS::Face( shape ));
- bool isOut = ( u < surf.FirstUParameter() ||
- u > surf.LastUParameter() ||
- v < surf.FirstVParameter() ||
- v > surf.LastVParameter() );
+ // Update Python script
+ TPythonDump() << "nodeID = " << this << ".AddNode( "
+ << TVar( x ) << ", " << TVar( y ) << ", " << TVar( z )<< " )";
- if ( isOut ) {
-#ifdef _DEBUG_
- cout << "FACE " << FaceID << " (" << u << "," << v << ") out of "
- << " u( " << surf.FirstUParameter()
- << "," << surf.LastUParameter()
- << ") v( " << surf.FirstVParameter()
- << "," << surf.LastVParameter()
- << ")" << endl;
-#endif
- THROW_SALOME_CORBA_EXCEPTION("Invalid UV", SALOME::BAD_PARAM);
- }
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return N->GetID();
- mesh->SetNodeOnFace( node, FaceID, u, v );
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=============================================================================
/*!
- * \brief Bind a node to a solid
- * \param NodeID - node ID
- * \param SolidID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
- * \retval boolean - false if NodeID or SolidID is invalid
+ * Create 0D element on the given node.
*/
//=============================================================================
-void SMESH_MeshEditor_i::SetNodeInVolume(CORBA::Long NodeID, CORBA::Long SolidID)
+CORBA::Long SMESH_MeshEditor_i::Add0DElement(CORBA::Long IDOfNode)
throw (SALOME::SALOME_Exception)
{
- Unexpect aCatch(SALOME_SalomeException);
+ SMESH_TRY;
+ initData();
- SMESHDS_Mesh * mesh = GetMeshDS();
- SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
- if ( !node )
- THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);
+ const SMDS_MeshNode* aNode = getMeshDS()->FindNode(IDOfNode);
+ SMDS_MeshElement* elem = getMeshDS()->Add0DElement(aNode);
- if ( mesh->MaxShapeIndex() < SolidID )
- THROW_SALOME_CORBA_EXCEPTION("Invalid SolidID", SALOME::BAD_PARAM);
+ // Update Python script
+ TPythonDump() << "elem0d = " << this << ".Add0DElement( " << IDOfNode <<" )";
- TopoDS_Shape shape = mesh->IndexToShape( SolidID );
- if ( shape.ShapeType() != TopAbs_SOLID &&
- shape.ShapeType() != TopAbs_SHELL)
- THROW_SALOME_CORBA_EXCEPTION("Invalid SolidID", SALOME::BAD_PARAM);
+ declareMeshModified( /*isReComputeSafe=*/false );
- mesh->SetNodeInVolume( node, SolidID );
+ return elem ? elem->GetID() : 0;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=============================================================================
/*!
- * \brief Bind an element to a shape
- * \param ElementID - element ID
- * \param ShapeID - shape ID available through GEOM_Object.GetSubShapeIndices()[0]
- * \retval boolean - false if ElementID or ShapeID is invalid
+ * Create a ball element on the given node.
*/
//=============================================================================
-void SMESH_MeshEditor_i::SetMeshElementOnShape(CORBA::Long ElementID,
- CORBA::Long ShapeID)
+CORBA::Long SMESH_MeshEditor_i::AddBall(CORBA::Long IDOfNode, CORBA::Double diameter)
throw (SALOME::SALOME_Exception)
{
- Unexpect aCatch(SALOME_SalomeException);
+ SMESH_TRY;
+ initData();
- SMESHDS_Mesh * mesh = GetMeshDS();
- SMDS_MeshElement* elem = const_cast<SMDS_MeshElement*>(mesh->FindElement(ElementID));
- if ( !elem )
- THROW_SALOME_CORBA_EXCEPTION("Invalid ElementID", SALOME::BAD_PARAM);
+ if ( diameter < std::numeric_limits<double>::min() )
+ THROW_SALOME_CORBA_EXCEPTION("Invalid diameter", SALOME::BAD_PARAM);
- if ( mesh->MaxShapeIndex() < ShapeID )
- THROW_SALOME_CORBA_EXCEPTION("Invalid ShapeID", SALOME::BAD_PARAM);
+ const SMDS_MeshNode* aNode = getMeshDS()->FindNode(IDOfNode);
+ SMDS_MeshElement* elem = getMeshDS()->AddBall(aNode, diameter);
- TopoDS_Shape shape = mesh->IndexToShape( ShapeID );
- if ( shape.ShapeType() != TopAbs_EDGE &&
- shape.ShapeType() != TopAbs_FACE &&
- shape.ShapeType() != TopAbs_SOLID &&
- shape.ShapeType() != TopAbs_SHELL )
- THROW_SALOME_CORBA_EXCEPTION("Invalid shape type", SALOME::BAD_PARAM);
+ // Update Python script
+ TPythonDump() << "ballElem = "
+ << this << ".AddBall( " << IDOfNode << ", " << diameter <<" )";
- mesh->SetMeshElementOnShape( elem, ShapeID );
-}
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return elem ? elem->GetID() : 0;
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
//=============================================================================
/*!
- *
+ * Create an edge, either linear and quadratic (this is determed
+ * by number of given nodes, two or three)
*/
//=============================================================================
-CORBA::Boolean SMESH_MeshEditor_i::MoveNode(CORBA::Long NodeID,
- CORBA::Double x,
- CORBA::Double y,
- CORBA::Double z)
+CORBA::Long SMESH_MeshEditor_i::AddEdge(const SMESH::long_array & IDsOfNodes)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
- const SMDS_MeshNode * node = GetMeshDS()->FindNode( NodeID );
- if ( !node )
- return false;
+ int NbNodes = IDsOfNodes.length();
+ SMDS_MeshElement* elem = 0;
+ if (NbNodes == 2)
+ {
+ CORBA::Long index1 = IDsOfNodes[0];
+ CORBA::Long index2 = IDsOfNodes[1];
+ elem = getMeshDS()->AddEdge( getMeshDS()->FindNode(index1),
+ getMeshDS()->FindNode(index2));
- GetMeshDS()->MoveNode(node, x, y, z);
+ // Update Python script
+ TPythonDump() << "edge = " << this << ".AddEdge([ "
+ << index1 << ", " << index2 <<" ])";
+ }
+ if (NbNodes == 3) {
+ CORBA::Long n1 = IDsOfNodes[0];
+ CORBA::Long n2 = IDsOfNodes[1];
+ CORBA::Long n12 = IDsOfNodes[2];
+ elem = getMeshDS()->AddEdge( getMeshDS()->FindNode(n1),
+ getMeshDS()->FindNode(n2),
+ getMeshDS()->FindNode(n12));
+ // Update Python script
+ TPythonDump() << "edgeID = " << this << ".AddEdge([ "
+ <<n1<<", "<<n2<<", "<<n12<<" ])";
+ }
- // Update Python script
- TPythonDump() << "isDone = " << this << ".MoveNode( "
- << NodeID << ", " << x << ", " << y << ", " << z << " )";
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return elem ? elem->GetID() : 0;
- return true;
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=============================================================================
/*!
- *
+ * AddFace
*/
//=============================================================================
-CORBA::Boolean SMESH_MeshEditor_i::InverseDiag(CORBA::Long NodeID1,
- CORBA::Long NodeID2)
+CORBA::Long SMESH_MeshEditor_i::AddFace(const SMESH::long_array & IDsOfNodes)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
- const SMDS_MeshNode * n1 = GetMeshDS()->FindNode( NodeID1 );
- const SMDS_MeshNode * n2 = GetMeshDS()->FindNode( NodeID2 );
- if ( !n1 || !n2 )
- return false;
+ int NbNodes = IDsOfNodes.length();
+ if (NbNodes < 3)
+ {
+ return 0;
+ }
+
+ std::vector<const SMDS_MeshNode*> nodes (NbNodes);
+ for (int i = 0; i < NbNodes; i++)
+ nodes[i] = getMeshDS()->FindNode(IDsOfNodes[i]);
+
+ SMDS_MeshElement* elem = 0;
+ switch (NbNodes) {
+ case 3: elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2]); break;
+ case 4: elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3]); break;
+ case 6: elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
+ nodes[4], nodes[5]); break;
+ case 7: elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
+ nodes[4], nodes[5], nodes[6]); break;
+ case 8: elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
+ nodes[4], nodes[5], nodes[6], nodes[7]); break;
+ case 9: elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
+ nodes[4], nodes[5], nodes[6], nodes[7],
+ nodes[8] ); break;
+ default: elem = getMeshDS()->AddPolygonalFace(nodes);
+ }
// Update Python script
- TPythonDump() << "isDone = " << this << ".InverseDiag( "
- << NodeID1 << ", " << NodeID2 << " )";
+ TPythonDump() << "faceID = " << this << ".AddFace( " << IDsOfNodes << " )";
- ::SMESH_MeshEditor aMeshEditor( myMesh );
- return aMeshEditor.InverseDiag ( n1, n2 );
+ declareMeshModified( /*isReComputeSafe=*/false );
+
+ return elem ? elem->GetID() : 0;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=============================================================================
/*!
- *
+ * AddPolygonalFace
*/
//=============================================================================
-
-CORBA::Boolean SMESH_MeshEditor_i::DeleteDiag(CORBA::Long NodeID1,
- CORBA::Long NodeID2)
+CORBA::Long SMESH_MeshEditor_i::AddPolygonalFace (const SMESH::long_array & IDsOfNodes)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
- const SMDS_MeshNode * n1 = GetMeshDS()->FindNode( NodeID1 );
- const SMDS_MeshNode * n2 = GetMeshDS()->FindNode( NodeID2 );
- if ( !n1 || !n2 )
- return false;
-
- // Update Python script
- TPythonDump() << "isDone = " << this << ".DeleteDiag( "
- << NodeID1 << ", " << NodeID2 << " )";
+ int NbNodes = IDsOfNodes.length();
+ std::vector<const SMDS_MeshNode*> nodes (NbNodes);
+ for (int i = 0; i < NbNodes; i++)
+ nodes[i] = getMeshDS()->FindNode(IDsOfNodes[i]);
- ::SMESH_MeshEditor aMeshEditor( myMesh );
+ const SMDS_MeshElement* elem = getMeshDS()->AddPolygonalFace(nodes);
- bool stat = aMeshEditor.DeleteDiag ( n1, n2 );
+ // Update Python script
+ TPythonDump() <<"faceID = "<<this<<".AddPolygonalFace( "<<IDsOfNodes<<" )";
- storeResult(aMeshEditor);
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return elem ? elem->GetID() : 0;
- return stat;
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=============================================================================
/*!
- *
+ * Create volume, either linear and quadratic (this is determed
+ * by number of given nodes)
*/
//=============================================================================
-CORBA::Boolean SMESH_MeshEditor_i::Reorient(const SMESH::long_array & IDsOfElements)
+CORBA::Long SMESH_MeshEditor_i::AddVolume(const SMESH::long_array & IDsOfNodes)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
- ::SMESH_MeshEditor anEditor( myMesh );
- for (int i = 0; i < IDsOfElements.length(); i++)
+ int NbNodes = IDsOfNodes.length();
+ vector< const SMDS_MeshNode*> n(NbNodes);
+ for(int i=0;i<NbNodes;i++)
+ n[i]= getMeshDS()->FindNode(IDsOfNodes[i]);
+
+ SMDS_MeshElement* elem = 0;
+ switch(NbNodes)
{
- CORBA::Long index = IDsOfElements[i];
- const SMDS_MeshElement * elem = GetMeshDS()->FindElement(index);
- if ( elem )
- anEditor.Reorient( elem );
+ case 4 :elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3]); break;
+ case 5 :elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4]); break;
+ case 6 :elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5]); break;
+ case 8 :elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7]); break;
+ case 10:elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],
+ n[6],n[7],n[8],n[9]);
+ break;
+ case 12:elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],
+ n[6],n[7],n[8],n[9],n[10],n[11]);
+ break;
+ case 13:elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],
+ n[7],n[8],n[9],n[10],n[11],n[12]);
+ break;
+ case 15:elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],n[8],
+ n[9],n[10],n[11],n[12],n[13],n[14]);
+ break;
+ case 20:elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],
+ n[8],n[9],n[10],n[11],n[12],n[13],n[14],
+ n[15],n[16],n[17],n[18],n[19]);
+ break;
+ case 27:elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],
+ n[8],n[9],n[10],n[11],n[12],n[13],n[14],
+ n[15],n[16],n[17],n[18],n[19],
+ n[20],n[21],n[22],n[23],n[24],n[25],n[26]);
+ break;
}
+
// Update Python script
- TPythonDump() << "isDone = " << this << ".Reorient( " << IDsOfElements << " )";
+ TPythonDump() << "volID = " << this << ".AddVolume( " << IDsOfNodes << " )";
- return true;
-}
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return elem ? elem->GetID() : 0;
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
//=============================================================================
/*!
- *
+ * AddPolyhedralVolume
*/
//=============================================================================
-
-CORBA::Boolean SMESH_MeshEditor_i::ReorientObject(SMESH::SMESH_IDSource_ptr theObject)
+CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolume (const SMESH::long_array & IDsOfNodes,
+ const SMESH::long_array & Quantities)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
- SMESH::long_array_var anElementsId = theObject->GetIDs();
- CORBA::Boolean isDone = Reorient(anElementsId);
+ int NbNodes = IDsOfNodes.length();
+ std::vector<const SMDS_MeshNode*> n (NbNodes);
+ for (int i = 0; i < NbNodes; i++)
+ {
+ const SMDS_MeshNode* aNode = getMeshDS()->FindNode(IDsOfNodes[i]);
+ if (!aNode) return 0;
+ n[i] = aNode;
+ }
- // Clear python line, created by Reorient()
- SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
- aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
+ int NbFaces = Quantities.length();
+ std::vector<int> q (NbFaces);
+ for (int j = 0; j < NbFaces; j++)
+ q[j] = Quantities[j];
- // Update Python script
- TPythonDump() << "isDone = " << this << ".ReorientObject( " << theObject << " )";
+ const SMDS_MeshElement* elem = getMeshDS()->AddPolyhedralVolume(n, q);
- return isDone;
-}
+ // Update Python script
+ TPythonDump() << "volID = " << this << ".AddPolyhedralVolume( "
+ << IDsOfNodes << ", " << Quantities << " )";
-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
- */
- //================================================================================
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return elem ? elem->GetID() : 0;
- 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 = aMesh->FindElement(ind);
- if ( elem && ( aType == SMDSAbs_All || elem->GetType() == aType ))
- aMap.insert( elem );
- }
- }
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=============================================================================
/*!
- *
+ * AddPolyhedralVolumeByFaces
*/
//=============================================================================
-CORBA::Boolean SMESH_MeshEditor_i::TriToQuad (const SMESH::long_array & IDsOfElements,
- SMESH::NumericalFunctor_ptr Criterion,
- CORBA::Double MaxAngle)
+
+CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolumeByFaces (const SMESH::long_array & IdsOfFaces)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
- SMESHDS_Mesh* aMesh = GetMeshDS();
- TIDSortedElemSet faces;
- arrayToSet(IDsOfElements, aMesh, faces, SMDSAbs_Face);
+ int NbFaces = IdsOfFaces.length();
+ std::vector<const SMDS_MeshNode*> poly_nodes;
+ std::vector<int> quantities (NbFaces);
- SMESH::NumericalFunctor_i* aNumericalFunctor =
- dynamic_cast<SMESH::NumericalFunctor_i*>( SMESH_Gen_i::GetServant( Criterion ).in() );
- SMESH::Controls::NumericalFunctorPtr aCrit;
- if ( !aNumericalFunctor )
- aCrit.reset( new SMESH::Controls::AspectRatio() );
- else
- aCrit = aNumericalFunctor->GetNumericalFunctor();
+ for (int i = 0; i < NbFaces; i++) {
+ const SMDS_MeshElement* aFace = getMeshDS()->FindElement(IdsOfFaces[i]);
+ quantities[i] = aFace->NbNodes();
- // Update Python script
- TPythonDump() << "isDone = " << this << ".TriToQuad( "
- << IDsOfElements << ", " << aNumericalFunctor << ", " << MaxAngle << " )";
-#ifdef _DEBUG_
- TPythonDump() << "print 'TriToQuad: ', isDone";
-#endif
+ SMDS_ElemIteratorPtr It = aFace->nodesIterator();
+ while (It->more()) {
+ poly_nodes.push_back(static_cast<const SMDS_MeshNode *>(It->next()));
+ }
+ }
- ::SMESH_MeshEditor anEditor( myMesh );
+ const SMDS_MeshElement* elem = getMeshDS()->AddPolyhedralVolume(poly_nodes, quantities);
- bool stat = anEditor.TriToQuad( faces, aCrit, MaxAngle );
+ // Update Python script
+ TPythonDump() << "volID = " << this << ".AddPolyhedralVolumeByFaces( "
+ << IdsOfFaces << " )";
- storeResult(anEditor);
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return elem ? elem->GetID() : 0;
- return stat;
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
-
//=============================================================================
-/*!
- *
- */
+//
+// \brief Create 0D elements on all nodes of the given object except those
+// nodes on which a 0D element already exists.
+// \param theObject object on whose nodes 0D elements will be created.
+// \param theGroupName optional name of a group to add 0D elements created
+// and/or found on nodes of \a theObject.
+// \return an object (a new group or a temporary SMESH_IDSource) holding
+// ids of new and/or found 0D elements.
+//
//=============================================================================
-CORBA::Boolean SMESH_MeshEditor_i::TriToQuadObject (SMESH::SMESH_IDSource_ptr theObject,
- SMESH::NumericalFunctor_ptr Criterion,
- CORBA::Double MaxAngle)
+
+SMESH::SMESH_IDSource_ptr
+SMESH_MeshEditor_i::Create0DElementsOnAllNodes(SMESH::SMESH_IDSource_ptr theObject,
+ const char* theGroupName)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
- SMESH::long_array_var anElementsId = theObject->GetIDs();
- CORBA::Boolean isDone = TriToQuad(anElementsId, Criterion, MaxAngle);
+ SMESH::SMESH_IDSource_var result;
+ TPythonDump pyDump;
- // Clear python line(s), created by TriToQuad()
- SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
- aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
-#ifdef _DEBUG_
- aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
-#endif
+ TIDSortedElemSet elements, elems0D;
+ prepareIdSource( theObject );
+ if ( idSourceToSet( theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
+ getEditor().Create0DElementsOnAllNodes( elements, elems0D );
- SMESH::NumericalFunctor_i* aNumericalFunctor =
- SMESH::DownCast<SMESH::NumericalFunctor_i*>( Criterion );
+ SMESH::long_array_var newElems = new SMESH::long_array;
+ newElems->length( elems0D.size() );
+ TIDSortedElemSet::iterator eIt = elems0D.begin();
+ for ( size_t i = 0; i < elems0D.size(); ++i, ++eIt )
+ newElems[ i ] = (*eIt)->GetID();
- // Update Python script
- TPythonDump() << "isDone = " << this << ".TriToQuadObject("
- << theObject << ", " << aNumericalFunctor << ", " << MaxAngle << " )";
-#ifdef _DEBUG_
- TPythonDump() << "print 'TriToQuadObject: ', isDone";
-#endif
+ SMESH::SMESH_GroupBase_var groupToFill;
+ if ( theGroupName && strlen( theGroupName ))
+ {
+ // Get existing group named theGroupName
+ SMESH::ListOfGroups_var groups = myMesh_i->GetGroups();
+ for (int i = 0, nbGroups = groups->length(); i < nbGroups; i++ ) {
+ SMESH::SMESH_GroupBase_var group = groups[i];
+ if ( !group->_is_nil() ) {
+ CORBA::String_var name = group->GetName();
+ if ( strcmp( name.in(), theGroupName ) == 0 && group->GetType() == SMESH::ELEM0D ) {
+ groupToFill = group;
+ break;
+ }
+ }
+ }
+ if ( groupToFill->_is_nil() )
+ groupToFill = myMesh_i->CreateGroup( SMESH::ELEM0D, theGroupName );
+ else if ( !SMESH::DownCast< SMESH_Group_i* > ( groupToFill ))
+ groupToFill = myMesh_i->ConvertToStandalone( groupToFill );
+ }
- return isDone;
-}
+ if ( SMESH_Group_i* group_i = SMESH::DownCast< SMESH_Group_i* > ( groupToFill ))
+ {
+ group_i->Add( newElems );
+ result = SMESH::SMESH_IDSource::_narrow( groupToFill );
+ pyDump << groupToFill;
+ }
+ else
+ {
+ result = MakeIDSource( newElems, SMESH::ELEM0D );
+ pyDump << "elem0DIDs";
+ }
+
+ pyDump << " = " << this << ".Create0DElementsOnAllNodes( "
+ << theObject << ", '" << theGroupName << "' )";
+
+ return result._retn();
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
//=============================================================================
/*!
- *
+ * \brief Bind a node to a vertex
+ * \param NodeID - node ID
+ * \param VertexID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
+ * \retval boolean - false if NodeID or VertexID is invalid
*/
//=============================================================================
-CORBA::Boolean SMESH_MeshEditor_i::QuadToTri (const SMESH::long_array & IDsOfElements,
- SMESH::NumericalFunctor_ptr Criterion)
-{
- initData();
- SMESHDS_Mesh* aMesh = GetMeshDS();
- TIDSortedElemSet faces;
- arrayToSet(IDsOfElements, aMesh, faces, SMDSAbs_Face);
+void SMESH_MeshEditor_i::SetNodeOnVertex(CORBA::Long NodeID, CORBA::Long VertexID)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
- SMESH::NumericalFunctor_i* aNumericalFunctor =
- dynamic_cast<SMESH::NumericalFunctor_i*>( SMESH_Gen_i::GetServant( Criterion ).in() );
- SMESH::Controls::NumericalFunctorPtr aCrit;
- if ( !aNumericalFunctor )
- aCrit.reset( new SMESH::Controls::AspectRatio() );
- else
- aCrit = aNumericalFunctor->GetNumericalFunctor();
+ SMESHDS_Mesh * mesh = getMeshDS();
+ SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
+ if ( !node )
+ THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);
+ if ( mesh->MaxShapeIndex() < VertexID )
+ THROW_SALOME_CORBA_EXCEPTION("Invalid VertexID", SALOME::BAD_PARAM);
- // Update Python script
- TPythonDump() << "isDone = " << this << ".QuadToTri( " << IDsOfElements << ", " << aNumericalFunctor << " )";
-#ifdef _DEBUG_
- TPythonDump() << "print 'QuadToTri: ', isDone";
-#endif
+ TopoDS_Shape shape = mesh->IndexToShape( VertexID );
+ if ( shape.ShapeType() != TopAbs_VERTEX )
+ THROW_SALOME_CORBA_EXCEPTION("Invalid VertexID", SALOME::BAD_PARAM);
- ::SMESH_MeshEditor anEditor( myMesh );
- CORBA::Boolean stat = anEditor.QuadToTri( faces, aCrit );
+ mesh->SetNodeOnVertex( node, VertexID );
- storeResult(anEditor);
+ myMesh->SetIsModified( true );
- return stat;
+ SMESH_CATCH( SMESH::throwCorbaException );
}
-
//=============================================================================
/*!
- *
+ * \brief Store node position on an edge
+ * \param NodeID - node ID
+ * \param EdgeID - edge ID available through GEOM_Object.GetSubShapeIndices()[0]
+ * \param paramOnEdge - parameter on edge where the node is located
+ * \retval boolean - false if any parameter is invalid
*/
//=============================================================================
-CORBA::Boolean SMESH_MeshEditor_i::QuadToTriObject (SMESH::SMESH_IDSource_ptr theObject,
- SMESH::NumericalFunctor_ptr Criterion)
+
+void SMESH_MeshEditor_i::SetNodeOnEdge(CORBA::Long NodeID, CORBA::Long EdgeID,
+ CORBA::Double paramOnEdge)
+ throw (SALOME::SALOME_Exception)
{
- initData();
+ SMESH_TRY;
- SMESH::long_array_var anElementsId = theObject->GetIDs();
- CORBA::Boolean isDone = QuadToTri(anElementsId, Criterion);
+ SMESHDS_Mesh * mesh = getMeshDS();
+ SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
+ if ( !node )
+ THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);
- // Clear python line(s), created by QuadToTri()
- SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
- aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
-#ifdef _DEBUG_
- aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
-#endif
+ if ( mesh->MaxShapeIndex() < EdgeID )
+ THROW_SALOME_CORBA_EXCEPTION("Invalid EdgeID", SALOME::BAD_PARAM);
- SMESH::NumericalFunctor_i* aNumericalFunctor =
- SMESH::DownCast<SMESH::NumericalFunctor_i*>( Criterion );
+ TopoDS_Shape shape = mesh->IndexToShape( EdgeID );
+ if ( shape.ShapeType() != TopAbs_EDGE )
+ THROW_SALOME_CORBA_EXCEPTION("Invalid EdgeID", SALOME::BAD_PARAM);
- // Update Python script
- TPythonDump() << "isDone = " << this << ".QuadToTriObject( " << theObject << ", " << aNumericalFunctor << " )";
-#ifdef _DEBUG_
- TPythonDump() << "print 'QuadToTriObject: ', isDone";
-#endif
+ Standard_Real f,l;
+ BRep_Tool::Range( TopoDS::Edge( shape ), f,l);
+ if ( paramOnEdge < f || paramOnEdge > l )
+ THROW_SALOME_CORBA_EXCEPTION("Invalid paramOnEdge", SALOME::BAD_PARAM);
- return isDone;
-}
+ mesh->SetNodeOnEdge( node, EdgeID, paramOnEdge );
+ myMesh->SetIsModified( true );
-//=============================================================================
+ SMESH_CATCH( SMESH::throwCorbaException );
+}
+
+//=============================================================================
/*!
- *
+ * \brief Store node position on a face
+ * \param NodeID - node ID
+ * \param FaceID - face ID available through GEOM_Object.GetSubShapeIndices()[0]
+ * \param u - U parameter on face where the node is located
+ * \param v - V parameter on face where the node is located
+ * \retval boolean - false if any parameter is invalid
*/
//=============================================================================
-CORBA::Boolean SMESH_MeshEditor_i::SplitQuad (const SMESH::long_array & IDsOfElements,
- CORBA::Boolean Diag13)
+
+void SMESH_MeshEditor_i::SetNodeOnFace(CORBA::Long NodeID, CORBA::Long FaceID,
+ CORBA::Double u, CORBA::Double v)
+ throw (SALOME::SALOME_Exception)
{
- initData();
+ SMESH_TRY;
+ SMESHDS_Mesh * mesh = getMeshDS();
+ SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
+ if ( !node )
+ THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);
- SMESHDS_Mesh* aMesh = GetMeshDS();
- TIDSortedElemSet faces;
- arrayToSet(IDsOfElements, aMesh, faces, SMDSAbs_Face);
+ if ( mesh->MaxShapeIndex() < FaceID )
+ THROW_SALOME_CORBA_EXCEPTION("Invalid FaceID", SALOME::BAD_PARAM);
- // Update Python script
- TPythonDump() << "isDone = " << this << ".SplitQuad( "
- << IDsOfElements << ", " << Diag13 << " )";
+ TopoDS_Shape shape = mesh->IndexToShape( FaceID );
+ if ( shape.ShapeType() != TopAbs_FACE )
+ THROW_SALOME_CORBA_EXCEPTION("Invalid FaceID", SALOME::BAD_PARAM);
+
+ BRepAdaptor_Surface surf( TopoDS::Face( shape ));
+ bool isOut = ( u < surf.FirstUParameter() ||
+ u > surf.LastUParameter() ||
+ v < surf.FirstVParameter() ||
+ v > surf.LastVParameter() );
+
+ if ( isOut ) {
#ifdef _DEBUG_
- TPythonDump() << "print 'SplitQuad: ', isDone";
+ MESSAGE ( "FACE " << FaceID << " (" << u << "," << v << ") out of "
+ << " u( " << surf.FirstUParameter()
+ << "," << surf.LastUParameter()
+ << ") v( " << surf.FirstVParameter()
+ << "," << surf.LastVParameter() << ")" );
#endif
+ THROW_SALOME_CORBA_EXCEPTION("Invalid UV", SALOME::BAD_PARAM);
+ }
- ::SMESH_MeshEditor anEditor( myMesh );
- CORBA::Boolean stat = anEditor.QuadToTri( faces, Diag13 );
-
- storeResult(anEditor);
+ mesh->SetNodeOnFace( node, FaceID, u, v );
+ myMesh->SetIsModified( true );
- return stat;
+ SMESH_CATCH( SMESH::throwCorbaException );
}
-
//=============================================================================
/*!
- *
+ * \brief Bind a node to a solid
+ * \param NodeID - node ID
+ * \param SolidID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
+ * \retval boolean - false if NodeID or SolidID is invalid
*/
//=============================================================================
-CORBA::Boolean SMESH_MeshEditor_i::SplitQuadObject (SMESH::SMESH_IDSource_ptr theObject,
- CORBA::Boolean Diag13)
+
+void SMESH_MeshEditor_i::SetNodeInVolume(CORBA::Long NodeID, CORBA::Long SolidID)
+ throw (SALOME::SALOME_Exception)
{
- initData();
+ SMESH_TRY;
+ SMESHDS_Mesh * mesh = getMeshDS();
+ SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
+ if ( !node )
+ THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);
- SMESH::long_array_var anElementsId = theObject->GetIDs();
- CORBA::Boolean isDone = SplitQuad(anElementsId, Diag13);
+ if ( mesh->MaxShapeIndex() < SolidID )
+ THROW_SALOME_CORBA_EXCEPTION("Invalid SolidID", SALOME::BAD_PARAM);
- // Clear python line(s), created by SplitQuad()
- SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
- aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
-#ifdef _DEBUG_
- aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
-#endif
+ TopoDS_Shape shape = mesh->IndexToShape( SolidID );
+ if ( shape.ShapeType() != TopAbs_SOLID &&
+ shape.ShapeType() != TopAbs_SHELL)
+ THROW_SALOME_CORBA_EXCEPTION("Invalid SolidID", SALOME::BAD_PARAM);
- // Update Python script
- TPythonDump() << "isDone = " << this << ".SplitQuadObject( "
- << theObject << ", " << Diag13 << " )";
-#ifdef _DEBUG_
- TPythonDump() << "print 'SplitQuadObject: ', isDone";
-#endif
+ mesh->SetNodeInVolume( node, SolidID );
- return isDone;
+ SMESH_CATCH( SMESH::throwCorbaException );
}
-
//=============================================================================
/*!
- * BestSplit
+ * \brief Bind an element to a shape
+ * \param ElementID - element ID
+ * \param ShapeID - shape ID available through GEOM_Object.GetSubShapeIndices()[0]
*/
//=============================================================================
-CORBA::Long SMESH_MeshEditor_i::BestSplit (CORBA::Long IDOfQuad,
- SMESH::NumericalFunctor_ptr Criterion)
+
+void SMESH_MeshEditor_i::SetMeshElementOnShape(CORBA::Long ElementID,
+ CORBA::Long ShapeID)
+ throw (SALOME::SALOME_Exception)
{
- const SMDS_MeshElement* quad = GetMeshDS()->FindElement(IDOfQuad);
- if (quad && quad->GetType() == SMDSAbs_Face && quad->NbNodes() == 4)
- {
- SMESH::NumericalFunctor_i* aNumericalFunctor =
- dynamic_cast<SMESH::NumericalFunctor_i*>(SMESH_Gen_i::GetServant(Criterion).in());
- SMESH::Controls::NumericalFunctorPtr aCrit;
- if (aNumericalFunctor)
- aCrit = aNumericalFunctor->GetNumericalFunctor();
- else
- aCrit.reset(new SMESH::Controls::AspectRatio());
+ SMESH_TRY;
+ SMESHDS_Mesh * mesh = getMeshDS();
+ SMDS_MeshElement* elem = const_cast<SMDS_MeshElement*>(mesh->FindElement(ElementID));
+ if ( !elem )
+ THROW_SALOME_CORBA_EXCEPTION("Invalid ElementID", SALOME::BAD_PARAM);
- ::SMESH_MeshEditor anEditor (myMesh);
- return anEditor.BestSplit(quad, aCrit);
- }
- return -1;
-}
+ if ( mesh->MaxShapeIndex() < ShapeID || ShapeID < 1 )
+ THROW_SALOME_CORBA_EXCEPTION("Invalid ShapeID", SALOME::BAD_PARAM);
+ TopoDS_Shape shape = mesh->IndexToShape( ShapeID );
+ if ( shape.ShapeType() != TopAbs_EDGE &&
+ shape.ShapeType() != TopAbs_FACE &&
+ shape.ShapeType() != TopAbs_SOLID &&
+ shape.ShapeType() != TopAbs_SHELL )
+ THROW_SALOME_CORBA_EXCEPTION("Invalid shape type", SALOME::BAD_PARAM);
-//=======================================================================
-//function : Smooth
-//purpose :
-//=======================================================================
+ mesh->SetMeshElementOnShape( elem, ShapeID );
-CORBA::Boolean
- SMESH_MeshEditor_i::Smooth(const SMESH::long_array & IDsOfElements,
- const SMESH::long_array & IDsOfFixedNodes,
- CORBA::Long MaxNbOfIterations,
- CORBA::Double MaxAspectRatio,
- SMESH::SMESH_MeshEditor::Smooth_Method Method)
-{
- return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
- MaxAspectRatio, Method, false );
-}
+ myMesh->SetIsModified( true );
+ SMESH_CATCH( SMESH::throwCorbaException );
+}
-//=======================================================================
-//function : SmoothParametric
-//purpose :
-//=======================================================================
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
-CORBA::Boolean
- SMESH_MeshEditor_i::SmoothParametric(const SMESH::long_array & IDsOfElements,
- const SMESH::long_array & IDsOfFixedNodes,
- CORBA::Long MaxNbOfIterations,
- CORBA::Double MaxAspectRatio,
- SMESH::SMESH_MeshEditor::Smooth_Method Method)
+CORBA::Boolean SMESH_MeshEditor_i::InverseDiag(CORBA::Long NodeID1,
+ CORBA::Long NodeID2)
+ throw (SALOME::SALOME_Exception)
{
- return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
- MaxAspectRatio, Method, true );
-}
-
+ SMESH_TRY;
+ initData();
-//=======================================================================
-//function : SmoothObject
-//purpose :
-//=======================================================================
+ const SMDS_MeshNode * n1 = getMeshDS()->FindNode( NodeID1 );
+ const SMDS_MeshNode * n2 = getMeshDS()->FindNode( NodeID2 );
+ if ( !n1 || !n2 )
+ return false;
-CORBA::Boolean
- SMESH_MeshEditor_i::SmoothObject(SMESH::SMESH_IDSource_ptr theObject,
- const SMESH::long_array & IDsOfFixedNodes,
- CORBA::Long MaxNbOfIterations,
- CORBA::Double MaxAspectRatio,
- SMESH::SMESH_MeshEditor::Smooth_Method Method)
-{
- return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
- MaxAspectRatio, Method, false);
-}
+ // Update Python script
+ TPythonDump() << "isDone = " << this << ".InverseDiag( "
+ << NodeID1 << ", " << NodeID2 << " )";
+ int ret = getEditor().InverseDiag ( n1, n2 );
-//=======================================================================
-//function : SmoothParametricObject
-//purpose :
-//=======================================================================
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return ret;
-CORBA::Boolean
- SMESH_MeshEditor_i::SmoothParametricObject(SMESH::SMESH_IDSource_ptr theObject,
- const SMESH::long_array & IDsOfFixedNodes,
- CORBA::Long MaxNbOfIterations,
- CORBA::Double MaxAspectRatio,
- SMESH::SMESH_MeshEditor::Smooth_Method Method)
-{
- return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
- MaxAspectRatio, Method, true);
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
-
//=============================================================================
/*!
*
*/
//=============================================================================
-CORBA::Boolean
- SMESH_MeshEditor_i::smooth(const SMESH::long_array & IDsOfElements,
- const SMESH::long_array & IDsOfFixedNodes,
- CORBA::Long MaxNbOfIterations,
- CORBA::Double MaxAspectRatio,
- SMESH::SMESH_MeshEditor::Smooth_Method Method,
- bool IsParametric)
+CORBA::Boolean SMESH_MeshEditor_i::DeleteDiag(CORBA::Long NodeID1,
+ CORBA::Long NodeID2)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
- SMESHDS_Mesh* aMesh = GetMeshDS();
+ const SMDS_MeshNode * n1 = getMeshDS()->FindNode( NodeID1 );
+ const SMDS_MeshNode * n2 = getMeshDS()->FindNode( NodeID2 );
+ if ( !n1 || !n2 )
+ return false;
- TIDSortedElemSet elements;
- arrayToSet(IDsOfElements, aMesh, elements, SMDSAbs_Face);
+ // Update Python script
+ TPythonDump() << "isDone = " << this << ".DeleteDiag( "
+ << NodeID1 << ", " << NodeID2 << " )";
- set<const SMDS_MeshNode*> fixedNodes;
- for (int i = 0; i < IDsOfFixedNodes.length(); i++) {
- CORBA::Long index = IDsOfFixedNodes[i];
- const SMDS_MeshNode * node = aMesh->FindNode(index);
- if ( node )
- fixedNodes.insert( node );
- }
- ::SMESH_MeshEditor::SmoothMethod method = ::SMESH_MeshEditor::LAPLACIAN;
- if ( Method != SMESH::SMESH_MeshEditor::LAPLACIAN_SMOOTH )
- method = ::SMESH_MeshEditor::CENTROIDAL;
- ::SMESH_MeshEditor anEditor( myMesh );
- anEditor.Smooth(elements, fixedNodes, method,
- MaxNbOfIterations, MaxAspectRatio, IsParametric );
+ bool stat = getEditor().DeleteDiag ( n1, n2 );
- storeResult(anEditor);
+ declareMeshModified( /*isReComputeSafe=*/!stat );
- // Update Python script
- TPythonDump() << "isDone = " << this << "."
- << (IsParametric ? "SmoothParametric( " : "Smooth( ")
- << IDsOfElements << ", " << IDsOfFixedNodes << ", "
- << MaxNbOfIterations << ", " << MaxAspectRatio << ", "
- << "SMESH.SMESH_MeshEditor."
- << ( Method == SMESH::SMESH_MeshEditor::CENTROIDAL_SMOOTH ?
- "CENTROIDAL_SMOOTH )" : "LAPLACIAN_SMOOTH )");
-#ifdef _DEBUG_
- TPythonDump() << "print 'Smooth: ', isDone";
-#endif
+ return stat;
- return true;
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
-
//=============================================================================
/*!
*
*/
//=============================================================================
-CORBA::Boolean
-SMESH_MeshEditor_i::smoothObject(SMESH::SMESH_IDSource_ptr theObject,
- const SMESH::long_array & IDsOfFixedNodes,
- CORBA::Long MaxNbOfIterations,
- CORBA::Double MaxAspectRatio,
- SMESH::SMESH_MeshEditor::Smooth_Method Method,
- bool IsParametric)
+CORBA::Boolean SMESH_MeshEditor_i::Reorient(const SMESH::long_array & IDsOfElements)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
- SMESH::long_array_var anElementsId = theObject->GetIDs();
- CORBA::Boolean isDone = smooth (anElementsId, IDsOfFixedNodes, MaxNbOfIterations,
- MaxAspectRatio, Method, IsParametric);
-
- // Clear python line(s), created by Smooth()
- SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
- aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
-#ifdef _DEBUG_
- aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
-#endif
-
+ for (int i = 0; i < IDsOfElements.length(); i++)
+ {
+ CORBA::Long index = IDsOfElements[i];
+ const SMDS_MeshElement * elem = getMeshDS()->FindElement(index);
+ if ( elem )
+ getEditor().Reorient( elem );
+ }
// Update Python script
- TPythonDump() << "isDone = " << this << "."
- << (IsParametric ? "SmoothParametricObject( " : "SmoothObject( ")
- << theObject << ", " << IDsOfFixedNodes << ", "
- << MaxNbOfIterations << ", " << MaxAspectRatio << ", "
- << "SMESH.SMESH_MeshEditor."
- << ( Method == SMESH::SMESH_MeshEditor::CENTROIDAL_SMOOTH ?
- "CENTROIDAL_SMOOTH )" : "LAPLACIAN_SMOOTH )");
-#ifdef _DEBUG_
- TPythonDump() << "print 'SmoothObject: ', isDone";
-#endif
+ TPythonDump() << "isDone = " << this << ".Reorient( " << IDsOfElements << " )";
- return isDone;
-}
+ declareMeshModified( /*isReComputeSafe=*/ IDsOfElements.length() == 0 );
+ return true;
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
//=============================================================================
/*!
*/
//=============================================================================
-void SMESH_MeshEditor_i::RenumberNodes()
+CORBA::Boolean SMESH_MeshEditor_i::ReorientObject(SMESH::SMESH_IDSource_ptr theObject)
+ throw (SALOME::SALOME_Exception)
{
- // Update Python script
- TPythonDump() << this << ".RenumberNodes()";
+ SMESH_TRY;
+ initData();
- GetMeshDS()->Renumber( true );
-}
+ TPythonDump aTPythonDump; // suppress dump in Reorient()
+ prepareIdSource( theObject );
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
+ SMESH::long_array_var anElementsId = theObject->GetIDs();
+ CORBA::Boolean isDone = Reorient(anElementsId);
-void SMESH_MeshEditor_i::RenumberElements()
-{
// Update Python script
- TPythonDump() << this << ".RenumberElements()";
+ aTPythonDump << "isDone = " << this << ".ReorientObject( " << theObject << " )";
- GetMeshDS()->Renumber( false );
+ declareMeshModified( /*isReComputeSafe=*/ anElementsId->length() == 0 );
+ return isDone;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=======================================================================
- /*!
- * \brief Return groups by their IDs
- */
+//function : Reorient2D
+//purpose : Reorient faces contained in \a the2Dgroup.
+// the2Dgroup - the mesh or its part to reorient
+// theDirection - desired direction of normal of \a theFace
+// theFace - ID of face whose orientation is checked.
+// It can be < 1 then \a thePoint is used to find a face.
+// thePoint - is used to find a face if \a theFace < 1.
+// return number of reoriented elements.
//=======================================================================
-SMESH::ListOfGroups* SMESH_MeshEditor_i::getGroups(const std::list<int>* groupIDs)
+CORBA::Long SMESH_MeshEditor_i::Reorient2D(SMESH::SMESH_IDSource_ptr the2Dgroup,
+ const SMESH::DirStruct& theDirection,
+ CORBA::Long theFace,
+ const SMESH::PointStruct& thePoint)
+ throw (SALOME::SALOME_Exception)
{
- if ( !groupIDs )
- return 0;
- myMesh_i->CreateGroupServants();
- return myMesh_i->GetGroups( *groupIDs );
-}
+ SMESH_TRY;
+ initData(/*deleteSearchers=*/false);
-//=======================================================================
-//function : rotationSweep
-//purpose :
-//=======================================================================
+ TIDSortedElemSet elements;
+ prepareIdSource( the2Dgroup );
+ if ( !idSourceToSet( the2Dgroup, getMeshDS(), elements, SMDSAbs_Face, /*emptyIfIsMesh=*/1))
+ THROW_SALOME_CORBA_EXCEPTION("No faces in given group", SALOME::BAD_PARAM);
-SMESH::ListOfGroups*
-SMESH_MeshEditor_i::rotationSweep(const SMESH::long_array & theIDsOfElements,
- const SMESH::AxisStruct & theAxis,
- CORBA::Double theAngleInRadians,
- CORBA::Long theNbOfSteps,
- CORBA::Double theTolerance,
- const bool theMakeGroups)
-{
- initData();
- TIDSortedElemSet inElements, copyElements;
- arrayToSet(theIDsOfElements, GetMeshDS(), inElements);
-
- TIDSortedElemSet* workElements = & inElements;
- TPreviewMesh tmpMesh( SMDSAbs_Face );
- SMESH_Mesh* mesh = 0;
- bool makeWalls=true;
- if ( myPreviewMode )
+ const SMDS_MeshElement* face = 0;
+ if ( theFace > 0 )
{
- SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
- tmpMesh.Copy( inElements, copyElements, select, avoid );
- mesh = &tmpMesh;
- workElements = & copyElements;
- //makeWalls = false;
+ face = getMeshDS()->FindElement( theFace );
+ if ( !face )
+ THROW_SALOME_CORBA_EXCEPTION("Inexistent face given", SALOME::BAD_PARAM);
+ if ( face->GetType() != SMDSAbs_Face )
+ THROW_SALOME_CORBA_EXCEPTION("Wrong element type", SALOME::BAD_PARAM);
}
else
{
- mesh = myMesh;
- }
+ // create theElementSearcher if needed
+ theSearchersDeleter.Set( myMesh, getPartIOR( the2Dgroup, SMESH::FACE ));
+ if ( !theElementSearcher )
+ {
+ if ( elements.empty() ) // search in the whole mesh
+ {
+ if ( myMesh->NbFaces() == 0 )
+ THROW_SALOME_CORBA_EXCEPTION("No faces in the mesh", SALOME::BAD_PARAM);
- gp_Ax1 Ax1 (gp_Pnt( theAxis.x, theAxis.y, theAxis.z ),
- gp_Vec( theAxis.vx, theAxis.vy, theAxis.vz ));
+ theElementSearcher = SMESH_MeshAlgos::GetElementSearcher( *getMeshDS() );
+ }
+ else
+ {
+ typedef SMDS_SetIterator<const SMDS_MeshElement*, TIDSortedElemSet::const_iterator > TIter;
+ SMDS_ElemIteratorPtr elemsIt( new TIter( elements.begin(), elements.end() ));
- ::SMESH_MeshEditor anEditor( mesh );
- ::SMESH_MeshEditor::PGroupIDs groupIds =
- anEditor.RotationSweep (*workElements, Ax1, theAngleInRadians,
- theNbOfSteps, theTolerance, theMakeGroups, makeWalls);
- storeResult(anEditor);
+ theElementSearcher = SMESH_MeshAlgos::GetElementSearcher( *getMeshDS(), elemsIt);
+ }
+ }
+ // find a face
+ gp_Pnt p( thePoint.x, thePoint.y, thePoint.z );
+ face = theElementSearcher->FindClosestTo( p, SMDSAbs_Face );
+
+ if ( !face )
+ THROW_SALOME_CORBA_EXCEPTION("No face found by point", SALOME::INTERNAL_ERROR );
+ if ( !elements.empty() && !elements.count( face ))
+ THROW_SALOME_CORBA_EXCEPTION("Found face is not in the group", SALOME::BAD_PARAM );
+ }
- return theMakeGroups ? getGroups(groupIds.get()) : 0;
-}
+ const SMESH::PointStruct * P = &theDirection.PS;
+ gp_Vec dirVec( P->x, P->y, P->z );
+ if ( dirVec.Magnitude() < std::numeric_limits< double >::min() )
+ THROW_SALOME_CORBA_EXCEPTION("Zero size vector", SALOME::BAD_PARAM);
-//=======================================================================
-//function : RotationSweep
-//purpose :
-//=======================================================================
+ int nbReori = getEditor().Reorient2D( elements, dirVec, face );
-void SMESH_MeshEditor_i::RotationSweep(const SMESH::long_array & theIDsOfElements,
- const SMESH::AxisStruct & theAxis,
- CORBA::Double theAngleInRadians,
- CORBA::Long theNbOfSteps,
- CORBA::Double theTolerance)
-{
- if ( !myPreviewMode ) {
- TPythonDump() << "axis = " << theAxis;
- TPythonDump() << this << ".RotationSweep( "
- << theIDsOfElements
- << ", axis, "
- << theAngleInRadians << ", "
- << theNbOfSteps << ", "
- << theTolerance << " )";
+ if ( nbReori ) {
+ declareMeshModified( /*isReComputeSafe=*/false );
}
- rotationSweep(theIDsOfElements,
- theAxis,
- theAngleInRadians,
- theNbOfSteps,
- theTolerance,
- false);
-}
+ TPythonDump() << this << ".Reorient2D( "
+ << the2Dgroup << ", "
+ << theDirection << ", "
+ << theFace << ", "
+ << thePoint << " )";
-//=======================================================================
-//function : RotationSweepMakeGroups
-//purpose :
-//=======================================================================
+ return nbReori;
-SMESH::ListOfGroups*
-SMESH_MeshEditor_i::RotationSweepMakeGroups(const SMESH::long_array& theIDsOfElements,
- const SMESH::AxisStruct& theAxis,
- CORBA::Double theAngleInRadians,
- CORBA::Long theNbOfSteps,
- CORBA::Double theTolerance)
-{
- if ( !myPreviewMode ) {
- TPythonDump() << "axis = " << theAxis;
- TPythonDump() << this << ".RotationSweepMakeGroups( "
- << theIDsOfElements
- << ", axis, "
- << theAngleInRadians << ", "
- << theNbOfSteps << ", "
- << theTolerance << " )";
- }
- return rotationSweep(theIDsOfElements,
- theAxis,
- theAngleInRadians,
- theNbOfSteps,
- theTolerance,
- true);
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
-//=======================================================================
-//function : RotationSweepObject
-//purpose :
-//=======================================================================
+//=============================================================================
+/*!
+ * \brief Fuse neighbour triangles into quadrangles.
+ */
+//=============================================================================
-void SMESH_MeshEditor_i::RotationSweepObject(SMESH::SMESH_IDSource_ptr theObject,
- const SMESH::AxisStruct & theAxis,
- CORBA::Double theAngleInRadians,
- CORBA::Long theNbOfSteps,
- CORBA::Double theTolerance)
+CORBA::Boolean SMESH_MeshEditor_i::TriToQuad (const SMESH::long_array & IDsOfElements,
+ SMESH::NumericalFunctor_ptr Criterion,
+ CORBA::Double MaxAngle)
+ throw (SALOME::SALOME_Exception)
{
- if ( !myPreviewMode ) {
- TPythonDump() << "axis = " << theAxis;
- TPythonDump() << this << ".RotationSweepObject( "
- << theObject
- << ", axis, "
- << theAngleInRadians << ", "
- << theNbOfSteps << ", "
- << theTolerance << " )";
- }
- SMESH::long_array_var anElementsId = theObject->GetIDs();
- rotationSweep(anElementsId,
- theAxis,
- theAngleInRadians,
- theNbOfSteps,
- theTolerance,
- false);
-}
+ SMESH_TRY;
+ initData();
-//=======================================================================
-//function : RotationSweepObjectMakeGroups
-//purpose :
-//=======================================================================
+ SMESHDS_Mesh* aMesh = getMeshDS();
+ TIDSortedElemSet faces;
+ arrayToSet(IDsOfElements, aMesh, faces, SMDSAbs_Face);
-SMESH::ListOfGroups*
-SMESH_MeshEditor_i::RotationSweepObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
- const SMESH::AxisStruct& theAxis,
- CORBA::Double theAngleInRadians,
- CORBA::Long theNbOfSteps,
- CORBA::Double theTolerance)
-{
- if ( !myPreviewMode ) {
- TPythonDump() << "axis = " << theAxis;
- TPythonDump() << this << ".RotationSweepObjectMakeGroups( "
- << theObject
- << ", axis, "
- << theAngleInRadians << ", "
- << theNbOfSteps << ", "
- << theTolerance << " )";
- }
- SMESH::long_array_var anElementsId = theObject->GetIDs();
- return rotationSweep(anElementsId,
- theAxis,
- theAngleInRadians,
- theNbOfSteps,
- theTolerance,
- true);
-}
+ SMESH::NumericalFunctor_i* aNumericalFunctor =
+ dynamic_cast<SMESH::NumericalFunctor_i*>( SMESH_Gen_i::GetServant( Criterion ).in() );
+ SMESH::Controls::NumericalFunctorPtr aCrit;
+ if ( !aNumericalFunctor )
+ aCrit.reset( new SMESH::Controls::MaxElementLength2D() );
+ else
+ aCrit = aNumericalFunctor->GetNumericalFunctor();
+ // Update Python script
+ TPythonDump() << "isDone = " << this << ".TriToQuad( "
+ << IDsOfElements << ", " << aNumericalFunctor << ", " << TVar( MaxAngle ) << " )";
-//=======================================================================
-//function : extrusionSweep
-//purpose :
-//=======================================================================
-SMESH::ListOfGroups*
-SMESH_MeshEditor_i::extrusionSweep(const SMESH::long_array & theIDsOfElements,
- const SMESH::DirStruct & theStepVector,
- CORBA::Long theNbOfSteps,
- const bool theMakeGroups,
- const SMDSAbs_ElementType theElementType)
+ bool stat = getEditor().TriToQuad( faces, aCrit, MaxAngle );
+
+ declareMeshModified( /*isReComputeSafe=*/!stat );
+ return stat;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//=============================================================================
+/*!
+ * \brief Fuse neighbour triangles into quadrangles.
+ */
+//=============================================================================
+
+CORBA::Boolean SMESH_MeshEditor_i::TriToQuadObject (SMESH::SMESH_IDSource_ptr theObject,
+ SMESH::NumericalFunctor_ptr Criterion,
+ CORBA::Double MaxAngle)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
- try {
-#ifdef NO_CAS_CATCH
- OCC_CATCH_SIGNALS;
-#endif
- TIDSortedElemSet elements;
- arrayToSet(theIDsOfElements, GetMeshDS(), elements, theElementType);
+ TPythonDump aTPythonDump; // suppress dump in TriToQuad()
- const SMESH::PointStruct * P = &theStepVector.PS;
- gp_Vec stepVec( P->x, P->y, P->z );
+ prepareIdSource( theObject );
+ SMESH::long_array_var anElementsId = theObject->GetIDs();
+ CORBA::Boolean isDone = TriToQuad(anElementsId, Criterion, MaxAngle);
- TElemOfElemListMap aHystory;
- ::SMESH_MeshEditor anEditor( myMesh );
- ::SMESH_MeshEditor::PGroupIDs groupIds =
- anEditor.ExtrusionSweep (elements, stepVec, theNbOfSteps, aHystory, theMakeGroups);
+ SMESH::NumericalFunctor_i* aNumericalFunctor =
+ SMESH::DownCast<SMESH::NumericalFunctor_i*>( Criterion );
- storeResult(anEditor);
+ // Update Python script
+ aTPythonDump << "isDone = " << this << ".TriToQuadObject("
+ << theObject << ", " << aNumericalFunctor << ", " << TVar( MaxAngle ) << " )";
- return theMakeGroups ? getGroups(groupIds.get()) : 0;
+ return isDone;
- } catch(Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- INFOS( "SMESH_MeshEditor_i::ExtrusionSweep fails - "<< aFail->GetMessageString() );
- }
+ SMESH_CATCH( SMESH::throwCorbaException );
return 0;
}
-//=======================================================================
-//function : ExtrusionSweep
-//purpose :
-//=======================================================================
+//=============================================================================
+/*!
+ * \brief Split quadrangles into triangles.
+ */
+//=============================================================================
-void SMESH_MeshEditor_i::ExtrusionSweep(const SMESH::long_array & theIDsOfElements,
- const SMESH::DirStruct & theStepVector,
- CORBA::Long theNbOfSteps)
+CORBA::Boolean SMESH_MeshEditor_i::QuadToTri (const SMESH::long_array & IDsOfElements,
+ SMESH::NumericalFunctor_ptr Criterion)
+ throw (SALOME::SALOME_Exception)
{
- extrusionSweep (theIDsOfElements, theStepVector, theNbOfSteps, false );
- if ( !myPreviewMode ) {
- TPythonDump() << "stepVector = " << theStepVector;
- TPythonDump() << this << ".ExtrusionSweep( "
- << theIDsOfElements << ", stepVector, " << theNbOfSteps << " )";
- }
-}
+ SMESH_TRY;
+ initData();
+ SMESHDS_Mesh* aMesh = getMeshDS();
+ TIDSortedElemSet faces;
+ arrayToSet(IDsOfElements, aMesh, faces, SMDSAbs_Face);
-//=======================================================================
-//function : ExtrusionSweepObject
-//purpose :
-//=======================================================================
+ SMESH::NumericalFunctor_i* aNumericalFunctor =
+ dynamic_cast<SMESH::NumericalFunctor_i*>( SMESH_Gen_i::GetServant( Criterion ).in() );
+ SMESH::Controls::NumericalFunctorPtr aCrit;
+ if ( !aNumericalFunctor )
+ aCrit.reset( new SMESH::Controls::AspectRatio() );
+ else
+ aCrit = aNumericalFunctor->GetNumericalFunctor();
-void SMESH_MeshEditor_i::ExtrusionSweepObject(SMESH::SMESH_IDSource_ptr theObject,
- const SMESH::DirStruct & theStepVector,
- CORBA::Long theNbOfSteps)
-{
- SMESH::long_array_var anElementsId = theObject->GetIDs();
- extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false );
- if ( !myPreviewMode ) {
- TPythonDump() << "stepVector = " << theStepVector;
- TPythonDump() << this << ".ExtrusionSweepObject( "
- << theObject << ", stepVector, " << theNbOfSteps << " )";
- }
-}
-//=======================================================================
-//function : ExtrusionSweepObject1D
-//purpose :
-//=======================================================================
+ // Update Python script
+ TPythonDump() << "isDone = " << this << ".QuadToTri( " << IDsOfElements << ", " << aNumericalFunctor << " )";
-void SMESH_MeshEditor_i::ExtrusionSweepObject1D(SMESH::SMESH_IDSource_ptr theObject,
- const SMESH::DirStruct & theStepVector,
- CORBA::Long theNbOfSteps)
-{
- SMESH::long_array_var anElementsId = theObject->GetIDs();
- extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false, SMDSAbs_Edge );
- if ( !myPreviewMode ) {
- TPythonDump() << "stepVector = " << theStepVector;
- TPythonDump() << this << ".ExtrusionSweepObject1D( "
- << theObject << ", stepVector, " << theNbOfSteps << " )";
- }
-}
+ CORBA::Boolean stat = getEditor().QuadToTri( faces, aCrit );
-//=======================================================================
-//function : ExtrusionSweepObject2D
-//purpose :
-//=======================================================================
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return stat;
-void SMESH_MeshEditor_i::ExtrusionSweepObject2D(SMESH::SMESH_IDSource_ptr theObject,
- const SMESH::DirStruct & theStepVector,
- CORBA::Long theNbOfSteps)
-{
- SMESH::long_array_var anElementsId = theObject->GetIDs();
- extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false, SMDSAbs_Face );
- if ( !myPreviewMode ) {
- TPythonDump() << "stepVector = " << theStepVector;
- TPythonDump() << this << ".ExtrusionSweepObject2D( "
- << theObject << ", stepVector, " << theNbOfSteps << " )";
- }
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
-//=======================================================================
-//function : ExtrusionSweepMakeGroups
-//purpose :
-//=======================================================================
+//=============================================================================
+/*!
+ * \brief Split quadrangles into triangles.
+ */
+//=============================================================================
-SMESH::ListOfGroups*
-SMESH_MeshEditor_i::ExtrusionSweepMakeGroups(const SMESH::long_array& theIDsOfElements,
- const SMESH::DirStruct& theStepVector,
- CORBA::Long theNbOfSteps)
+CORBA::Boolean SMESH_MeshEditor_i::QuadToTriObject (SMESH::SMESH_IDSource_ptr theObject,
+ SMESH::NumericalFunctor_ptr Criterion)
+ throw (SALOME::SALOME_Exception)
{
- if ( !myPreviewMode ) {
- TPythonDump() << "stepVector = " << theStepVector;
- TPythonDump() << this << ".ExtrusionSweepMakeGroups( "
- << theIDsOfElements << ", stepVector, " << theNbOfSteps << " )";
- }
- return extrusionSweep (theIDsOfElements, theStepVector, theNbOfSteps, true );
-}
-//=======================================================================
-//function : ExtrusionSweepObjectMakeGroups
-//purpose :
-//=======================================================================
+ SMESH_TRY;
+ initData();
-SMESH::ListOfGroups*
-SMESH_MeshEditor_i::ExtrusionSweepObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
- const SMESH::DirStruct& theStepVector,
- CORBA::Long theNbOfSteps)
-{
- if ( !myPreviewMode ) {
- TPythonDump() << "stepVector = " << theStepVector;
- TPythonDump() << this << ".ExtrusionSweepObjectMakeGroups( "
- << theObject << ", stepVector, " << theNbOfSteps << " )";
- }
+ TPythonDump aTPythonDump; // suppress dump in QuadToTri()
+
+ prepareIdSource( theObject );
SMESH::long_array_var anElementsId = theObject->GetIDs();
- return extrusionSweep (anElementsId, theStepVector, theNbOfSteps, true );
-}
+ CORBA::Boolean isDone = QuadToTri(anElementsId, Criterion);
-//=======================================================================
-//function : ExtrusionSweepObject1DMakeGroups
-//purpose :
-//=======================================================================
+ SMESH::NumericalFunctor_i* aNumericalFunctor =
+ SMESH::DownCast<SMESH::NumericalFunctor_i*>( Criterion );
-SMESH::ListOfGroups*
-SMESH_MeshEditor_i::ExtrusionSweepObject1DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
- const SMESH::DirStruct& theStepVector,
- CORBA::Long theNbOfSteps)
-{
- if ( !myPreviewMode ) {
- TPythonDump() << "stepVector = " << theStepVector;
- TPythonDump() << this << ".ExtrusionSweepObject1DMakeGroups( "
- << theObject << ", stepVector, " << theNbOfSteps << " )";
- }
- SMESH::long_array_var anElementsId = theObject->GetIDs();
- return extrusionSweep (anElementsId, theStepVector, theNbOfSteps, true, SMDSAbs_Edge );
-}
+ // Update Python script
+ aTPythonDump << "isDone = " << this << ".QuadToTriObject( " << theObject << ", " << aNumericalFunctor << " )";
-//=======================================================================
-//function : ExtrusionSweepObject2DMakeGroups
-//purpose :
-//=======================================================================
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return isDone;
-SMESH::ListOfGroups*
-SMESH_MeshEditor_i::ExtrusionSweepObject2DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
- const SMESH::DirStruct& theStepVector,
- CORBA::Long theNbOfSteps)
-{
- if ( !myPreviewMode ) {
- TPythonDump() << "stepVector = " << theStepVector;
- TPythonDump() << this << ".ExtrusionSweepObject2DMakeGroups( "
- << theObject << ", stepVector, " << theNbOfSteps << " )";
- }
- SMESH::long_array_var anElementsId = theObject->GetIDs();
- return extrusionSweep (anElementsId, theStepVector, theNbOfSteps, true, SMDSAbs_Face );
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
+//================================================================================
+/*!
+ * \brief Split each of quadrangles into 4 triangles.
+ * \param [in] theObject - theQuads Container of quadrangles to split.
+ */
+//================================================================================
-//=======================================================================
-//function : advancedExtrusion
-//purpose :
-//=======================================================================
-
-SMESH::ListOfGroups*
-SMESH_MeshEditor_i::advancedExtrusion(const SMESH::long_array & theIDsOfElements,
- const SMESH::DirStruct & theStepVector,
- CORBA::Long theNbOfSteps,
- CORBA::Long theExtrFlags,
- CORBA::Double theSewTolerance,
- const bool theMakeGroups)
+void SMESH_MeshEditor_i::QuadTo4Tri (SMESH::SMESH_IDSource_ptr theObject)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
- TIDSortedElemSet elements;
- arrayToSet(theIDsOfElements, GetMeshDS(), elements);
-
- const SMESH::PointStruct * P = &theStepVector.PS;
- gp_Vec stepVec( P->x, P->y, P->z );
+ TIDSortedElemSet faces;
+ prepareIdSource( theObject );
+ if ( !idSourceToSet( theObject, getMeshDS(), faces, SMDSAbs_Face, /*emptyIfIsMesh=*/true ) &&
+ faces.empty() )
+ THROW_SALOME_CORBA_EXCEPTION("No faces given", SALOME::BAD_PARAM);
- ::SMESH_MeshEditor anEditor( myMesh );
- TElemOfElemListMap aHystory;
- ::SMESH_MeshEditor::PGroupIDs groupIds =
- anEditor.ExtrusionSweep (elements, stepVec, theNbOfSteps, aHystory,
- theMakeGroups, theExtrFlags, theSewTolerance);
- storeResult(anEditor);
+ getEditor().QuadTo4Tri( faces );
+ TPythonDump() << this << ".QuadTo4Tri( " << theObject << " )";
- return theMakeGroups ? getGroups(groupIds.get()) : 0;
+ SMESH_CATCH( SMESH::throwCorbaException );
}
-//=======================================================================
-//function : AdvancedExtrusion
-//purpose :
-//=======================================================================
+//=============================================================================
+/*!
+ * \brief Split quadrangles into triangles.
+ */
+//=============================================================================
-void SMESH_MeshEditor_i::AdvancedExtrusion(const SMESH::long_array & theIDsOfElements,
- const SMESH::DirStruct & theStepVector,
- CORBA::Long theNbOfSteps,
- CORBA::Long theExtrFlags,
- CORBA::Double theSewTolerance)
+CORBA::Boolean SMESH_MeshEditor_i::SplitQuad (const SMESH::long_array & IDsOfElements,
+ CORBA::Boolean Diag13)
+ throw (SALOME::SALOME_Exception)
{
- if ( !myPreviewMode ) {
- TPythonDump() << "stepVector = " << theStepVector;
- TPythonDump() << this << ".AdvancedExtrusion("
- << theIDsOfElements
- << ", stepVector, "
- << theNbOfSteps << ","
- << theExtrFlags << ", "
- << theSewTolerance << " )";
- }
- advancedExtrusion( theIDsOfElements,
- theStepVector,
- theNbOfSteps,
- theExtrFlags,
- theSewTolerance,
- false);
-}
+ SMESH_TRY;
+ initData();
-//=======================================================================
-//function : AdvancedExtrusionMakeGroups
-//purpose :
-//=======================================================================
+ SMESHDS_Mesh* aMesh = getMeshDS();
+ TIDSortedElemSet faces;
+ arrayToSet(IDsOfElements, aMesh, faces, SMDSAbs_Face);
-SMESH::ListOfGroups*
-SMESH_MeshEditor_i::AdvancedExtrusionMakeGroups(const SMESH::long_array& theIDsOfElements,
- const SMESH::DirStruct& theStepVector,
- CORBA::Long theNbOfSteps,
- CORBA::Long theExtrFlags,
- CORBA::Double theSewTolerance)
-{
- if ( !myPreviewMode ) {
- TPythonDump() << "stepVector = " << theStepVector;
- TPythonDump() << this << ".AdvancedExtrusionMakeGroups("
- << theIDsOfElements
- << ", stepVector, "
- << theNbOfSteps << ","
- << theExtrFlags << ", "
- << theSewTolerance << " )";
- }
- return advancedExtrusion( theIDsOfElements,
- theStepVector,
- theNbOfSteps,
- theExtrFlags,
- theSewTolerance,
- true);
-}
+ // Update Python script
+ TPythonDump() << "isDone = " << this << ".SplitQuad( "
+ << IDsOfElements << ", " << Diag13 << " )";
+ CORBA::Boolean stat = getEditor().QuadToTri( faces, Diag13 );
-//================================================================================
+ declareMeshModified( /*isReComputeSafe=*/ !stat );
+ return stat;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//=============================================================================
/*!
- * \brief Convert extrusion error to IDL enum
+ * \brief Split quadrangles into triangles.
*/
-//================================================================================
-
-#define RETCASE(enm) case ::SMESH_MeshEditor::enm: return SMESH::SMESH_MeshEditor::enm;
+//=============================================================================
-static SMESH::SMESH_MeshEditor::Extrusion_Error convExtrError( const::SMESH_MeshEditor::Extrusion_Error e )
+CORBA::Boolean SMESH_MeshEditor_i::SplitQuadObject (SMESH::SMESH_IDSource_ptr theObject,
+ CORBA::Boolean Diag13)
+ throw (SALOME::SALOME_Exception)
{
- switch ( e ) {
- RETCASE( EXTR_OK );
- RETCASE( EXTR_NO_ELEMENTS );
- RETCASE( EXTR_PATH_NOT_EDGE );
- RETCASE( EXTR_BAD_PATH_SHAPE );
- RETCASE( EXTR_BAD_STARTING_NODE );
- RETCASE( EXTR_BAD_ANGLES_NUMBER );
- RETCASE( EXTR_CANT_GET_TANGENT );
- }
- return SMESH::SMESH_MeshEditor::EXTR_OK;
+ SMESH_TRY;
+ initData();
+
+ TPythonDump aTPythonDump; // suppress dump in SplitQuad()
+
+ prepareIdSource( theObject );
+ SMESH::long_array_var anElementsId = theObject->GetIDs();
+ CORBA::Boolean isDone = SplitQuad(anElementsId, Diag13);
+
+ // Update Python script
+ aTPythonDump << "isDone = " << this << ".SplitQuadObject( "
+ << theObject << ", " << Diag13 << " )";
+
+ declareMeshModified( /*isReComputeSafe=*/!isDone );
+ return isDone;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
-//=======================================================================
-//function : extrusionAlongPath
-//purpose :
-//=======================================================================
+//=============================================================================
+/*!
+ * Find better splitting of the given quadrangle.
+ * \param IDOfQuad ID of the quadrangle to be splitted.
+ * \param Criterion A criterion to choose a diagonal for splitting.
+ * \return 1 if 1-3 diagonal is better, 2 if 2-4
+ * diagonal is better, 0 if error occurs.
+ */
+//=============================================================================
-SMESH::ListOfGroups*
-SMESH_MeshEditor_i::extrusionAlongPath(const SMESH::long_array & theIDsOfElements,
- SMESH::SMESH_Mesh_ptr thePathMesh,
- GEOM::GEOM_Object_ptr thePathShape,
- CORBA::Long theNodeStart,
- CORBA::Boolean theHasAngles,
- const SMESH::double_array & theAngles,
- CORBA::Boolean theHasRefPoint,
- const SMESH::PointStruct & theRefPoint,
- const bool theMakeGroups,
- SMESH::SMESH_MeshEditor::Extrusion_Error & theError)
+CORBA::Long SMESH_MeshEditor_i::BestSplit (CORBA::Long IDOfQuad,
+ SMESH::NumericalFunctor_ptr Criterion)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
- if ( thePathMesh->_is_nil() || thePathShape->_is_nil() ) {
- theError = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
- return 0;
- }
- SMESH_Mesh_i* aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( thePathMesh );
-
- TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( thePathShape );
- SMESH_subMesh* aSubMesh = aMeshImp->GetImpl().GetSubMesh( aShape );
+ const SMDS_MeshElement* quad = getMeshDS()->FindElement(IDOfQuad);
+ if (quad && quad->GetType() == SMDSAbs_Face && quad->NbNodes() == 4)
+ {
+ SMESH::NumericalFunctor_i* aNumericalFunctor =
+ dynamic_cast<SMESH::NumericalFunctor_i*>(SMESH_Gen_i::GetServant(Criterion).in());
+ SMESH::Controls::NumericalFunctorPtr aCrit;
+ if (aNumericalFunctor)
+ aCrit = aNumericalFunctor->GetNumericalFunctor();
+ else
+ aCrit.reset(new SMESH::Controls::AspectRatio());
- if ( !aSubMesh || !aSubMesh->GetSubMeshDS()) {
- theError = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
- return 0;
+ int id = getEditor().BestSplit(quad, aCrit);
+ declareMeshModified( /*isReComputeSafe=*/ id < 1 );
}
- SMDS_MeshNode* nodeStart = (SMDS_MeshNode*)aMeshImp->GetImpl().GetMeshDS()->FindNode(theNodeStart);
- if ( !nodeStart ) {
- theError = SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE;
- return 0;
- }
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
- TIDSortedElemSet elements;
- arrayToSet(theIDsOfElements, GetMeshDS(), elements);
+//================================================================================
+/*!
+ * \brief Split volumic elements into tetrahedrons
+ */
+//================================================================================
- list<double> angles;
- for (int i = 0; i < theAngles.length(); i++) {
- angles.push_back( theAngles[i] );
- }
+void SMESH_MeshEditor_i::SplitVolumesIntoTetra (SMESH::SMESH_IDSource_ptr elems,
+ CORBA::Short methodFlags)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ initData();
- gp_Pnt refPnt( theRefPoint.x, theRefPoint.y, theRefPoint.z );
+ prepareIdSource( elems );
+ SMESH::long_array_var anElementsId = elems->GetIDs();
+ TIDSortedElemSet elemSet;
+ arrayToSet( anElementsId, getMeshDS(), elemSet, SMDSAbs_Volume );
- int nbOldGroups = myMesh->NbGroup();
+ getEditor().SplitVolumesIntoTetra( elemSet, int( methodFlags ));
+ declareMeshModified( /*isReComputeSafe=*/true ); // it does not influence Compute()
- ::SMESH_MeshEditor anEditor( myMesh );
- ::SMESH_MeshEditor::Extrusion_Error error =
- anEditor.ExtrusionAlongTrack( elements, aSubMesh, nodeStart,
- theHasAngles, angles,
- theHasRefPoint, refPnt, theMakeGroups );
- storeResult(anEditor);
- theError = convExtrError( error );
+ TPythonDump() << this << ".SplitVolumesIntoTetra( "
+ << elems << ", " << methodFlags << " )";
- if ( theMakeGroups ) {
- list<int> groupIDs = myMesh->GetGroupIds();
- list<int>::iterator newBegin = groupIDs.begin();
- std::advance( newBegin, nbOldGroups ); // skip old groups
- groupIDs.erase( groupIDs.begin(), newBegin );
- return getGroups( & groupIDs );
- }
- return 0;
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//=======================================================================
-//function : ExtrusionAlongPath
+//function : Smooth
//purpose :
//=======================================================================
-SMESH::SMESH_MeshEditor::Extrusion_Error
- SMESH_MeshEditor_i::ExtrusionAlongPath(const SMESH::long_array & theIDsOfElements,
- SMESH::SMESH_Mesh_ptr thePathMesh,
- GEOM::GEOM_Object_ptr thePathShape,
- CORBA::Long theNodeStart,
- CORBA::Boolean theHasAngles,
- const SMESH::double_array & theAngles,
- CORBA::Boolean theHasRefPoint,
- const SMESH::PointStruct & theRefPoint)
-{
- if ( !myPreviewMode ) {
- TPythonDump() << "rotAngles = " << theAngles;
-
- if ( theHasRefPoint )
- TPythonDump() << "refPoint = SMESH.PointStruct( "
- << theRefPoint.x << ", "
- << theRefPoint.y << ", "
- << theRefPoint.z << " )";
- else
- TPythonDump() << "refPoint = SMESH.PointStruct( 0,0,0 )";
-
- TPythonDump() << "error = " << this << ".ExtrusionAlongPath( "
- << theIDsOfElements << ", "
- << thePathMesh << ", "
- << thePathShape << ", "
- << theNodeStart << ", "
- << theHasAngles << ", "
- << "rotAngles" << ", "
- << theHasRefPoint << ", refPoint )";
- }
- SMESH::SMESH_MeshEditor::Extrusion_Error anError;
- extrusionAlongPath( theIDsOfElements,
- thePathMesh,
- thePathShape,
- theNodeStart,
- theHasAngles,
- theAngles,
- theHasRefPoint,
- theRefPoint,
- false,
- anError);
- return anError;
+CORBA::Boolean
+SMESH_MeshEditor_i::Smooth(const SMESH::long_array & IDsOfElements,
+ const SMESH::long_array & IDsOfFixedNodes,
+ CORBA::Long MaxNbOfIterations,
+ CORBA::Double MaxAspectRatio,
+ SMESH::SMESH_MeshEditor::Smooth_Method Method)
+ throw (SALOME::SALOME_Exception)
+{
+ return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
+ MaxAspectRatio, Method, false );
}
+
//=======================================================================
-//function : ExtrusionAlongPathObject
+//function : SmoothParametric
//purpose :
//=======================================================================
-SMESH::SMESH_MeshEditor::Extrusion_Error
-SMESH_MeshEditor_i::ExtrusionAlongPathObject(SMESH::SMESH_IDSource_ptr theObject,
- SMESH::SMESH_Mesh_ptr thePathMesh,
- GEOM::GEOM_Object_ptr thePathShape,
- CORBA::Long theNodeStart,
- CORBA::Boolean theHasAngles,
- const SMESH::double_array & theAngles,
- CORBA::Boolean theHasRefPoint,
- const SMESH::PointStruct & theRefPoint)
+CORBA::Boolean
+SMESH_MeshEditor_i::SmoothParametric(const SMESH::long_array & IDsOfElements,
+ const SMESH::long_array & IDsOfFixedNodes,
+ CORBA::Long MaxNbOfIterations,
+ CORBA::Double MaxAspectRatio,
+ SMESH::SMESH_MeshEditor::Smooth_Method Method)
+ throw (SALOME::SALOME_Exception)
{
- if ( !myPreviewMode ) {
- TPythonDump() << "rotAngles = " << theAngles;
+ return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
+ MaxAspectRatio, Method, true );
+}
- if ( theHasRefPoint )
- TPythonDump() << "refPoint = SMESH.PointStruct( "
- << theRefPoint.x << ", "
- << theRefPoint.y << ", "
- << theRefPoint.z << " )";
- else
- TPythonDump() << "refPoint = SMESH.PointStruct( 0,0,0 )";
- TPythonDump() << "error = " << this << ".ExtrusionAlongPathObject( "
- << theObject << ", "
- << thePathMesh << ", "
- << thePathShape << ", "
- << theNodeStart << ", "
- << theHasAngles << ", "
- << "rotAngles" << ", "
- << theHasRefPoint << ", refPoint )";
- }
- SMESH::SMESH_MeshEditor::Extrusion_Error anError;
+//=======================================================================
+//function : SmoothObject
+//purpose :
+//=======================================================================
+
+CORBA::Boolean
+SMESH_MeshEditor_i::SmoothObject(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::long_array & IDsOfFixedNodes,
+ CORBA::Long MaxNbOfIterations,
+ CORBA::Double MaxAspectRatio,
+ SMESH::SMESH_MeshEditor::Smooth_Method Method)
+ throw (SALOME::SALOME_Exception)
+{
+ return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
+ MaxAspectRatio, Method, false);
+}
+
+
+//=======================================================================
+//function : SmoothParametricObject
+//purpose :
+//=======================================================================
+
+CORBA::Boolean
+SMESH_MeshEditor_i::SmoothParametricObject(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::long_array & IDsOfFixedNodes,
+ CORBA::Long MaxNbOfIterations,
+ CORBA::Double MaxAspectRatio,
+ SMESH::SMESH_MeshEditor::Smooth_Method Method)
+ throw (SALOME::SALOME_Exception)
+{
+ return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
+ MaxAspectRatio, Method, true);
+}
+
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+CORBA::Boolean
+SMESH_MeshEditor_i::smooth(const SMESH::long_array & IDsOfElements,
+ const SMESH::long_array & IDsOfFixedNodes,
+ CORBA::Long MaxNbOfIterations,
+ CORBA::Double MaxAspectRatio,
+ SMESH::SMESH_MeshEditor::Smooth_Method Method,
+ bool IsParametric)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ initData();
+
+ SMESHDS_Mesh* aMesh = getMeshDS();
+
+ TIDSortedElemSet elements;
+ arrayToSet(IDsOfElements, aMesh, elements, SMDSAbs_Face);
+
+ set<const SMDS_MeshNode*> fixedNodes;
+ for (int i = 0; i < IDsOfFixedNodes.length(); i++) {
+ CORBA::Long index = IDsOfFixedNodes[i];
+ const SMDS_MeshNode * node = aMesh->FindNode(index);
+ if ( node )
+ fixedNodes.insert( node );
+ }
+ ::SMESH_MeshEditor::SmoothMethod method = ::SMESH_MeshEditor::LAPLACIAN;
+ if ( Method != SMESH::SMESH_MeshEditor::LAPLACIAN_SMOOTH )
+ method = ::SMESH_MeshEditor::CENTROIDAL;
+
+ getEditor().Smooth(elements, fixedNodes, method,
+ MaxNbOfIterations, MaxAspectRatio, IsParametric );
+
+ declareMeshModified( /*isReComputeSafe=*/true ); // does not prevent re-compute
+
+ // Update Python script
+ TPythonDump() << "isDone = " << this << "."
+ << (IsParametric ? "SmoothParametric( " : "Smooth( ")
+ << IDsOfElements << ", " << IDsOfFixedNodes << ", "
+ << TVar( MaxNbOfIterations ) << ", " << TVar( MaxAspectRatio ) << ", "
+ << "SMESH.SMESH_MeshEditor."
+ << ( Method == SMESH::SMESH_MeshEditor::CENTROIDAL_SMOOTH ?
+ "CENTROIDAL_SMOOTH )" : "LAPLACIAN_SMOOTH )");
+
+ return true;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+CORBA::Boolean
+SMESH_MeshEditor_i::smoothObject(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::long_array & IDsOfFixedNodes,
+ CORBA::Long MaxNbOfIterations,
+ CORBA::Double MaxAspectRatio,
+ SMESH::SMESH_MeshEditor::Smooth_Method Method,
+ bool IsParametric)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ initData();
+
+ TPythonDump aTPythonDump; // suppress dump in smooth()
+
+ prepareIdSource( theObject );
SMESH::long_array_var anElementsId = theObject->GetIDs();
- extrusionAlongPath( anElementsId,
- thePathMesh,
- thePathShape,
- theNodeStart,
- theHasAngles,
- theAngles,
- theHasRefPoint,
- theRefPoint,
- false,
- anError);
- return anError;
+ CORBA::Boolean isDone = smooth (anElementsId, IDsOfFixedNodes, MaxNbOfIterations,
+ MaxAspectRatio, Method, IsParametric);
+
+ // Update Python script
+ aTPythonDump << "isDone = " << this << "."
+ << (IsParametric ? "SmoothParametricObject( " : "SmoothObject( ")
+ << theObject << ", " << IDsOfFixedNodes << ", "
+ << TVar( MaxNbOfIterations ) << ", " << TVar( MaxAspectRatio ) << ", "
+ << "SMESH.SMESH_MeshEditor."
+ << ( Method == SMESH::SMESH_MeshEditor::CENTROIDAL_SMOOTH ?
+ "CENTROIDAL_SMOOTH )" : "LAPLACIAN_SMOOTH )");
+
+ return isDone;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+void SMESH_MeshEditor_i::RenumberNodes()
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ // Update Python script
+ TPythonDump() << this << ".RenumberNodes()";
+
+ getMeshDS()->Renumber( true );
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+void SMESH_MeshEditor_i::RenumberElements()
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ // Update Python script
+ TPythonDump() << this << ".RenumberElements()";
+
+ getMeshDS()->Renumber( false );
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+}
+
+//=======================================================================
+/*!
+ * \brief Return groups by their IDs
+ */
+//=======================================================================
+
+SMESH::ListOfGroups* SMESH_MeshEditor_i::getGroups(const std::list<int>* groupIDs)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ if ( !groupIDs )
+ return 0;
+ myMesh_i->CreateGroupServants();
+ return myMesh_i->GetGroups( *groupIDs );
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//=======================================================================
+//function : rotationSweep
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::rotationSweep(const SMESH::long_array & theIDsOfElements,
+ const SMESH::AxisStruct & theAxis,
+ CORBA::Double theAngleInRadians,
+ CORBA::Long theNbOfSteps,
+ CORBA::Double theTolerance,
+ const bool theMakeGroups,
+ const SMDSAbs_ElementType theElementType)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ initData();
+
+ TIDSortedElemSet inElements, copyElements;
+ arrayToSet(theIDsOfElements, getMeshDS(), inElements, theElementType);
+
+ TIDSortedElemSet* workElements = & inElements;
+ bool makeWalls=true;
+ if ( myIsPreviewMode )
+ {
+ SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
+ getPreviewMesh( SMDSAbs_Face )->Copy( inElements, copyElements, select, avoid );
+ workElements = & copyElements;
+ //makeWalls = false;
+ }
+
+ gp_Ax1 Ax1 (gp_Pnt( theAxis.x, theAxis.y, theAxis.z ),
+ gp_Vec( theAxis.vx, theAxis.vy, theAxis.vz ));
+
+ ::SMESH_MeshEditor::PGroupIDs groupIds =
+ getEditor().RotationSweep (*workElements, Ax1, theAngleInRadians,
+ theNbOfSteps, theTolerance, theMakeGroups, makeWalls);
+
+ declareMeshModified( /*isReComputeSafe=*/true ); // does not influence Compute()
+
+ return theMakeGroups ? getGroups(groupIds.get()) : 0;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//=======================================================================
+//function : RotationSweep
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::RotationSweep(const SMESH::long_array & theIDsOfElements,
+ const SMESH::AxisStruct & theAxis,
+ CORBA::Double theAngleInRadians,
+ CORBA::Long theNbOfSteps,
+ CORBA::Double theTolerance)
+ throw (SALOME::SALOME_Exception)
+{
+ if ( !myIsPreviewMode ) {
+ TPythonDump() << this << ".RotationSweep( "
+ << theIDsOfElements << ", "
+ << theAxis << ", "
+ << TVar( theAngleInRadians ) << ", "
+ << TVar( theNbOfSteps ) << ", "
+ << TVar( theTolerance ) << " )";
+ }
+ rotationSweep(theIDsOfElements,
+ theAxis,
+ theAngleInRadians,
+ theNbOfSteps,
+ theTolerance,
+ false);
+}
+
+//=======================================================================
+//function : RotationSweepMakeGroups
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::RotationSweepMakeGroups(const SMESH::long_array& theIDsOfElements,
+ const SMESH::AxisStruct& theAxis,
+ CORBA::Double theAngleInRadians,
+ CORBA::Long theNbOfSteps,
+ CORBA::Double theTolerance)
+ throw (SALOME::SALOME_Exception)
+{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
+ SMESH::ListOfGroups *aGroups = rotationSweep(theIDsOfElements,
+ theAxis,
+ theAngleInRadians,
+ theNbOfSteps,
+ theTolerance,
+ true);
+ if (!myIsPreviewMode) {
+ dumpGroupsList(aPythonDump, aGroups);
+ aPythonDump << this << ".RotationSweepMakeGroups( "
+ << theIDsOfElements << ", "
+ << theAxis << ", "
+ << TVar( theAngleInRadians ) << ", "
+ << TVar( theNbOfSteps ) << ", "
+ << TVar( theTolerance ) << " )";
+ }
+ return aGroups;
+}
+
+//=======================================================================
+//function : RotationSweepObject
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::RotationSweepObject(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::AxisStruct & theAxis,
+ CORBA::Double theAngleInRadians,
+ CORBA::Long theNbOfSteps,
+ CORBA::Double theTolerance)
+ throw (SALOME::SALOME_Exception)
+{
+ if ( !myIsPreviewMode ) {
+ TPythonDump() << this << ".RotationSweepObject( "
+ << theObject << ", "
+ << theAxis << ", "
+ << theAngleInRadians << ", "
+ << theNbOfSteps << ", "
+ << theTolerance << " )";
+ }
+ prepareIdSource( theObject );
+ SMESH::long_array_var anElementsId = theObject->GetIDs();
+ rotationSweep(anElementsId,
+ theAxis,
+ theAngleInRadians,
+ theNbOfSteps,
+ theTolerance,
+ false);
+}
+
+//=======================================================================
+//function : RotationSweepObject1D
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::RotationSweepObject1D(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::AxisStruct & theAxis,
+ CORBA::Double theAngleInRadians,
+ CORBA::Long theNbOfSteps,
+ CORBA::Double theTolerance)
+ throw (SALOME::SALOME_Exception)
+{
+ if ( !myIsPreviewMode ) {
+ TPythonDump() << this << ".RotationSweepObject1D( "
+ << theObject << ", "
+ << theAxis << ", "
+ << TVar( theAngleInRadians ) << ", "
+ << TVar( theNbOfSteps ) << ", "
+ << TVar( theTolerance ) << " )";
+ }
+ prepareIdSource( theObject );
+ SMESH::long_array_var anElementsId = theObject->GetIDs();
+ rotationSweep(anElementsId,
+ theAxis,
+ theAngleInRadians,
+ theNbOfSteps,
+ theTolerance,
+ false,
+ SMDSAbs_Edge);
+}
+
+//=======================================================================
+//function : RotationSweepObject2D
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::RotationSweepObject2D(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::AxisStruct & theAxis,
+ CORBA::Double theAngleInRadians,
+ CORBA::Long theNbOfSteps,
+ CORBA::Double theTolerance)
+ throw (SALOME::SALOME_Exception)
+{
+ if ( !myIsPreviewMode ) {
+ TPythonDump() << this << ".RotationSweepObject2D( "
+ << theObject << ", "
+ << theAxis << ", "
+ << TVar( theAngleInRadians ) << ", "
+ << TVar( theNbOfSteps ) << ", "
+ << TVar( theTolerance ) << " )";
+ }
+ prepareIdSource( theObject );
+ SMESH::long_array_var anElementsId = theObject->GetIDs();
+ rotationSweep(anElementsId,
+ theAxis,
+ theAngleInRadians,
+ theNbOfSteps,
+ theTolerance,
+ false,
+ SMDSAbs_Face);
+}
+
+//=======================================================================
+//function : RotationSweepObjectMakeGroups
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::RotationSweepObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::AxisStruct& theAxis,
+ CORBA::Double theAngleInRadians,
+ CORBA::Long theNbOfSteps,
+ CORBA::Double theTolerance)
+ throw (SALOME::SALOME_Exception)
+{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
+ prepareIdSource( theObject );
+ SMESH::long_array_var anElementsId = theObject->GetIDs();
+ SMESH::ListOfGroups *aGroups = rotationSweep(anElementsId,
+ theAxis,
+ theAngleInRadians,
+ theNbOfSteps,
+ theTolerance,
+ true);
+ if (!myIsPreviewMode) {
+ dumpGroupsList(aPythonDump, aGroups);
+ aPythonDump << this << ".RotationSweepObjectMakeGroups( "
+ << theObject << ", "
+ << theAxis << ", "
+ << theAngleInRadians << ", "
+ << theNbOfSteps << ", "
+ << theTolerance << " )";
+ }
+ return aGroups;
+}
+
+//=======================================================================
+//function : RotationSweepObject1DMakeGroups
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::RotationSweepObject1DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::AxisStruct& theAxis,
+ CORBA::Double theAngleInRadians,
+ CORBA::Long theNbOfSteps,
+ CORBA::Double theTolerance)
+ throw (SALOME::SALOME_Exception)
+{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
+ prepareIdSource( theObject );
+ SMESH::long_array_var anElementsId = theObject->GetIDs();
+ SMESH::ListOfGroups *aGroups = rotationSweep(anElementsId,
+ theAxis,
+ theAngleInRadians,
+ theNbOfSteps,
+ theTolerance,
+ true,
+ SMDSAbs_Edge);
+ if (!myIsPreviewMode) {
+ dumpGroupsList(aPythonDump, aGroups);
+ aPythonDump << this << ".RotationSweepObject1DMakeGroups( "
+ << theObject << ", "
+ << theAxis << ", "
+ << TVar( theAngleInRadians ) << ", "
+ << TVar( theNbOfSteps ) << ", "
+ << TVar( theTolerance ) << " )";
+ }
+ return aGroups;
+}
+
+//=======================================================================
+//function : RotationSweepObject2DMakeGroups
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::RotationSweepObject2DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::AxisStruct& theAxis,
+ CORBA::Double theAngleInRadians,
+ CORBA::Long theNbOfSteps,
+ CORBA::Double theTolerance)
+ throw (SALOME::SALOME_Exception)
+{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
+ prepareIdSource( theObject );
+ SMESH::long_array_var anElementsId = theObject->GetIDs();
+ SMESH::ListOfGroups *aGroups = rotationSweep(anElementsId,
+ theAxis,
+ theAngleInRadians,
+ theNbOfSteps,
+ theTolerance,
+ true,
+ SMDSAbs_Face);
+ if (!myIsPreviewMode) {
+ dumpGroupsList(aPythonDump, aGroups);
+ aPythonDump << this << ".RotationSweepObject2DMakeGroups( "
+ << theObject << ", "
+ << theAxis << ", "
+ << TVar( theAngleInRadians ) << ", "
+ << TVar( theNbOfSteps ) << ", "
+ << TVar( theTolerance ) << " )";
+ }
+ return aGroups;
+}
+
+
+//=======================================================================
+//function : extrusionSweep
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::extrusionSweep(const SMESH::long_array & theIDsOfElements,
+ const SMESH::DirStruct & theStepVector,
+ CORBA::Long theNbOfSteps,
+ bool theMakeGroups,
+ const SMDSAbs_ElementType theElementType)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ initData();
+
+ 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;
+
+ SMDSAbs_ElementType aType = SMDSAbs_Face;
+ if (theElementType == SMDSAbs_Node)
+ {
+ aType = SMDSAbs_Edge;
+ }
+ if ( myIsPreviewMode ) {
+ SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
+ getPreviewMesh( aType )->Copy( elements, copyElements, select, avoid );
+ workElements = & copyElements;
+ theMakeGroups = false;
+ }
+
+ TElemOfElemListMap aHystory;
+ ::SMESH_MeshEditor::PGroupIDs groupIds =
+ getEditor().ExtrusionSweep (*workElements, stepVec, theNbOfSteps, aHystory, theMakeGroups);
+
+ declareMeshModified( /*isReComputeSafe=*/true ); // does not influence Compute()
+
+ return theMakeGroups ? getGroups(groupIds.get()) : 0;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//=======================================================================
+//function : ExtrusionSweep
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::ExtrusionSweep(const SMESH::long_array & theIDsOfElements,
+ const SMESH::DirStruct & theStepVector,
+ CORBA::Long theNbOfSteps)
+ throw (SALOME::SALOME_Exception)
+{
+ extrusionSweep (theIDsOfElements, theStepVector, theNbOfSteps, false );
+ if (!myIsPreviewMode) {
+ TPythonDump() << this << ".ExtrusionSweep( "
+ << theIDsOfElements << ", " << theStepVector <<", " << TVar(theNbOfSteps) << " )";
+ }
+}
+
+//=======================================================================
+//function : ExtrusionSweep0D
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::ExtrusionSweep0D(const SMESH::long_array & theIDsOfElements,
+ const SMESH::DirStruct & theStepVector,
+ CORBA::Long theNbOfSteps)
+ throw (SALOME::SALOME_Exception)
+{
+ extrusionSweep (theIDsOfElements, theStepVector, theNbOfSteps, false, SMDSAbs_Node );
+ if (!myIsPreviewMode) {
+ TPythonDump() << this << ".ExtrusionSweep0D( "
+ << theIDsOfElements << ", " << theStepVector <<", " << TVar(theNbOfSteps)<< " )";
+ }
+}
+
+//=======================================================================
+//function : ExtrusionSweepObject
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::ExtrusionSweepObject(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::DirStruct & theStepVector,
+ CORBA::Long theNbOfSteps)
+ throw (SALOME::SALOME_Exception)
+{
+ prepareIdSource( theObject );
+ SMESH::long_array_var anElementsId = theObject->GetIDs();
+ extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false );
+ if (!myIsPreviewMode) {
+ TPythonDump() << this << ".ExtrusionSweepObject( "
+ << theObject << ", " << theStepVector << ", " << theNbOfSteps << " )";
+ }
+}
+
+//=======================================================================
+//function : ExtrusionSweepObject0D
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::ExtrusionSweepObject0D(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::DirStruct & theStepVector,
+ CORBA::Long theNbOfSteps)
+ throw (SALOME::SALOME_Exception)
+{
+ prepareIdSource( theObject );
+ SMESH::long_array_var anElementsId = theObject->GetIDs();
+ extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false, SMDSAbs_Node );
+ if ( !myIsPreviewMode ) {
+ TPythonDump() << this << ".ExtrusionSweepObject0D( "
+ << theObject << ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
+ }
+}
+
+//=======================================================================
+//function : ExtrusionSweepObject1D
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::ExtrusionSweepObject1D(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::DirStruct & theStepVector,
+ CORBA::Long theNbOfSteps)
+ throw (SALOME::SALOME_Exception)
+{
+ prepareIdSource( theObject );
+ SMESH::long_array_var anElementsId = theObject->GetIDs();
+ extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false, SMDSAbs_Edge );
+ if ( !myIsPreviewMode ) {
+ TPythonDump() << this << ".ExtrusionSweepObject1D( "
+ << theObject << ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
+ }
+}
+
+//=======================================================================
+//function : ExtrusionSweepObject2D
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::ExtrusionSweepObject2D(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::DirStruct & theStepVector,
+ CORBA::Long theNbOfSteps)
+ throw (SALOME::SALOME_Exception)
+{
+ prepareIdSource( theObject );
+ SMESH::long_array_var anElementsId = theObject->GetIDs();
+ extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false, SMDSAbs_Face );
+ if ( !myIsPreviewMode ) {
+ TPythonDump() << this << ".ExtrusionSweepObject2D( "
+ << theObject << ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
+ }
+}
+
+//=======================================================================
+//function : ExtrusionSweepMakeGroups
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::ExtrusionSweepMakeGroups(const SMESH::long_array& theIDsOfElements,
+ const SMESH::DirStruct& theStepVector,
+ CORBA::Long theNbOfSteps)
+ throw (SALOME::SALOME_Exception)
+{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
+ SMESH::ListOfGroups* aGroups = extrusionSweep(theIDsOfElements, theStepVector, theNbOfSteps, true);
+
+ if (!myIsPreviewMode) {
+ dumpGroupsList(aPythonDump, aGroups);
+ aPythonDump << this << ".ExtrusionSweepMakeGroups( " << theIDsOfElements
+ << ", " << theStepVector <<", " << TVar( theNbOfSteps ) << " )";
+ }
+ return aGroups;
+}
+
+//=======================================================================
+//function : ExtrusionSweepMakeGroups0D
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::ExtrusionSweepMakeGroups0D(const SMESH::long_array& theIDsOfElements,
+ const SMESH::DirStruct& theStepVector,
+ CORBA::Long theNbOfSteps)
+ throw (SALOME::SALOME_Exception)
+{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
+ SMESH::ListOfGroups* aGroups = extrusionSweep(theIDsOfElements, theStepVector, theNbOfSteps, true,SMDSAbs_Node);
+
+ if (!myIsPreviewMode) {
+ dumpGroupsList(aPythonDump, aGroups);
+ aPythonDump << this << ".ExtrusionSweepMakeGroups0D( " << theIDsOfElements
+ << ", " << theStepVector <<", " << TVar( theNbOfSteps ) << " )";
+ }
+ return aGroups;
+}
+
+//=======================================================================
+//function : ExtrusionSweepObjectMakeGroups
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::ExtrusionSweepObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::DirStruct& theStepVector,
+ CORBA::Long theNbOfSteps)
+ throw (SALOME::SALOME_Exception)
+{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
+ prepareIdSource( theObject );
+ SMESH::long_array_var anElementsId = theObject->GetIDs();
+ SMESH::ListOfGroups * aGroups = extrusionSweep(anElementsId, theStepVector, theNbOfSteps, true);
+
+ if (!myIsPreviewMode) {
+ dumpGroupsList(aPythonDump, aGroups);
+ aPythonDump << this << ".ExtrusionSweepObjectMakeGroups( " << theObject
+ << ", " << theStepVector << ", " << theNbOfSteps << " )";
+ }
+ return aGroups;
+}
+
+//=======================================================================
+//function : ExtrusionSweepObject0DMakeGroups
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::ExtrusionSweepObject0DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::DirStruct& theStepVector,
+ CORBA::Long theNbOfSteps)
+ throw (SALOME::SALOME_Exception)
+{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
+ prepareIdSource( theObject );
+ SMESH::long_array_var anElementsId = theObject->GetIDs();
+ SMESH::ListOfGroups * aGroups = extrusionSweep(anElementsId, theStepVector,
+ theNbOfSteps, true, SMDSAbs_Node);
+ if (!myIsPreviewMode) {
+ dumpGroupsList(aPythonDump, aGroups);
+ aPythonDump << this << ".ExtrusionSweepObject0DMakeGroups( " << theObject
+ << ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
+ }
+ return aGroups;
+}
+
+//=======================================================================
+//function : ExtrusionSweepObject1DMakeGroups
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::ExtrusionSweepObject1DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::DirStruct& theStepVector,
+ CORBA::Long theNbOfSteps)
+ throw (SALOME::SALOME_Exception)
+{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
+ prepareIdSource( theObject );
+ SMESH::long_array_var anElementsId = theObject->GetIDs();
+ SMESH::ListOfGroups * aGroups = extrusionSweep(anElementsId, theStepVector,
+ theNbOfSteps, true, SMDSAbs_Edge);
+ if (!myIsPreviewMode) {
+ dumpGroupsList(aPythonDump, aGroups);
+ aPythonDump << this << ".ExtrusionSweepObject1DMakeGroups( " << theObject
+ << ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
+ }
+ return aGroups;
+}
+
+//=======================================================================
+//function : ExtrusionSweepObject2DMakeGroups
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::ExtrusionSweepObject2DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::DirStruct& theStepVector,
+ CORBA::Long theNbOfSteps)
+ throw (SALOME::SALOME_Exception)
+{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
+ prepareIdSource( theObject );
+ SMESH::long_array_var anElementsId = theObject->GetIDs();
+ SMESH::ListOfGroups * aGroups = extrusionSweep(anElementsId, theStepVector,
+ theNbOfSteps, true, SMDSAbs_Face);
+ if (!myIsPreviewMode) {
+ dumpGroupsList(aPythonDump, aGroups);
+ aPythonDump << this << ".ExtrusionSweepObject2DMakeGroups( " << theObject
+ << ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
+ }
+ return aGroups;
+}
+
+
+//=======================================================================
+//function : advancedExtrusion
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::advancedExtrusion(const SMESH::long_array & theIDsOfElements,
+ const SMESH::DirStruct & theStepVector,
+ CORBA::Long theNbOfSteps,
+ CORBA::Long theExtrFlags,
+ CORBA::Double theSewTolerance,
+ const bool theMakeGroups)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ initData();
+
+ TIDSortedElemSet elements;
+ arrayToSet(theIDsOfElements, getMeshDS(), elements);
+
+ const SMESH::PointStruct * P = &theStepVector.PS;
+ gp_Vec stepVec( P->x, P->y, P->z );
+
+ TElemOfElemListMap aHystory;
+ ::SMESH_MeshEditor::PGroupIDs groupIds =
+ getEditor().ExtrusionSweep (elements, stepVec, theNbOfSteps, aHystory,
+ theMakeGroups, theExtrFlags, theSewTolerance);
+
+ declareMeshModified( /*isReComputeSafe=*/true );
+
+ return theMakeGroups ? getGroups(groupIds.get()) : 0;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//=======================================================================
+//function : AdvancedExtrusion
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::AdvancedExtrusion(const SMESH::long_array & theIDsOfElements,
+ const SMESH::DirStruct & theStepVector,
+ CORBA::Long theNbOfSteps,
+ CORBA::Long theExtrFlags,
+ CORBA::Double theSewTolerance)
+ throw (SALOME::SALOME_Exception)
+{
+ if ( !myIsPreviewMode ) {
+ TPythonDump() << "stepVector = " << theStepVector;
+ TPythonDump() << this << ".AdvancedExtrusion("
+ << theIDsOfElements
+ << ", stepVector, "
+ << theNbOfSteps << ","
+ << theExtrFlags << ", "
+ << theSewTolerance << " )";
+ }
+ advancedExtrusion( theIDsOfElements,
+ theStepVector,
+ theNbOfSteps,
+ theExtrFlags,
+ theSewTolerance,
+ false);
+}
+
+//=======================================================================
+//function : AdvancedExtrusionMakeGroups
+//purpose :
+//=======================================================================
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::AdvancedExtrusionMakeGroups(const SMESH::long_array& theIDsOfElements,
+ const SMESH::DirStruct& theStepVector,
+ CORBA::Long theNbOfSteps,
+ CORBA::Long theExtrFlags,
+ CORBA::Double theSewTolerance)
+ throw (SALOME::SALOME_Exception)
+{
+ if (!myIsPreviewMode) {
+ TPythonDump() << "stepVector = " << theStepVector;
+ }
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
+ SMESH::ListOfGroups * aGroups = advancedExtrusion( theIDsOfElements,
+ theStepVector,
+ theNbOfSteps,
+ theExtrFlags,
+ theSewTolerance,
+ true);
+
+ if (!myIsPreviewMode) {
+ dumpGroupsList(aPythonDump, aGroups);
+ aPythonDump << this << ".AdvancedExtrusionMakeGroups("
+ << theIDsOfElements
+ << ", stepVector, "
+ << theNbOfSteps << ","
+ << theExtrFlags << ", "
+ << theSewTolerance << " )";
+ }
+ return aGroups;
+}
+
+
+//================================================================================
+/*!
+ * \brief Convert extrusion error to IDL enum
+ */
+//================================================================================
+
+#define RETCASE(enm) case ::SMESH_MeshEditor::enm: return SMESH::SMESH_MeshEditor::enm;
+
+static SMESH::SMESH_MeshEditor::Extrusion_Error convExtrError( const::SMESH_MeshEditor::Extrusion_Error e )
+{
+ switch ( e ) {
+ RETCASE( EXTR_OK );
+ RETCASE( EXTR_NO_ELEMENTS );
+ RETCASE( EXTR_PATH_NOT_EDGE );
+ RETCASE( EXTR_BAD_PATH_SHAPE );
+ RETCASE( EXTR_BAD_STARTING_NODE );
+ RETCASE( EXTR_BAD_ANGLES_NUMBER );
+ RETCASE( EXTR_CANT_GET_TANGENT );
+ }
+ return SMESH::SMESH_MeshEditor::EXTR_OK;
+}
+
+
+//=======================================================================
+//function : extrusionAlongPath
+//purpose :
+//=======================================================================
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::extrusionAlongPath(const SMESH::long_array & theIDsOfElements,
+ SMESH::SMESH_Mesh_ptr thePathMesh,
+ GEOM::GEOM_Object_ptr thePathShape,
+ CORBA::Long theNodeStart,
+ CORBA::Boolean theHasAngles,
+ const SMESH::double_array & theAngles,
+ CORBA::Boolean theHasRefPoint,
+ const SMESH::PointStruct & theRefPoint,
+ const bool theMakeGroups,
+ SMESH::SMESH_MeshEditor::Extrusion_Error & theError,
+ const SMDSAbs_ElementType theElementType)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ MESSAGE("extrusionAlongPath");
+ initData();
+
+ if ( thePathMesh->_is_nil() || thePathShape->_is_nil() ) {
+ theError = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
+ return 0;
+ }
+ SMESH_Mesh_i* aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( thePathMesh );
+
+ TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( thePathShape );
+ SMESH_subMesh* aSubMesh = aMeshImp->GetImpl().GetSubMesh( aShape );
+
+ if ( !aSubMesh || !aSubMesh->GetSubMeshDS()) {
+ theError = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
+ return 0;
+ }
+
+ SMDS_MeshNode* nodeStart = (SMDS_MeshNode*)aMeshImp->GetImpl().GetMeshDS()->FindNode(theNodeStart);
+ if ( !nodeStart ) {
+ theError = SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE;
+ return 0;
+ }
+
+ TIDSortedElemSet elements;
+ arrayToSet(theIDsOfElements, getMeshDS(), elements, theElementType);
+
+ list<double> angles;
+ for (int i = 0; i < theAngles.length(); i++) {
+ angles.push_back( theAngles[i] );
+ }
+
+ gp_Pnt refPnt( theRefPoint.x, theRefPoint.y, theRefPoint.z );
+
+ int nbOldGroups = myMesh->NbGroup();
+
+ ::SMESH_MeshEditor::Extrusion_Error error =
+ getEditor().ExtrusionAlongTrack( elements, aSubMesh, nodeStart,
+ theHasAngles, angles, false,
+ theHasRefPoint, refPnt, theMakeGroups );
+
+ declareMeshModified( /*isReComputeSafe=*/true );
+ theError = convExtrError( error );
+
+ if ( theMakeGroups ) {
+ list<int> groupIDs = myMesh->GetGroupIds();
+ list<int>::iterator newBegin = groupIDs.begin();
+ std::advance( newBegin, nbOldGroups ); // skip old groups
+ groupIDs.erase( groupIDs.begin(), newBegin );
+ return getGroups( & groupIDs );
+ }
+ return 0;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//=======================================================================
+//function : extrusionAlongPathX
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::extrusionAlongPathX(const SMESH::long_array & IDsOfElements,
+ SMESH::SMESH_IDSource_ptr Path,
+ CORBA::Long NodeStart,
+ CORBA::Boolean HasAngles,
+ const SMESH::double_array& Angles,
+ CORBA::Boolean LinearVariation,
+ CORBA::Boolean HasRefPoint,
+ const SMESH::PointStruct& RefPoint,
+ bool MakeGroups,
+ const SMDSAbs_ElementType ElementType,
+ SMESH::SMESH_MeshEditor::Extrusion_Error & Error)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ SMESH::ListOfGroups* EmptyGr = new SMESH::ListOfGroups;
+
+ initData();
+
+ list<double> angles;
+ for (int i = 0; i < Angles.length(); i++) {
+ angles.push_back( Angles[i] );
+ }
+ gp_Pnt refPnt( RefPoint.x, RefPoint.y, RefPoint.z );
+ int nbOldGroups = myMesh->NbGroup();
+
+ if ( Path->_is_nil() ) {
+ Error = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
+ return EmptyGr;
+ }
+
+ TIDSortedElemSet elements, copyElements;
+ arrayToSet(IDsOfElements, getMeshDS(), elements, ElementType);
+
+ TIDSortedElemSet* workElements = &elements;
+
+ if ( myIsPreviewMode )
+ {
+ SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
+ getPreviewMesh( SMDSAbs_Face )->Copy( elements, copyElements, select, avoid );
+ workElements = & copyElements;
+ MakeGroups = false;
+ }
+
+ ::SMESH_MeshEditor::Extrusion_Error error;
+
+ if ( SMESH_Mesh_i* aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( Path ))
+ {
+ // path as mesh
+ SMDS_MeshNode* aNodeStart =
+ (SMDS_MeshNode*)aMeshImp->GetImpl().GetMeshDS()->FindNode(NodeStart);
+ if ( !aNodeStart ) {
+ Error = SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE;
+ return EmptyGr;
+ }
+ error = getEditor().ExtrusionAlongTrack( *workElements, &(aMeshImp->GetImpl()), aNodeStart,
+ HasAngles, angles, LinearVariation,
+ HasRefPoint, refPnt, MakeGroups );
+ declareMeshModified( /*isReComputeSafe=*/true );
+ }
+ 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 = getEditor().ExtrusionAlongTrack( *workElements, aSubMesh, aNodeStart,
+ HasAngles, angles, LinearVariation,
+ HasRefPoint, refPnt, MakeGroups );
+ declareMeshModified( /*isReComputeSafe=*/true );
+ }
+ 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;
+ }
+
+ Error = convExtrError( error );
+
+ if ( MakeGroups ) {
+ list<int> groupIDs = myMesh->GetGroupIds();
+ list<int>::iterator newBegin = groupIDs.begin();
+ std::advance( newBegin, nbOldGroups ); // skip old groups
+ groupIDs.erase( groupIDs.begin(), newBegin );
+ return getGroups( & groupIDs );
+ }
+ return EmptyGr;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//=======================================================================
+//function : ExtrusionAlongPath
+//purpose :
+//=======================================================================
+
+SMESH::SMESH_MeshEditor::Extrusion_Error
+SMESH_MeshEditor_i::ExtrusionAlongPath(const SMESH::long_array & theIDsOfElements,
+ SMESH::SMESH_Mesh_ptr thePathMesh,
+ GEOM::GEOM_Object_ptr thePathShape,
+ CORBA::Long theNodeStart,
+ CORBA::Boolean theHasAngles,
+ const SMESH::double_array & theAngles,
+ CORBA::Boolean theHasRefPoint,
+ const SMESH::PointStruct & theRefPoint)
+ throw (SALOME::SALOME_Exception)
+{
+ MESSAGE("ExtrusionAlongPath");
+ if ( !myIsPreviewMode ) {
+ TPythonDump() << "error = " << this << ".ExtrusionAlongPath( "
+ << theIDsOfElements << ", "
+ << thePathMesh << ", "
+ << thePathShape << ", "
+ << theNodeStart << ", "
+ << theHasAngles << ", "
+ << theAngles << ", "
+ << theHasRefPoint << ", "
+ << "SMESH.PointStruct( "
+ << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
+ << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
+ << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
+ }
+ SMESH::SMESH_MeshEditor::Extrusion_Error anError;
+ extrusionAlongPath( theIDsOfElements,
+ thePathMesh,
+ thePathShape,
+ theNodeStart,
+ theHasAngles,
+ theAngles,
+ theHasRefPoint,
+ theRefPoint,
+ false,
+ anError);
+ return anError;
+}
+
+//=======================================================================
+//function : ExtrusionAlongPathObject
+//purpose :
+//=======================================================================
+
+SMESH::SMESH_MeshEditor::Extrusion_Error
+SMESH_MeshEditor_i::ExtrusionAlongPathObject(SMESH::SMESH_IDSource_ptr theObject,
+ SMESH::SMESH_Mesh_ptr thePathMesh,
+ GEOM::GEOM_Object_ptr thePathShape,
+ CORBA::Long theNodeStart,
+ CORBA::Boolean theHasAngles,
+ const SMESH::double_array & theAngles,
+ CORBA::Boolean theHasRefPoint,
+ const SMESH::PointStruct & theRefPoint)
+ throw (SALOME::SALOME_Exception)
+{
+ if ( !myIsPreviewMode ) {
+ TPythonDump() << "error = " << this << ".ExtrusionAlongPathObject( "
+ << theObject << ", "
+ << thePathMesh << ", "
+ << thePathShape << ", "
+ << theNodeStart << ", "
+ << theHasAngles << ", "
+ << theAngles << ", "
+ << theHasRefPoint << ", "
+ << "SMESH.PointStruct( "
+ << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
+ << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
+ << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
+ }
+ SMESH::SMESH_MeshEditor::Extrusion_Error anError;
+ prepareIdSource( theObject );
+ SMESH::long_array_var anElementsId = theObject->GetIDs();
+ extrusionAlongPath( anElementsId,
+ thePathMesh,
+ thePathShape,
+ theNodeStart,
+ theHasAngles,
+ theAngles,
+ theHasRefPoint,
+ theRefPoint,
+ false,
+ anError);
+ return anError;
+}
+
+//=======================================================================
+//function : ExtrusionAlongPathObject1D
+//purpose :
+//=======================================================================
+
+SMESH::SMESH_MeshEditor::Extrusion_Error
+SMESH_MeshEditor_i::ExtrusionAlongPathObject1D(SMESH::SMESH_IDSource_ptr theObject,
+ SMESH::SMESH_Mesh_ptr thePathMesh,
+ GEOM::GEOM_Object_ptr thePathShape,
+ CORBA::Long theNodeStart,
+ CORBA::Boolean theHasAngles,
+ const SMESH::double_array & theAngles,
+ CORBA::Boolean theHasRefPoint,
+ const SMESH::PointStruct & theRefPoint)
+ throw (SALOME::SALOME_Exception)
+{
+ if ( !myIsPreviewMode ) {
+ TPythonDump() << "error = " << this << ".ExtrusionAlongPathObject1D( "
+ << theObject << ", "
+ << thePathMesh << ", "
+ << thePathShape << ", "
+ << theNodeStart << ", "
+ << theHasAngles << ", "
+ << theAngles << ", "
+ << theHasRefPoint << ", "
+ << "SMESH.PointStruct( "
+ << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
+ << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
+ << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
+ }
+ SMESH::SMESH_MeshEditor::Extrusion_Error anError;
+ prepareIdSource( theObject );
+ SMESH::long_array_var anElementsId = theObject->GetIDs();
+ extrusionAlongPath( anElementsId,
+ thePathMesh,
+ thePathShape,
+ theNodeStart,
+ theHasAngles,
+ theAngles,
+ theHasRefPoint,
+ theRefPoint,
+ false,
+ anError,
+ SMDSAbs_Edge);
+ return anError;
+}
+
+//=======================================================================
+//function : ExtrusionAlongPathObject2D
+//purpose :
+//=======================================================================
+
+SMESH::SMESH_MeshEditor::Extrusion_Error
+SMESH_MeshEditor_i::ExtrusionAlongPathObject2D(SMESH::SMESH_IDSource_ptr theObject,
+ SMESH::SMESH_Mesh_ptr thePathMesh,
+ GEOM::GEOM_Object_ptr thePathShape,
+ CORBA::Long theNodeStart,
+ CORBA::Boolean theHasAngles,
+ const SMESH::double_array & theAngles,
+ CORBA::Boolean theHasRefPoint,
+ const SMESH::PointStruct & theRefPoint)
+ throw (SALOME::SALOME_Exception)
+{
+ if ( !myIsPreviewMode ) {
+ TPythonDump() << "error = " << this << ".ExtrusionAlongPathObject2D( "
+ << theObject << ", "
+ << thePathMesh << ", "
+ << thePathShape << ", "
+ << theNodeStart << ", "
+ << theHasAngles << ", "
+ << theAngles << ", "
+ << theHasRefPoint << ", "
+ << "SMESH.PointStruct( "
+ << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
+ << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
+ << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
+ }
+ SMESH::SMESH_MeshEditor::Extrusion_Error anError;
+ prepareIdSource( theObject );
+ SMESH::long_array_var anElementsId = theObject->GetIDs();
+ extrusionAlongPath( anElementsId,
+ thePathMesh,
+ thePathShape,
+ theNodeStart,
+ theHasAngles,
+ theAngles,
+ theHasRefPoint,
+ theRefPoint,
+ false,
+ anError,
+ SMDSAbs_Face);
+ return anError;
+}
+
+
+//=======================================================================
+//function : ExtrusionAlongPathMakeGroups
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::ExtrusionAlongPathMakeGroups(const SMESH::long_array& theIDsOfElements,
+ SMESH::SMESH_Mesh_ptr thePathMesh,
+ GEOM::GEOM_Object_ptr thePathShape,
+ CORBA::Long theNodeStart,
+ CORBA::Boolean theHasAngles,
+ const SMESH::double_array& theAngles,
+ CORBA::Boolean theHasRefPoint,
+ const SMESH::PointStruct& theRefPoint,
+ SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
+ throw (SALOME::SALOME_Exception)
+{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
+ SMESH::ListOfGroups * aGroups = extrusionAlongPath( theIDsOfElements,
+ thePathMesh,
+ thePathShape,
+ theNodeStart,
+ theHasAngles,
+ theAngles,
+ theHasRefPoint,
+ theRefPoint,
+ true,
+ Error);
+ if (!myIsPreviewMode) {
+ bool isDumpGroups = aGroups && aGroups->length() > 0;
+ if (isDumpGroups)
+ aPythonDump << "(" << aGroups << ", error)";
+ else
+ aPythonDump <<"error";
+
+ aPythonDump<<" = "<< this << ".ExtrusionAlongPathMakeGroups( "
+ << theIDsOfElements << ", "
+ << thePathMesh << ", "
+ << thePathShape << ", "
+ << theNodeStart << ", "
+ << theHasAngles << ", "
+ << theAngles << ", "
+ << theHasRefPoint << ", "
+ << "SMESH.PointStruct( "
+ << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
+ << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
+ << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
+ }
+ return aGroups;
+}
+
+//=======================================================================
+//function : ExtrusionAlongPathObjectMakeGroups
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups* SMESH_MeshEditor_i::
+ExtrusionAlongPathObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
+ SMESH::SMESH_Mesh_ptr thePathMesh,
+ GEOM::GEOM_Object_ptr thePathShape,
+ CORBA::Long theNodeStart,
+ CORBA::Boolean theHasAngles,
+ const SMESH::double_array& theAngles,
+ CORBA::Boolean theHasRefPoint,
+ const SMESH::PointStruct& theRefPoint,
+ SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
+ throw (SALOME::SALOME_Exception)
+{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
+ prepareIdSource( theObject );
+ SMESH::long_array_var anElementsId = theObject->GetIDs();
+ SMESH::ListOfGroups * aGroups = extrusionAlongPath( anElementsId,
+ thePathMesh,
+ thePathShape,
+ theNodeStart,
+ theHasAngles,
+ theAngles,
+ theHasRefPoint,
+ theRefPoint,
+ true,
+ Error);
+
+ if (!myIsPreviewMode) {
+ bool isDumpGroups = aGroups && aGroups->length() > 0;
+ if (isDumpGroups)
+ aPythonDump << "(" << aGroups << ", error)";
+ else
+ aPythonDump <<"error";
+
+ aPythonDump << " = " << this << ".ExtrusionAlongPathObjectMakeGroups( "
+ << theObject << ", "
+ << thePathMesh << ", "
+ << thePathShape << ", "
+ << theNodeStart << ", "
+ << theHasAngles << ", "
+ << theAngles << ", "
+ << theHasRefPoint << ", "
+ << "SMESH.PointStruct( "
+ << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
+ << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
+ << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
+ }
+ return aGroups;
+}
+
+//=======================================================================
+//function : ExtrusionAlongPathObject1DMakeGroups
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups* SMESH_MeshEditor_i::
+ExtrusionAlongPathObject1DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
+ SMESH::SMESH_Mesh_ptr thePathMesh,
+ GEOM::GEOM_Object_ptr thePathShape,
+ CORBA::Long theNodeStart,
+ CORBA::Boolean theHasAngles,
+ const SMESH::double_array& theAngles,
+ CORBA::Boolean theHasRefPoint,
+ const SMESH::PointStruct& theRefPoint,
+ SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
+ throw (SALOME::SALOME_Exception)
+{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
+ prepareIdSource( theObject );
+ SMESH::long_array_var anElementsId = theObject->GetIDs();
+ SMESH::ListOfGroups * aGroups = extrusionAlongPath( anElementsId,
+ thePathMesh,
+ thePathShape,
+ theNodeStart,
+ theHasAngles,
+ theAngles,
+ theHasRefPoint,
+ theRefPoint,
+ true,
+ Error,
+ SMDSAbs_Edge);
+
+ if (!myIsPreviewMode) {
+ bool isDumpGroups = aGroups && aGroups->length() > 0;
+ if (isDumpGroups)
+ aPythonDump << "(" << aGroups << ", error)";
+ else
+ aPythonDump << "error";
+
+ aPythonDump << " = " << this << ".ExtrusionAlongPathObject1DMakeGroups( "
+ << theObject << ", "
+ << thePathMesh << ", "
+ << thePathShape << ", "
+ << theNodeStart << ", "
+ << theHasAngles << ", "
+ << theAngles << ", "
+ << theHasRefPoint << ", "
+ << "SMESH.PointStruct( "
+ << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
+ << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
+ << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
+ }
+ return aGroups;
+}
+
+//=======================================================================
+//function : ExtrusionAlongPathObject2DMakeGroups
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups* SMESH_MeshEditor_i::
+ExtrusionAlongPathObject2DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
+ SMESH::SMESH_Mesh_ptr thePathMesh,
+ GEOM::GEOM_Object_ptr thePathShape,
+ CORBA::Long theNodeStart,
+ CORBA::Boolean theHasAngles,
+ const SMESH::double_array& theAngles,
+ CORBA::Boolean theHasRefPoint,
+ const SMESH::PointStruct& theRefPoint,
+ SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
+ throw (SALOME::SALOME_Exception)
+{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
+ prepareIdSource( theObject );
+ SMESH::long_array_var anElementsId = theObject->GetIDs();
+ SMESH::ListOfGroups * aGroups = extrusionAlongPath( anElementsId,
+ thePathMesh,
+ thePathShape,
+ theNodeStart,
+ theHasAngles,
+ theAngles,
+ theHasRefPoint,
+ theRefPoint,
+ true,
+ Error,
+ SMDSAbs_Face);
+
+ if (!myIsPreviewMode) {
+ bool isDumpGroups = aGroups && aGroups->length() > 0;
+ if (isDumpGroups)
+ aPythonDump << "(" << aGroups << ", error)";
+ else
+ aPythonDump << "error";
+
+ aPythonDump << " = " << this << ".ExtrusionAlongPathObject2DMakeGroups( "
+ << theObject << ", "
+ << thePathMesh << ", "
+ << thePathShape << ", "
+ << theNodeStart << ", "
+ << theHasAngles << ", "
+ << theAngles << ", "
+ << theHasRefPoint << ", "
+ << "SMESH.PointStruct( "
+ << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
+ << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
+ << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
+ }
+ return aGroups;
+}
+
+//=======================================================================
+//function : ExtrusionAlongPathObjX
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups* SMESH_MeshEditor_i::
+ExtrusionAlongPathObjX(SMESH::SMESH_IDSource_ptr Object,
+ SMESH::SMESH_IDSource_ptr Path,
+ CORBA::Long NodeStart,
+ CORBA::Boolean HasAngles,
+ const SMESH::double_array& Angles,
+ CORBA::Boolean LinearVariation,
+ CORBA::Boolean HasRefPoint,
+ const SMESH::PointStruct& RefPoint,
+ CORBA::Boolean MakeGroups,
+ SMESH::ElementType ElemType,
+ SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
+ throw (SALOME::SALOME_Exception)
+{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
+ prepareIdSource( Object );
+ SMESH::long_array_var anElementsId = Object->GetIDs();
+ SMESH::ListOfGroups * aGroups = extrusionAlongPathX(anElementsId,
+ Path,
+ NodeStart,
+ HasAngles,
+ Angles,
+ LinearVariation,
+ HasRefPoint,
+ RefPoint,
+ MakeGroups,
+ (SMDSAbs_ElementType)ElemType,
+ Error);
+
+ if (!myIsPreviewMode) {
+ bool isDumpGroups = aGroups && aGroups->length() > 0;
+ if (isDumpGroups)
+ aPythonDump << "(" << *aGroups << ", error)";
+ else
+ aPythonDump << "error";
+
+ aPythonDump << " = " << this << ".ExtrusionAlongPathObjX( "
+ << Object << ", "
+ << Path << ", "
+ << NodeStart << ", "
+ << HasAngles << ", "
+ << TVar( Angles ) << ", "
+ << LinearVariation << ", "
+ << HasRefPoint << ", "
+ << "SMESH.PointStruct( "
+ << TVar( HasRefPoint ? RefPoint.x : 0 ) << ", "
+ << TVar( HasRefPoint ? RefPoint.y : 0 ) << ", "
+ << TVar( HasRefPoint ? RefPoint.z : 0 ) << " ), "
+ << MakeGroups << ", "
+ << ElemType << " )";
+ }
+ return aGroups;
+}
+
+//=======================================================================
+//function : ExtrusionAlongPathX
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups* SMESH_MeshEditor_i::
+ExtrusionAlongPathX(const SMESH::long_array& IDsOfElements,
+ SMESH::SMESH_IDSource_ptr Path,
+ CORBA::Long NodeStart,
+ CORBA::Boolean HasAngles,
+ const SMESH::double_array& Angles,
+ CORBA::Boolean LinearVariation,
+ CORBA::Boolean HasRefPoint,
+ const SMESH::PointStruct& RefPoint,
+ CORBA::Boolean MakeGroups,
+ SMESH::ElementType ElemType,
+ SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
+ throw (SALOME::SALOME_Exception)
+{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
+ SMESH::ListOfGroups * aGroups = extrusionAlongPathX(IDsOfElements,
+ Path,
+ NodeStart,
+ HasAngles,
+ Angles,
+ LinearVariation,
+ HasRefPoint,
+ RefPoint,
+ MakeGroups,
+ (SMDSAbs_ElementType)ElemType,
+ Error);
+
+ if (!myIsPreviewMode) {
+ bool isDumpGroups = aGroups && aGroups->length() > 0;
+ if (isDumpGroups)
+ aPythonDump << "(" << *aGroups << ", error)";
+ else
+ aPythonDump <<"error";
+
+ aPythonDump << " = " << this << ".ExtrusionAlongPathX( "
+ << IDsOfElements << ", "
+ << Path << ", "
+ << NodeStart << ", "
+ << HasAngles << ", "
+ << TVar( Angles ) << ", "
+ << LinearVariation << ", "
+ << HasRefPoint << ", "
+ << "SMESH.PointStruct( "
+ << TVar( HasRefPoint ? RefPoint.x : 0 ) << ", "
+ << TVar( HasRefPoint ? RefPoint.y : 0 ) << ", "
+ << TVar( 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
+ * which proceeds the extrusion
+ * \param PathShape is shape(edge); as the mesh can be complex, the edge
+ * is used to define the sub-mesh for the path
+ */
+//================================================================================
+
+SMESH::double_array*
+SMESH_MeshEditor_i::LinearAnglesVariation(SMESH::SMESH_Mesh_ptr thePathMesh,
+ GEOM::GEOM_Object_ptr thePathShape,
+ const SMESH::double_array & theAngles)
+{
+ SMESH::double_array_var aResult = new SMESH::double_array();
+ int nbAngles = theAngles.length();
+ if ( nbAngles > 0 && !thePathMesh->_is_nil() && !thePathShape->_is_nil() )
+ {
+ SMESH_Mesh_i* aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( thePathMesh );
+ TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( thePathShape );
+ SMESH_subMesh* aSubMesh = aMeshImp->GetImpl().GetSubMesh( aShape );
+ if ( !aSubMesh || !aSubMesh->GetSubMeshDS())
+ return aResult._retn();
+ int nbSteps = aSubMesh->GetSubMeshDS()->NbElements();
+ if ( nbSteps == nbAngles )
+ {
+ aResult.inout() = theAngles;
+ }
+ else
+ {
+ aResult->length( nbSteps );
+ double rAn2St = double( nbAngles ) / double( nbSteps );
+ double angPrev = 0, angle;
+ for ( int iSt = 0; iSt < nbSteps; ++iSt )
+ {
+ double angCur = rAn2St * ( iSt+1 );
+ double angCurFloor = floor( angCur );
+ double angPrevFloor = floor( angPrev );
+ if ( angPrevFloor == angCurFloor )
+ angle = rAn2St * theAngles[ int( angCurFloor ) ];
+ else
+ {
+ int iP = int( angPrevFloor );
+ double angPrevCeil = ceil(angPrev);
+ angle = ( angPrevCeil - angPrev ) * theAngles[ iP ];
+
+ int iC = int( angCurFloor );
+ if ( iC < nbAngles )
+ angle += ( angCur - angCurFloor ) * theAngles[ iC ];
+
+ iP = int( angPrevCeil );
+ while ( iC-- > iP )
+ angle += theAngles[ iC ];
+ }
+ aResult[ iSt ] = angle;
+ angPrev = angCur;
+ }
+ }
+ }
+ // Update Python script
+ TPythonDump() << "rotAngles = " << theAngles;
+ TPythonDump() << "rotAngles = " << this << ".LinearAnglesVariation( "
+ << thePathMesh << ", "
+ << thePathShape << ", "
+ << "rotAngles )";
+
+ return aResult._retn();
+}
+
+//=======================================================================
+//function : mirror
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::mirror(TIDSortedElemSet & theElements,
+ const SMESH::AxisStruct & theAxis,
+ SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
+ CORBA::Boolean theCopy,
+ bool theMakeGroups,
+ ::SMESH_Mesh* theTargetMesh)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ initData();
+
+ 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( P );
+ break;
+ case SMESH::SMESH_MeshEditor::AXIS:
+ aTrsf.SetMirror( gp_Ax1( P, V ));
+ break;
+ default:
+ aTrsf.SetMirror( gp_Ax2( P, V ));
+ }
+
+ TIDSortedElemSet copyElements;
+ TIDSortedElemSet* workElements = & theElements;
+
+ if ( myIsPreviewMode )
+ {
+ TPreviewMesh * tmpMesh = getPreviewMesh();
+ tmpMesh->Copy( theElements, copyElements);
+ if ( !theCopy && !theTargetMesh )
+ {
+ TIDSortedElemSet elemsAround, elemsAroundCopy;
+ getElementsAround( theElements, getMeshDS(), elemsAround );
+ tmpMesh->Copy( elemsAround, elemsAroundCopy);
+ }
+ workElements = & copyElements;
+ theMakeGroups = false;
+ }
+
+ ::SMESH_MeshEditor::PGroupIDs groupIds =
+ getEditor().Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
+
+ if ( theCopy && !myIsPreviewMode)
+ {
+ if ( theTargetMesh )
+ {
+ theTargetMesh->GetMeshDS()->Modified();
+ }
+ else
+ {
+ declareMeshModified( /*isReComputeSafe=*/false );
+ }
+ }
+ return theMakeGroups ? getGroups(groupIds.get()) : 0;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//=======================================================================
+//function : Mirror
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::Mirror(const SMESH::long_array & theIDsOfElements,
+ const SMESH::AxisStruct & theAxis,
+ SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
+ CORBA::Boolean theCopy)
+ throw (SALOME::SALOME_Exception)
+{
+ if ( !myIsPreviewMode ) {
+ TPythonDump() << this << ".Mirror( "
+ << theIDsOfElements << ", "
+ << theAxis << ", "
+ << mirrorTypeName(theMirrorType) << ", "
+ << theCopy << " )";
+ }
+ if ( theIDsOfElements.length() > 0 )
+ {
+ TIDSortedElemSet elements;
+ arrayToSet(theIDsOfElements, getMeshDS(), elements);
+ mirror(elements, theAxis, theMirrorType, theCopy, false);
+ }
+}
+
+
+//=======================================================================
+//function : MirrorObject
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::MirrorObject(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::AxisStruct & theAxis,
+ SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
+ CORBA::Boolean theCopy)
+ throw (SALOME::SALOME_Exception)
+{
+ if ( !myIsPreviewMode ) {
+ TPythonDump() << this << ".MirrorObject( "
+ << theObject << ", "
+ << theAxis << ", "
+ << mirrorTypeName(theMirrorType) << ", "
+ << theCopy << " )";
+ }
+ TIDSortedElemSet elements;
+
+ bool emptyIfIsMesh = myIsPreviewMode ? false : true;
+
+ prepareIdSource( theObject );
+ if (idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
+ mirror(elements, theAxis, theMirrorType, theCopy, false);
+}
+
+//=======================================================================
+//function : MirrorMakeGroups
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::MirrorMakeGroups(const SMESH::long_array& theIDsOfElements,
+ const SMESH::AxisStruct& theMirror,
+ SMESH::SMESH_MeshEditor::MirrorType theMirrorType)
+ throw (SALOME::SALOME_Exception)
+{
+ 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 (!myIsPreviewMode) {
+ dumpGroupsList(aPythonDump, aGroups);
+ aPythonDump << this << ".MirrorMakeGroups( "
+ << theIDsOfElements << ", "
+ << theMirror << ", "
+ << mirrorTypeName(theMirrorType) << " )";
+ }
+ return aGroups;
+}
+
+//=======================================================================
+//function : MirrorObjectMakeGroups
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::MirrorObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::AxisStruct& theMirror,
+ SMESH::SMESH_MeshEditor::MirrorType theMirrorType)
+ throw (SALOME::SALOME_Exception)
+{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
+ SMESH::ListOfGroups * aGroups = 0;
+ TIDSortedElemSet elements;
+ prepareIdSource( theObject );
+ if ( idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
+ aGroups = mirror(elements, theMirror, theMirrorType, true, true);
+
+ if (!myIsPreviewMode)
+ {
+ dumpGroupsList(aPythonDump,aGroups);
+ aPythonDump << this << ".MirrorObjectMakeGroups( "
+ << theObject << ", "
+ << theMirror << ", "
+ << mirrorTypeName(theMirrorType) << " )";
+ }
+ return aGroups;
+}
+
+//=======================================================================
+//function : MirrorMakeMesh
+//purpose :
+//=======================================================================
+
+SMESH::SMESH_Mesh_ptr
+SMESH_MeshEditor_i::MirrorMakeMesh(const SMESH::long_array& theIDsOfElements,
+ const SMESH::AxisStruct& theMirror,
+ SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
+ CORBA::Boolean theCopyGroups,
+ const char* theMeshName)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_Mesh_i* mesh_i;
+ SMESH::SMESH_Mesh_var mesh;
+ { // open new scope to dump "MakeMesh" command
+ // and then "GetGroups" using SMESH_Mesh::GetGroups()
+
+ TPythonDump pydump; // to prevent dump at mesh creation
+
+ mesh = makeMesh( theMeshName );
+ mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
+ 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 (!myIsPreviewMode) {
+ pydump << mesh << " = " << this << ".MirrorMakeMesh( "
+ << theIDsOfElements << ", "
+ << theMirror << ", "
+ << mirrorTypeName(theMirrorType) << ", "
+ << theCopyGroups << ", '"
+ << theMeshName << "' )";
+ }
+ }
+
+ //dump "GetGroups"
+ if (!myIsPreviewMode && mesh_i)
+ mesh_i->GetGroups();
+
+ return mesh._retn();
+}
+
+//=======================================================================
+//function : MirrorObjectMakeMesh
+//purpose :
+//=======================================================================
+
+SMESH::SMESH_Mesh_ptr
+SMESH_MeshEditor_i::MirrorObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::AxisStruct& theMirror,
+ SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
+ CORBA::Boolean theCopyGroups,
+ const char* theMeshName)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_Mesh_i* mesh_i;
+ SMESH::SMESH_Mesh_var mesh;
+ { // open new scope to dump "MakeMesh" command
+ // and then "GetGroups" using SMESH_Mesh::GetGroups()
+
+ TPythonDump pydump; // to prevent dump at mesh creation
+
+ mesh = makeMesh( theMeshName );
+ mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
+ TIDSortedElemSet elements;
+ prepareIdSource( theObject );
+ if ( mesh_i &&
+ idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
+ {
+ mirror(elements, theMirror, theMirrorType,
+ false, theCopyGroups, & mesh_i->GetImpl());
+ mesh_i->CreateGroupServants();
+ }
+ if (!myIsPreviewMode) {
+ pydump << mesh << " = " << this << ".MirrorObjectMakeMesh( "
+ << theObject << ", "
+ << theMirror << ", "
+ << mirrorTypeName(theMirrorType) << ", "
+ << theCopyGroups << ", '"
+ << theMeshName << "' )";
+ }
+ }
+
+ //dump "GetGroups"
+ if (!myIsPreviewMode && mesh_i)
+ mesh_i->GetGroups();
+
+ return mesh._retn();
+}
+
+//=======================================================================
+//function : translate
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::translate(TIDSortedElemSet & theElements,
+ const SMESH::DirStruct & theVector,
+ CORBA::Boolean theCopy,
+ bool theMakeGroups,
+ ::SMESH_Mesh* theTargetMesh)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ initData();
+
+ if ( theTargetMesh )
+ theCopy = false;
+
+ gp_Trsf aTrsf;
+ const SMESH::PointStruct * P = &theVector.PS;
+ aTrsf.SetTranslation( gp_Vec( P->x, P->y, P->z ));
+
+ TIDSortedElemSet copyElements;
+ TIDSortedElemSet* workElements = &theElements;
+
+ if ( myIsPreviewMode )
+ {
+ TPreviewMesh * tmpMesh = getPreviewMesh();
+ tmpMesh->Copy( theElements, copyElements);
+ if ( !theCopy && !theTargetMesh )
+ {
+ TIDSortedElemSet elemsAround, elemsAroundCopy;
+ getElementsAround( theElements, getMeshDS(), elemsAround );
+ tmpMesh->Copy( elemsAround, elemsAroundCopy);
+ }
+ workElements = & copyElements;
+ theMakeGroups = false;
+ }
+
+ ::SMESH_MeshEditor::PGroupIDs groupIds =
+ getEditor().Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
+
+ if ( theCopy && !myIsPreviewMode )
+ {
+ if ( theTargetMesh )
+ {
+ theTargetMesh->GetMeshDS()->Modified();
+ }
+ else
+ {
+ declareMeshModified( /*isReComputeSafe=*/false );
+ }
+ }
+
+ return theMakeGroups ? getGroups(groupIds.get()) : 0;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//=======================================================================
+//function : Translate
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::Translate(const SMESH::long_array & theIDsOfElements,
+ const SMESH::DirStruct & theVector,
+ CORBA::Boolean theCopy)
+ throw (SALOME::SALOME_Exception)
+{
+ if (!myIsPreviewMode) {
+ TPythonDump() << this << ".Translate( "
+ << theIDsOfElements << ", "
+ << theVector << ", "
+ << theCopy << " )";
+ }
+ if (theIDsOfElements.length()) {
+ TIDSortedElemSet elements;
+ arrayToSet(theIDsOfElements, getMeshDS(), elements);
+ translate(elements, theVector, theCopy, false);
+ }
+}
+
+//=======================================================================
+//function : TranslateObject
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::TranslateObject(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::DirStruct & theVector,
+ CORBA::Boolean theCopy)
+ throw (SALOME::SALOME_Exception)
+{
+ if (!myIsPreviewMode) {
+ TPythonDump() << this << ".TranslateObject( "
+ << theObject << ", "
+ << theVector << ", "
+ << theCopy << " )";
+ }
+ TIDSortedElemSet elements;
+
+ bool emptyIfIsMesh = myIsPreviewMode ? false : true;
+
+ prepareIdSource( theObject );
+ if (idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
+ translate(elements, theVector, theCopy, false);
+}
+
+//=======================================================================
+//function : TranslateMakeGroups
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::TranslateMakeGroups(const SMESH::long_array& theIDsOfElements,
+ const SMESH::DirStruct& theVector)
+ throw (SALOME::SALOME_Exception)
+{
+ 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 (!myIsPreviewMode) {
+ dumpGroupsList(aPythonDump, aGroups);
+ aPythonDump << this << ".TranslateMakeGroups( "
+ << theIDsOfElements << ", "
+ << theVector << " )";
+ }
+ return aGroups;
+}
+
+//=======================================================================
+//function : TranslateObjectMakeGroups
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::TranslateObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::DirStruct& theVector)
+ throw (SALOME::SALOME_Exception)
+{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
+ SMESH::ListOfGroups * aGroups = 0;
+ TIDSortedElemSet elements;
+ prepareIdSource( theObject );
+ if (idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
+ aGroups = translate(elements, theVector, true, true);
+
+ if (!myIsPreviewMode) {
+ dumpGroupsList(aPythonDump, aGroups);
+ aPythonDump << this << ".TranslateObjectMakeGroups( "
+ << theObject << ", "
+ << theVector << " )";
+ }
+ return aGroups;
+}
+
+//=======================================================================
+//function : TranslateMakeMesh
+//purpose :
+//=======================================================================
+
+SMESH::SMESH_Mesh_ptr
+SMESH_MeshEditor_i::TranslateMakeMesh(const SMESH::long_array& theIDsOfElements,
+ const SMESH::DirStruct& theVector,
+ CORBA::Boolean theCopyGroups,
+ const char* theMeshName)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_Mesh_i* mesh_i;
+ SMESH::SMESH_Mesh_var mesh;
+
+ { // open new scope to dump "MakeMesh" command
+ // and then "GetGroups" using SMESH_Mesh::GetGroups()
+
+ TPythonDump pydump; // to prevent dump at mesh creation
+
+ mesh = makeMesh( theMeshName );
+ mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
+
+ if ( mesh_i && theIDsOfElements.length() )
+ {
+ TIDSortedElemSet elements;
+ arrayToSet(theIDsOfElements, getMeshDS(), elements);
+ translate(elements, theVector, false, theCopyGroups, & mesh_i->GetImpl());
+ mesh_i->CreateGroupServants();
+ }
+
+ if ( !myIsPreviewMode ) {
+ pydump << mesh << " = " << this << ".TranslateMakeMesh( "
+ << theIDsOfElements << ", "
+ << theVector << ", "
+ << theCopyGroups << ", '"
+ << theMeshName << "' )";
+ }
+ }
+
+ //dump "GetGroups"
+ if (!myIsPreviewMode && mesh_i)
+ mesh_i->GetGroups();
+
+ return mesh._retn();
+}
+
+//=======================================================================
+//function : TranslateObjectMakeMesh
+//purpose :
+//=======================================================================
+
+SMESH::SMESH_Mesh_ptr
+SMESH_MeshEditor_i::TranslateObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::DirStruct& theVector,
+ CORBA::Boolean theCopyGroups,
+ const char* theMeshName)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ SMESH_Mesh_i* mesh_i;
+ SMESH::SMESH_Mesh_var mesh;
+ { // open new scope to dump "MakeMesh" command
+ // and then "GetGroups" using SMESH_Mesh::GetGroups()
+
+ TPythonDump pydump; // to prevent dump at mesh creation
+ mesh = makeMesh( theMeshName );
+ mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
+
+ TIDSortedElemSet elements;
+ prepareIdSource( theObject );
+ if ( mesh_i &&
+ idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
+ {
+ translate(elements, theVector,false, theCopyGroups, & mesh_i->GetImpl());
+ mesh_i->CreateGroupServants();
+ }
+ if ( !myIsPreviewMode ) {
+ pydump << mesh << " = " << this << ".TranslateObjectMakeMesh( "
+ << theObject << ", "
+ << theVector << ", "
+ << theCopyGroups << ", '"
+ << theMeshName << "' )";
+ }
+ }
+
+ // dump "GetGroups"
+ if (!myIsPreviewMode && mesh_i)
+ mesh_i->GetGroups();
+
+ return mesh._retn();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//=======================================================================
+//function : rotate
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::rotate(TIDSortedElemSet & theElements,
+ const SMESH::AxisStruct & theAxis,
+ CORBA::Double theAngle,
+ CORBA::Boolean theCopy,
+ bool theMakeGroups,
+ ::SMESH_Mesh* theTargetMesh)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ initData();
+
+ 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);
+
+ TIDSortedElemSet copyElements;
+ TIDSortedElemSet* workElements = &theElements;
+ if ( myIsPreviewMode ) {
+ TPreviewMesh * tmpMesh = getPreviewMesh();
+ tmpMesh->Copy( theElements, copyElements );
+ if ( !theCopy && !theTargetMesh )
+ {
+ TIDSortedElemSet elemsAround, elemsAroundCopy;
+ getElementsAround( theElements, getMeshDS(), elemsAround );
+ tmpMesh->Copy( elemsAround, elemsAroundCopy);
+ }
+ workElements = ©Elements;
+ theMakeGroups = false;
+ }
+
+ ::SMESH_MeshEditor::PGroupIDs groupIds =
+ getEditor().Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
+
+ if ( theCopy && !myIsPreviewMode)
+ {
+ if ( theTargetMesh ) theTargetMesh->GetMeshDS()->Modified();
+ else declareMeshModified( /*isReComputeSafe=*/false );
+ }
+
+ return theMakeGroups ? getGroups(groupIds.get()) : 0;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//=======================================================================
+//function : Rotate
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::Rotate(const SMESH::long_array & theIDsOfElements,
+ const SMESH::AxisStruct & theAxis,
+ CORBA::Double theAngle,
+ CORBA::Boolean theCopy)
+ throw (SALOME::SALOME_Exception)
+{
+ if (!myIsPreviewMode) {
+ TPythonDump() << this << ".Rotate( "
+ << theIDsOfElements << ", "
+ << theAxis << ", "
+ << TVar( theAngle ) << ", "
+ << theCopy << " )";
+ }
+ if (theIDsOfElements.length() > 0)
+ {
+ TIDSortedElemSet elements;
+ arrayToSet(theIDsOfElements, getMeshDS(), elements);
+ rotate(elements,theAxis,theAngle,theCopy,false);
+ }
+}
+
+//=======================================================================
+//function : RotateObject
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::RotateObject(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::AxisStruct & theAxis,
+ CORBA::Double theAngle,
+ CORBA::Boolean theCopy)
+ throw (SALOME::SALOME_Exception)
+{
+ if ( !myIsPreviewMode ) {
+ TPythonDump() << this << ".RotateObject( "
+ << theObject << ", "
+ << theAxis << ", "
+ << TVar( theAngle ) << ", "
+ << theCopy << " )";
+ }
+ TIDSortedElemSet elements;
+ bool emptyIfIsMesh = myIsPreviewMode ? false : true;
+ prepareIdSource( theObject );
+ if (idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
+ rotate(elements,theAxis,theAngle,theCopy,false);
+}
+
+//=======================================================================
+//function : RotateMakeGroups
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::RotateMakeGroups(const SMESH::long_array& theIDsOfElements,
+ const SMESH::AxisStruct& theAxis,
+ CORBA::Double theAngle)
+ throw (SALOME::SALOME_Exception)
+{
+ 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 (!myIsPreviewMode) {
+ dumpGroupsList(aPythonDump, aGroups);
+ aPythonDump << this << ".RotateMakeGroups( "
+ << theIDsOfElements << ", "
+ << theAxis << ", "
+ << TVar( theAngle ) << " )";
+ }
+ return aGroups;
+}
+
+//=======================================================================
+//function : RotateObjectMakeGroups
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::RotateObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::AxisStruct& theAxis,
+ CORBA::Double theAngle)
+ throw (SALOME::SALOME_Exception)
+{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
+ SMESH::ListOfGroups * aGroups = 0;
+ TIDSortedElemSet elements;
+ prepareIdSource( theObject );
+ if (idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
+ aGroups = rotate(elements, theAxis, theAngle, true, true);
+
+ if (!myIsPreviewMode) {
+ dumpGroupsList(aPythonDump, aGroups);
+ aPythonDump << this << ".RotateObjectMakeGroups( "
+ << theObject << ", "
+ << theAxis << ", "
+ << TVar( theAngle ) << " )";
+ }
+ return aGroups;
+}
+
+//=======================================================================
+//function : RotateMakeMesh
+//purpose :
+//=======================================================================
+
+SMESH::SMESH_Mesh_ptr
+SMESH_MeshEditor_i::RotateMakeMesh(const SMESH::long_array& theIDsOfElements,
+ const SMESH::AxisStruct& theAxis,
+ CORBA::Double theAngleInRadians,
+ CORBA::Boolean theCopyGroups,
+ const char* theMeshName)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ SMESH::SMESH_Mesh_var mesh;
+ SMESH_Mesh_i* mesh_i;
+
+ { // open new scope to dump "MakeMesh" command
+ // and then "GetGroups" using SMESH_Mesh::GetGroups()
+
+ TPythonDump pydump; // to prevent dump at mesh creation
+
+ mesh = makeMesh( theMeshName );
+ mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
+
+ if ( mesh_i && theIDsOfElements.length() > 0 )
+ {
+ TIDSortedElemSet elements;
+ arrayToSet(theIDsOfElements, getMeshDS(), elements);
+ rotate(elements, theAxis, theAngleInRadians,
+ false, theCopyGroups, & mesh_i->GetImpl());
+ mesh_i->CreateGroupServants();
+ }
+ if ( !myIsPreviewMode ) {
+ pydump << mesh << " = " << this << ".RotateMakeMesh( "
+ << theIDsOfElements << ", "
+ << theAxis << ", "
+ << TVar( theAngleInRadians ) << ", "
+ << theCopyGroups << ", '"
+ << theMeshName << "' )";
+ }
+ }
+
+ // dump "GetGroups"
+ if (!myIsPreviewMode && mesh_i && theIDsOfElements.length() > 0 )
+ mesh_i->GetGroups();
+
+ return mesh._retn();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//=======================================================================
+//function : RotateObjectMakeMesh
+//purpose :
+//=======================================================================
+
+SMESH::SMESH_Mesh_ptr
+SMESH_MeshEditor_i::RotateObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::AxisStruct& theAxis,
+ CORBA::Double theAngleInRadians,
+ CORBA::Boolean theCopyGroups,
+ const char* theMeshName)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ SMESH::SMESH_Mesh_var mesh;
+ SMESH_Mesh_i* mesh_i;
+
+ {// open new scope to dump "MakeMesh" command
+ // and then "GetGroups" using SMESH_Mesh::GetGroups()
+
+ TPythonDump pydump; // to prevent dump at mesh creation
+ mesh = makeMesh( theMeshName );
+ mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
+
+ TIDSortedElemSet elements;
+ prepareIdSource( theObject );
+ if (mesh_i &&
+ idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
+ {
+ rotate(elements, theAxis, theAngleInRadians,
+ false, theCopyGroups, & mesh_i->GetImpl());
+ mesh_i->CreateGroupServants();
+ }
+ if ( !myIsPreviewMode ) {
+ pydump << mesh << " = " << this << ".RotateObjectMakeMesh( "
+ << theObject << ", "
+ << theAxis << ", "
+ << TVar( theAngleInRadians ) << ", "
+ << theCopyGroups << ", '"
+ << theMeshName << "' )";
+ }
+ }
+
+ // dump "GetGroups"
+ if (!myIsPreviewMode && mesh_i)
+ mesh_i->GetGroups();
+
+ return mesh._retn();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//=======================================================================
+//function : scale
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::scale(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::PointStruct& thePoint,
+ const SMESH::double_array& theScaleFact,
+ CORBA::Boolean theCopy,
+ bool theMakeGroups,
+ ::SMESH_Mesh* theTargetMesh)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ 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;
+ prepareIdSource( theObject );
+ bool emptyIfIsMesh = myIsPreviewMode ? false : true;
+ if ( !idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
+ return 0;
+
+ 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;
+ TIDSortedElemSet* workElements = &elements;
+ if ( myIsPreviewMode )
+ {
+ TPreviewMesh * tmpMesh = getPreviewMesh();
+ tmpMesh->Copy( elements, copyElements);
+ if ( !theCopy && !theTargetMesh )
+ {
+ TIDSortedElemSet elemsAround, elemsAroundCopy;
+ getElementsAround( elements, getMeshDS(), elemsAround );
+ tmpMesh->Copy( elemsAround, elemsAroundCopy);
+ }
+ workElements = & copyElements;
+ theMakeGroups = false;
+ }
+
+ ::SMESH_MeshEditor::PGroupIDs groupIds =
+ getEditor().Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
+
+ if ( theCopy && !myIsPreviewMode )
+ {
+ if ( theTargetMesh ) theTargetMesh->GetMeshDS()->Modified();
+ else declareMeshModified( /*isReComputeSafe=*/false );
+ }
+ return theMakeGroups ? getGroups(groupIds.get()) : 0;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//=======================================================================
+//function : Scale
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::Scale(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::PointStruct& thePoint,
+ const SMESH::double_array& theScaleFact,
+ CORBA::Boolean theCopy)
+ throw (SALOME::SALOME_Exception)
+{
+ if ( !myIsPreviewMode ) {
+ TPythonDump() << this << ".Scale( "
+ << theObject << ", "
+ << thePoint << ", "
+ << TVar( theScaleFact ) << ", "
+ << theCopy << " )";
+ }
+ scale(theObject, thePoint, theScaleFact, theCopy, false);
+}
+
+
+//=======================================================================
+//function : ScaleMakeGroups
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::ScaleMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::PointStruct& thePoint,
+ const SMESH::double_array& theScaleFact)
+ throw (SALOME::SALOME_Exception)
+{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
+ SMESH::ListOfGroups * aGroups = scale(theObject, thePoint, theScaleFact, true, true);
+ if (!myIsPreviewMode) {
+ dumpGroupsList(aPythonDump, aGroups);
+ aPythonDump << this << ".Scale("
+ << theObject << ","
+ << thePoint << ","
+ << TVar( theScaleFact ) << ",True,True)";
+ }
+ return aGroups;
+}
+
+
+//=======================================================================
+//function : ScaleMakeMesh
+//purpose :
+//=======================================================================
+
+SMESH::SMESH_Mesh_ptr
+SMESH_MeshEditor_i::ScaleMakeMesh(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::PointStruct& thePoint,
+ const SMESH::double_array& theScaleFact,
+ CORBA::Boolean theCopyGroups,
+ const char* theMeshName)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_Mesh_i* mesh_i;
+ SMESH::SMESH_Mesh_var mesh;
+ { // open new scope to dump "MakeMesh" command
+ // and then "GetGroups" using SMESH_Mesh::GetGroups()
+
+ TPythonDump pydump; // to prevent dump at mesh creation
+ mesh = makeMesh( theMeshName );
+ mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
+
+ if ( mesh_i )
+ {
+ scale(theObject, thePoint, theScaleFact,false, theCopyGroups, & mesh_i->GetImpl());
+ mesh_i->CreateGroupServants();
+ }
+ if ( !myIsPreviewMode )
+ pydump << mesh << " = " << this << ".ScaleMakeMesh( "
+ << theObject << ", "
+ << thePoint << ", "
+ << TVar( theScaleFact ) << ", "
+ << theCopyGroups << ", '"
+ << theMeshName << "' )";
+ }
+
+ // dump "GetGroups"
+ if (!myIsPreviewMode && mesh_i)
+ mesh_i->GetGroups();
+
+ return mesh._retn();
+}
+
+
+//=======================================================================
+//function : FindCoincidentNodes
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::FindCoincidentNodes (CORBA::Double Tolerance,
+ SMESH::array_of_long_array_out GroupsOfNodes)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ initData();
+
+ ::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
+ TIDSortedNodeSet nodes; // no input nodes
+ getEditor().FindCoincidentNodes( nodes, Tolerance, aListOfListOfNodes );
+
+ 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++ ) {
+ list< const SMDS_MeshNode* >& aListOfNodes = *llIt;
+ list< const SMDS_MeshNode* >::iterator lIt = aListOfNodes.begin();;
+ SMESH::long_array& aGroup = (*GroupsOfNodes)[ i ];
+ aGroup.length( aListOfNodes.size() );
+ for ( int j = 0; lIt != aListOfNodes.end(); lIt++, j++ )
+ aGroup[ j ] = (*lIt)->GetID();
+ }
+ TPythonDump() << "coincident_nodes = " << this << ".FindCoincidentNodes( "
+ << Tolerance << " )";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+}
+
+//=======================================================================
+//function : FindCoincidentNodesOnPart
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::FindCoincidentNodesOnPart(SMESH::SMESH_IDSource_ptr theObject,
+ CORBA::Double Tolerance,
+ SMESH::array_of_long_array_out GroupsOfNodes)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ initData();
+
+ TIDSortedNodeSet nodes;
+ prepareIdSource( theObject );
+ idSourceToNodeSet( theObject, getMeshDS(), nodes );
+
+ ::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
+ if(!nodes.empty())
+ getEditor().FindCoincidentNodes( nodes, Tolerance, aListOfListOfNodes );
+
+ 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++ )
+ {
+ list< const SMDS_MeshNode* >& aListOfNodes = *llIt;
+ list< const SMDS_MeshNode* >::iterator lIt = aListOfNodes.begin();;
+ SMESH::long_array& aGroup = (*GroupsOfNodes)[ i ];
+ aGroup.length( aListOfNodes.size() );
+ for ( int j = 0; lIt != aListOfNodes.end(); lIt++, j++ )
+ aGroup[ j ] = (*lIt)->GetID();
+ }
+ TPythonDump() << "coincident_nodes_on_part = " << this << ".FindCoincidentNodesOnPart( "
+ <<theObject<<", "
+ << Tolerance << " )";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+}
+
+//================================================================================
+/*!
+ * \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)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ initData();
+
+ TIDSortedNodeSet nodes;
+ prepareIdSource( theObject );
+ 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;
+ if(!nodes.empty())
+ getEditor().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 << " )";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+}
+
+//=======================================================================
+//function : MergeNodes
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ initData();
+
+ SMESHDS_Mesh* aMesh = getMeshDS();
+
+ TPythonDump aTPythonDump;
+ aTPythonDump << this << ".MergeNodes([";
+ ::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
+ for (int i = 0; i < GroupsOfNodes.length(); i++)
+ {
+ const SMESH::long_array& aNodeGroup = GroupsOfNodes[ i ];
+ aListOfListOfNodes.push_back( list< const SMDS_MeshNode* >() );
+ list< const SMDS_MeshNode* >& aListOfNodes = aListOfListOfNodes.back();
+ for ( int j = 0; j < aNodeGroup.length(); j++ )
+ {
+ CORBA::Long index = aNodeGroup[ j ];
+ const SMDS_MeshNode * node = aMesh->FindNode(index);
+ if ( node )
+ aListOfNodes.push_back( node );
+ }
+ if ( aListOfNodes.size() < 2 )
+ aListOfListOfNodes.pop_back();
+
+ if ( i > 0 ) aTPythonDump << ", ";
+ aTPythonDump << aNodeGroup;
+ }
+ getEditor().MergeNodes( aListOfListOfNodes );
+
+ aTPythonDump << "])";
+
+ declareMeshModified( /*isReComputeSafe=*/false );
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+}
+
+//=======================================================================
+//function : FindEqualElements
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::FindEqualElements(SMESH::SMESH_IDSource_ptr theObject,
+ SMESH::array_of_long_array_out GroupsOfElementsID)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ initData();
+
+ SMESH::SMESH_GroupBase_var group = SMESH::SMESH_GroupBase::_narrow(theObject);
+ if ( !(!group->_is_nil() && group->GetType() == SMESH::NODE) )
+ {
+ TIDSortedElemSet elems;
+ prepareIdSource( theObject );
+ idSourceToSet( theObject, getMeshDS(), elems, SMDSAbs_All, /*emptyIfIsMesh=*/true);
+
+ ::SMESH_MeshEditor::TListOfListOfElementsID aListOfListOfElementsID;
+ getEditor().FindEqualElements( elems, aListOfListOfElementsID );
+
+ GroupsOfElementsID = new SMESH::array_of_long_array;
+ GroupsOfElementsID->length( aListOfListOfElementsID.size() );
+
+ ::SMESH_MeshEditor::TListOfListOfElementsID::iterator arraysIt =
+ aListOfListOfElementsID.begin();
+ for (CORBA::Long j = 0; arraysIt != aListOfListOfElementsID.end(); ++arraysIt, ++j)
+ {
+ SMESH::long_array& aGroup = (*GroupsOfElementsID)[ j ];
+ list<int>& listOfIDs = *arraysIt;
+ aGroup.length( listOfIDs.size() );
+ list<int>::iterator idIt = listOfIDs.begin();
+ for (int k = 0; idIt != listOfIDs.end(); ++idIt, ++k )
+ aGroup[ k ] = *idIt;
+ }
+
+ TPythonDump() << "equal_elements = " << this << ".FindEqualElements( "
+ <<theObject<<" )";
+ }
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+}
+
+//=======================================================================
+//function : MergeElements
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::MergeElements(const SMESH::array_of_long_array& GroupsOfElementsID)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ initData();
+
+ TPythonDump aTPythonDump;
+ aTPythonDump << this << ".MergeElements( [";
+
+ ::SMESH_MeshEditor::TListOfListOfElementsID aListOfListOfElementsID;
+
+ for (int i = 0; i < GroupsOfElementsID.length(); i++) {
+ const SMESH::long_array& anElemsIDGroup = GroupsOfElementsID[ i ];
+ aListOfListOfElementsID.push_back( list< int >() );
+ list< int >& aListOfElemsID = aListOfListOfElementsID.back();
+ for ( int j = 0; j < anElemsIDGroup.length(); j++ ) {
+ CORBA::Long id = anElemsIDGroup[ j ];
+ aListOfElemsID.push_back( id );
+ }
+ if ( aListOfElemsID.size() < 2 )
+ aListOfListOfElementsID.pop_back();
+ if ( i > 0 ) aTPythonDump << ", ";
+ aTPythonDump << anElemsIDGroup;
+ }
+
+ getEditor().MergeElements(aListOfListOfElementsID);
+
+ declareMeshModified( /*isReComputeSafe=*/true );
+
+ aTPythonDump << "] )";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+}
+
+//=======================================================================
+//function : MergeEqualElements
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::MergeEqualElements()
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ initData();
+
+ getEditor().MergeEqualElements();
+
+ declareMeshModified( /*isReComputeSafe=*/true );
+
+ TPythonDump() << this << ".MergeEqualElements()";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+}
+
+//=============================================================================
+/*!
+ * Move the node to a given point
+ */
+//=============================================================================
+
+CORBA::Boolean SMESH_MeshEditor_i::MoveNode(CORBA::Long NodeID,
+ CORBA::Double x,
+ CORBA::Double y,
+ CORBA::Double z)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ initData(/*deleteSearchers=*/false);
+
+ const SMDS_MeshNode * node = getMeshDS()->FindNode( NodeID );
+ if ( !node )
+ return false;
+
+ if ( theNodeSearcher )
+ theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other
+
+ if ( myIsPreviewMode ) // make preview data
+ {
+ // in a preview mesh, make edges linked to a node
+ TPreviewMesh& tmpMesh = *getPreviewMesh();
+ 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
+ }
+ 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);
+
+ if ( !myIsPreviewMode )
+ {
+ // Update Python script
+ TPythonDump() << "isDone = " << this << ".MoveNode( "
+ << NodeID << ", " << TVar(x) << ", " << TVar(y) << ", " << TVar(z) << " )";
+ declareMeshModified( /*isReComputeSafe=*/false );
+ }
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+
+ return true;
+}
+
+//================================================================================
+/*!
+ * \brief Return ID of node closest to a given point
+ */
+//================================================================================
+
+CORBA::Long SMESH_MeshEditor_i::FindNodeClosestTo(CORBA::Double x,
+ CORBA::Double y,
+ CORBA::Double z)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other
+
+ if ( !theNodeSearcher ) {
+ theNodeSearcher = SMESH_MeshAlgos::GetNodeSearcher( *getMeshDS() );
+ }
+ gp_Pnt p( x,y,z );
+ if ( const SMDS_MeshNode* node = theNodeSearcher->FindClosestTo( p ))
+ return node->GetID();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//================================================================================
+/*!
+ * \brief If the given ID is a valid node ID (nodeID > 0), just move this node, else
+ * move the node closest to the point to point's location and return ID of the node
+ */
+//================================================================================
+
+CORBA::Long SMESH_MeshEditor_i::MoveClosestNodeToPoint(CORBA::Double x,
+ CORBA::Double y,
+ CORBA::Double z,
+ CORBA::Long theNodeID)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ // We keep theNodeSearcher until any mesh modification:
+ // 1) initData() deletes theNodeSearcher at any edition,
+ // 2) TSearchersDeleter - at any mesh compute event and mesh change
+
+ initData(/*deleteSearchers=*/false);
+
+ theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other
+
+ int nodeID = theNodeID;
+ const SMDS_MeshNode* node = getMeshDS()->FindNode( nodeID );
+ if ( !node ) // preview moving node
+ {
+ if ( !theNodeSearcher ) {
+ theNodeSearcher = SMESH_MeshAlgos::GetNodeSearcher( *getMeshDS() );
+ }
+ gp_Pnt p( x,y,z );
+ node = theNodeSearcher->FindClosestTo( p );
+ }
+ if ( node ) {
+ nodeID = node->GetID();
+ if ( myIsPreviewMode ) // make preview data
+ {
+ // in a preview mesh, make edges linked to a node
+ TPreviewMesh tmpMesh = *getPreviewMesh();
+ TIDSortedElemSet linkedNodes;
+ ::SMESH_MeshEditor::GetLinkedNodes( node, linkedNodes );
+ TIDSortedElemSet::iterator nIt = linkedNodes.begin();
+ for ( ; nIt != linkedNodes.end(); ++nIt )
+ {
+ SMDS_LinearEdge edge( node, cast2Node( *nIt ));
+ tmpMesh.Copy( &edge );
+ }
+ // move copied node
+ node = tmpMesh.GetMeshDS()->FindNode( nodeID );
+ if ( node )
+ tmpMesh.GetMeshDS()->MoveNode(node, x, y, z);
+ // fill preview data
+ }
+ 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);
+ }
+ }
+
+ if ( !myIsPreviewMode )
+ {
+ TPythonDump() << "nodeID = " << this
+ << ".MoveClosestNodeToPoint( "<< x << ", " << y << ", " << z
+ << ", " << nodeID << " )";
+
+ declareMeshModified( /*isReComputeSafe=*/false );
+ }
+
+ return nodeID;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//=======================================================================
+/*!
+ * Return elements of given type where the given point is IN or ON.
+ *
+ * 'ALL' type means elements of any type excluding nodes
+ */
+//=======================================================================
+
+SMESH::long_array* SMESH_MeshEditor_i::FindElementsByPoint(CORBA::Double x,
+ CORBA::Double y,
+ CORBA::Double z,
+ SMESH::ElementType type)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ SMESH::long_array_var res = new SMESH::long_array;
+ vector< const SMDS_MeshElement* > foundElems;
+
+ theSearchersDeleter.Set( myMesh );
+ if ( !theElementSearcher ) {
+ theElementSearcher = SMESH_MeshAlgos::GetElementSearcher( *getMeshDS() );
+ }
+ theElementSearcher->FindElementsByPoint( gp_Pnt( x,y,z ),
+ SMDSAbs_ElementType( type ),
+ foundElems);
+ res->length( foundElems.size() );
+ for ( int i = 0; i < foundElems.size(); ++i )
+ res[i] = foundElems[i]->GetID();
+
+ if ( !myIsPreviewMode ) // call from tui
+ TPythonDump() << "res = " << this << ".FindElementsByPoint( "
+ << x << ", "
+ << y << ", "
+ << z << ", "
+ << type << " )";
+
+ return res._retn();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//=======================================================================
+//function : FindAmongElementsByPoint
+//purpose : Searching among the given elements, return elements of given type
+// where the given point is IN or ON.
+// 'ALL' type means elements of any type excluding nodes
+//=======================================================================
+
+SMESH::long_array*
+SMESH_MeshEditor_i::FindAmongElementsByPoint(SMESH::SMESH_IDSource_ptr elementIDs,
+ CORBA::Double x,
+ CORBA::Double y,
+ CORBA::Double z,
+ SMESH::ElementType type)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ SMESH::long_array_var res = new SMESH::long_array;
+
+ SMESH::array_of_ElementType_var types = elementIDs->GetTypes();
+ if ( types->length() == 1 && // a part contains only nodes or 0D elements
+ ( types[0] == SMESH::NODE || types[0] == SMESH::ELEM0D || types[0] == SMESH::BALL) &&
+ type != types[0] ) // but search of elements of dim > 0
+ return res._retn();
+
+ if ( SMESH::DownCast<SMESH_Mesh_i*>( elementIDs )) // elementIDs is the whole mesh
+ return FindElementsByPoint( x,y,z, type );
+
+ TIDSortedElemSet elements; // elems should live until FindElementsByPoint() finishes
+
+ theSearchersDeleter.Set( myMesh, getPartIOR( elementIDs, type ));
+ if ( !theElementSearcher )
+ {
+ // create a searcher from elementIDs
+ SMESH::SMESH_Mesh_var mesh = elementIDs->GetMesh();
+ SMESHDS_Mesh* meshDS = SMESH::DownCast<SMESH_Mesh_i*>( mesh )->GetImpl().GetMeshDS();
+
+ if ( !idSourceToSet( elementIDs, meshDS, elements,
+ SMDSAbs_ElementType(type), /*emptyIfIsMesh=*/true))
+ return res._retn();
+
+ typedef SMDS_SetIterator<const SMDS_MeshElement*, TIDSortedElemSet::const_iterator > TIter;
+ SMDS_ElemIteratorPtr elemsIt( new TIter( elements.begin(), elements.end() ));
+
+ theElementSearcher = SMESH_MeshAlgos::GetElementSearcher( *getMeshDS(), elemsIt );
+ }
+
+ vector< const SMDS_MeshElement* > foundElems;
+
+ theElementSearcher->FindElementsByPoint( gp_Pnt( x,y,z ),
+ SMDSAbs_ElementType( type ),
+ foundElems);
+ res->length( foundElems.size() );
+ for ( int i = 0; i < foundElems.size(); ++i )
+ res[i] = foundElems[i]->GetID();
+
+ if ( !myIsPreviewMode ) // call from tui
+ TPythonDump() << "res = " << this << ".FindAmongElementsByPoint( "
+ << elementIDs << ", "
+ << x << ", "
+ << y << ", "
+ << z << ", "
+ << type << " )";
+
+ return res._retn();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//=======================================================================
+//function : GetPointState
+//purpose : Return point state in a closed 2D mesh in terms of TopAbs_State enumeration.
+// TopAbs_UNKNOWN state means that either mesh is wrong or the analysis fails.
+//=======================================================================
+
+CORBA::Short SMESH_MeshEditor_i::GetPointState(CORBA::Double x,
+ CORBA::Double y,
+ CORBA::Double z)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ theSearchersDeleter.Set( myMesh );
+ if ( !theElementSearcher ) {
+ theElementSearcher = SMESH_MeshAlgos::GetElementSearcher( *getMeshDS() );
+ }
+ return CORBA::Short( theElementSearcher->GetPointState( gp_Pnt( x,y,z )));
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//=======================================================================
+//function : convError
+//purpose :
+//=======================================================================
+
+#define RETCASE(enm) case ::SMESH_MeshEditor::enm: return SMESH::SMESH_MeshEditor::enm;
+
+static SMESH::SMESH_MeshEditor::Sew_Error convError( const::SMESH_MeshEditor::Sew_Error e )
+{
+ switch ( e ) {
+ RETCASE( SEW_OK );
+ RETCASE( SEW_BORDER1_NOT_FOUND );
+ RETCASE( SEW_BORDER2_NOT_FOUND );
+ RETCASE( SEW_BOTH_BORDERS_NOT_FOUND );
+ RETCASE( SEW_BAD_SIDE_NODES );
+ RETCASE( SEW_VOLUMES_TO_SPLIT );
+ RETCASE( SEW_DIFF_NB_OF_ELEMENTS );
+ RETCASE( SEW_TOPO_DIFF_SETS_OF_ELEMENTS );
+ RETCASE( SEW_BAD_SIDE1_NODES );
+ RETCASE( SEW_BAD_SIDE2_NODES );
+ }
+ return SMESH::SMESH_MeshEditor::SEW_OK;
+}
+
+//=======================================================================
+//function : SewFreeBorders
+//purpose :
+//=======================================================================
+
+SMESH::SMESH_MeshEditor::Sew_Error
+SMESH_MeshEditor_i::SewFreeBorders(CORBA::Long FirstNodeID1,
+ CORBA::Long SecondNodeID1,
+ CORBA::Long LastNodeID1,
+ CORBA::Long FirstNodeID2,
+ CORBA::Long SecondNodeID2,
+ CORBA::Long LastNodeID2,
+ CORBA::Boolean CreatePolygons,
+ CORBA::Boolean CreatePolyedrs)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ initData();
+
+ SMESHDS_Mesh* aMesh = getMeshDS();
+
+ const SMDS_MeshNode* aBorderFirstNode = aMesh->FindNode( FirstNodeID1 );
+ const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeID1 );
+ const SMDS_MeshNode* aBorderLastNode = aMesh->FindNode( LastNodeID1 );
+ const SMDS_MeshNode* aSide2FirstNode = aMesh->FindNode( FirstNodeID2 );
+ const SMDS_MeshNode* aSide2SecondNode = aMesh->FindNode( SecondNodeID2 );
+ const SMDS_MeshNode* aSide2ThirdNode = aMesh->FindNode( LastNodeID2 );
+
+ if (!aBorderFirstNode ||
+ !aBorderSecondNode||
+ !aBorderLastNode)
+ return SMESH::SMESH_MeshEditor::SEW_BORDER1_NOT_FOUND;
+ if (!aSide2FirstNode ||
+ !aSide2SecondNode ||
+ !aSide2ThirdNode)
+ return SMESH::SMESH_MeshEditor::SEW_BORDER2_NOT_FOUND;
+
+ TPythonDump() << "error = " << this << ".SewFreeBorders( "
+ << FirstNodeID1 << ", "
+ << SecondNodeID1 << ", "
+ << LastNodeID1 << ", "
+ << FirstNodeID2 << ", "
+ << SecondNodeID2 << ", "
+ << LastNodeID2 << ", "
+ << CreatePolygons<< ", "
+ << CreatePolyedrs<< " )";
+
+ SMESH::SMESH_MeshEditor::Sew_Error error =
+ convError( getEditor().SewFreeBorder (aBorderFirstNode,
+ aBorderSecondNode,
+ aBorderLastNode,
+ aSide2FirstNode,
+ aSide2SecondNode,
+ aSide2ThirdNode,
+ true,
+ CreatePolygons,
+ CreatePolyedrs) );
+
+
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return error;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return SMESH::SMESH_MeshEditor::Sew_Error(0);
}
//=======================================================================
-//function : ExtrusionAlongPathMakeGroups
-//purpose :
+//function : SewConformFreeBorders
+//purpose :
//=======================================================================
-SMESH::ListOfGroups*
-SMESH_MeshEditor_i::ExtrusionAlongPathMakeGroups(const SMESH::long_array& theIDsOfElements,
- SMESH::SMESH_Mesh_ptr thePathMesh,
- GEOM::GEOM_Object_ptr thePathShape,
- CORBA::Long theNodeStart,
- CORBA::Boolean theHasAngles,
- const SMESH::double_array& theAngles,
- CORBA::Boolean theHasRefPoint,
- const SMESH::PointStruct& theRefPoint,
- SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
+SMESH::SMESH_MeshEditor::Sew_Error
+SMESH_MeshEditor_i::SewConformFreeBorders(CORBA::Long FirstNodeID1,
+ CORBA::Long SecondNodeID1,
+ CORBA::Long LastNodeID1,
+ CORBA::Long FirstNodeID2,
+ CORBA::Long SecondNodeID2)
+ throw (SALOME::SALOME_Exception)
{
- if ( !myPreviewMode ) {
- TPythonDump() << "rotAngles = " << theAngles;
+ SMESH_TRY;
+ initData();
- if ( theHasRefPoint )
- TPythonDump() << "refPoint = SMESH.PointStruct( "
- << theRefPoint.x << ", "
- << theRefPoint.y << ", "
- << theRefPoint.z << " )";
- else
- TPythonDump() << "refPoint = SMESH.PointStruct( 0,0,0 )";
+ SMESHDS_Mesh* aMesh = getMeshDS();
- TPythonDump() << "groups = " << this << ".ExtrusionAlongPathMakeGroups( "
- << theIDsOfElements << ", "
- << thePathMesh << ", "
- << thePathShape << ", "
- << theNodeStart << ", "
- << theHasAngles << ", "
- << "rotAngles" << ", "
- << theHasRefPoint << ", refPoint )";
- }
- return extrusionAlongPath( theIDsOfElements,
- thePathMesh,
- thePathShape,
- theNodeStart,
- theHasAngles,
- theAngles,
- theHasRefPoint,
- theRefPoint,
- true,
- Error);
+ const SMDS_MeshNode* aBorderFirstNode = aMesh->FindNode( FirstNodeID1 );
+ const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeID1 );
+ const SMDS_MeshNode* aBorderLastNode = aMesh->FindNode( LastNodeID1 );
+ const SMDS_MeshNode* aSide2FirstNode = aMesh->FindNode( FirstNodeID2 );
+ const SMDS_MeshNode* aSide2SecondNode = aMesh->FindNode( SecondNodeID2 );
+ const SMDS_MeshNode* aSide2ThirdNode = 0;
+
+ if (!aBorderFirstNode ||
+ !aBorderSecondNode||
+ !aBorderLastNode )
+ return SMESH::SMESH_MeshEditor::SEW_BORDER1_NOT_FOUND;
+ if (!aSide2FirstNode ||
+ !aSide2SecondNode)
+ return SMESH::SMESH_MeshEditor::SEW_BORDER2_NOT_FOUND;
+
+ TPythonDump() << "error = " << this << ".SewConformFreeBorders( "
+ << FirstNodeID1 << ", "
+ << SecondNodeID1 << ", "
+ << LastNodeID1 << ", "
+ << FirstNodeID2 << ", "
+ << SecondNodeID2 << " )";
+
+ SMESH::SMESH_MeshEditor::Sew_Error error =
+ convError( getEditor().SewFreeBorder (aBorderFirstNode,
+ aBorderSecondNode,
+ aBorderLastNode,
+ aSide2FirstNode,
+ aSide2SecondNode,
+ aSide2ThirdNode,
+ true,
+ false, false) );
+
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return error;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return SMESH::SMESH_MeshEditor::Sew_Error(0);
}
+
//=======================================================================
-//function : ExtrusionAlongPathObjectMakeGroups
-//purpose :
+//function : SewBorderToSide
+//purpose :
//=======================================================================
-SMESH::ListOfGroups* SMESH_MeshEditor_i::
-ExtrusionAlongPathObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
- SMESH::SMESH_Mesh_ptr thePathMesh,
- GEOM::GEOM_Object_ptr thePathShape,
- CORBA::Long theNodeStart,
- CORBA::Boolean theHasAngles,
- const SMESH::double_array& theAngles,
- CORBA::Boolean theHasRefPoint,
- const SMESH::PointStruct& theRefPoint,
- SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
+SMESH::SMESH_MeshEditor::Sew_Error
+SMESH_MeshEditor_i::SewBorderToSide(CORBA::Long FirstNodeIDOnFreeBorder,
+ CORBA::Long SecondNodeIDOnFreeBorder,
+ CORBA::Long LastNodeIDOnFreeBorder,
+ CORBA::Long FirstNodeIDOnSide,
+ CORBA::Long LastNodeIDOnSide,
+ CORBA::Boolean CreatePolygons,
+ CORBA::Boolean CreatePolyedrs)
+ throw (SALOME::SALOME_Exception)
{
- if ( !myPreviewMode ) {
- TPythonDump() << "rotAngles = " << theAngles;
+ SMESH_TRY;
+ initData();
- if ( theHasRefPoint )
- TPythonDump() << "refPoint = SMESH.PointStruct( "
- << theRefPoint.x << ", "
- << theRefPoint.y << ", "
- << theRefPoint.z << " )";
- else
- TPythonDump() << "refPoint = SMESH.PointStruct( 0,0,0 )";
+ SMESHDS_Mesh* aMesh = getMeshDS();
- TPythonDump() << "groups = " << this << ".ExtrusionAlongPathObjectMakeGroups( "
- << theObject << ", "
- << thePathMesh << ", "
- << thePathShape << ", "
- << theNodeStart << ", "
- << theHasAngles << ", "
- << "rotAngles" << ", "
- << theHasRefPoint << ", refPoint )";
- }
- SMESH::long_array_var anElementsId = theObject->GetIDs();
- return extrusionAlongPath( anElementsId,
- thePathMesh,
- thePathShape,
- theNodeStart,
- theHasAngles,
- theAngles,
- theHasRefPoint,
- theRefPoint,
- true,
- Error);
+ const SMDS_MeshNode* aBorderFirstNode = aMesh->FindNode( FirstNodeIDOnFreeBorder );
+ const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeIDOnFreeBorder );
+ const SMDS_MeshNode* aBorderLastNode = aMesh->FindNode( LastNodeIDOnFreeBorder );
+ const SMDS_MeshNode* aSide2FirstNode = aMesh->FindNode( FirstNodeIDOnSide );
+ const SMDS_MeshNode* aSide2SecondNode = aMesh->FindNode( LastNodeIDOnSide );
+ const SMDS_MeshNode* aSide2ThirdNode = 0;
+
+ if (!aBorderFirstNode ||
+ !aBorderSecondNode||
+ !aBorderLastNode )
+ return SMESH::SMESH_MeshEditor::SEW_BORDER1_NOT_FOUND;
+ if (!aSide2FirstNode ||
+ !aSide2SecondNode)
+ return SMESH::SMESH_MeshEditor::SEW_BAD_SIDE_NODES;
+
+ TPythonDump() << "error = " << this << ".SewBorderToSide( "
+ << FirstNodeIDOnFreeBorder << ", "
+ << SecondNodeIDOnFreeBorder << ", "
+ << LastNodeIDOnFreeBorder << ", "
+ << FirstNodeIDOnSide << ", "
+ << LastNodeIDOnSide << ", "
+ << CreatePolygons << ", "
+ << CreatePolyedrs << ") ";
+
+ SMESH::SMESH_MeshEditor::Sew_Error error =
+ convError( getEditor().SewFreeBorder (aBorderFirstNode,
+ aBorderSecondNode,
+ aBorderLastNode,
+ aSide2FirstNode,
+ aSide2SecondNode,
+ aSide2ThirdNode,
+ false,
+ CreatePolygons,
+ CreatePolyedrs) );
+
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return error;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return SMESH::SMESH_MeshEditor::Sew_Error(0);
+}
+
+
+//=======================================================================
+//function : SewSideElements
+//purpose :
+//=======================================================================
+
+SMESH::SMESH_MeshEditor::Sew_Error
+SMESH_MeshEditor_i::SewSideElements(const SMESH::long_array& IDsOfSide1Elements,
+ const SMESH::long_array& IDsOfSide2Elements,
+ CORBA::Long NodeID1OfSide1ToMerge,
+ CORBA::Long NodeID1OfSide2ToMerge,
+ CORBA::Long NodeID2OfSide1ToMerge,
+ CORBA::Long NodeID2OfSide2ToMerge)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ initData();
+
+ SMESHDS_Mesh* aMesh = getMeshDS();
+
+ const SMDS_MeshNode* aFirstNode1ToMerge = aMesh->FindNode( NodeID1OfSide1ToMerge );
+ const SMDS_MeshNode* aFirstNode2ToMerge = aMesh->FindNode( NodeID1OfSide2ToMerge );
+ const SMDS_MeshNode* aSecondNode1ToMerge = aMesh->FindNode( NodeID2OfSide1ToMerge );
+ const SMDS_MeshNode* aSecondNode2ToMerge = aMesh->FindNode( NodeID2OfSide2ToMerge );
+
+ if (!aFirstNode1ToMerge ||
+ !aFirstNode2ToMerge )
+ return SMESH::SMESH_MeshEditor::SEW_BAD_SIDE1_NODES;
+ if (!aSecondNode1ToMerge||
+ !aSecondNode2ToMerge)
+ return SMESH::SMESH_MeshEditor::SEW_BAD_SIDE2_NODES;
+
+ TIDSortedElemSet aSide1Elems, aSide2Elems;
+ arrayToSet(IDsOfSide1Elements, aMesh, aSide1Elems);
+ arrayToSet(IDsOfSide2Elements, aMesh, aSide2Elems);
+
+ TPythonDump() << "error = " << this << ".SewSideElements( "
+ << IDsOfSide1Elements << ", "
+ << IDsOfSide2Elements << ", "
+ << NodeID1OfSide1ToMerge << ", "
+ << NodeID1OfSide2ToMerge << ", "
+ << NodeID2OfSide1ToMerge << ", "
+ << NodeID2OfSide2ToMerge << ")";
+
+ SMESH::SMESH_MeshEditor::Sew_Error error =
+ convError( getEditor().SewSideElements (aSide1Elems, aSide2Elems,
+ aFirstNode1ToMerge,
+ aFirstNode2ToMerge,
+ aSecondNode1ToMerge,
+ aSecondNode2ToMerge));
+
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return error;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return SMESH::SMESH_MeshEditor::Sew_Error(0);
}
//================================================================================
/*!
- * \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
- * which proceeds the extrusion
- * \param PathShape is shape(edge); as the mesh can be complex, the edge
- * is used to define the sub-mesh for the path
+ * \brief Set new nodes for given element
+ * \param ide - element id
+ * \param newIDs - new node ids
+ * \retval CORBA::Boolean - true if result is OK
*/
//================================================================================
-SMESH::double_array*
-SMESH_MeshEditor_i::LinearAnglesVariation(SMESH::SMESH_Mesh_ptr thePathMesh,
- GEOM::GEOM_Object_ptr thePathShape,
- const SMESH::double_array & theAngles)
-{
- SMESH::double_array_var aResult = new SMESH::double_array();
- return aResult._retn();
+CORBA::Boolean SMESH_MeshEditor_i::ChangeElemNodes(CORBA::Long ide,
+ const SMESH::long_array& newIDs)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ initData();
+
+ const SMDS_MeshElement* elem = getMeshDS()->FindElement(ide);
+ if(!elem) return false;
+
+ int nbn = newIDs.length();
+ int i=0;
+ vector<const SMDS_MeshNode*> aNodes(nbn);
+ int nbn1=-1;
+ for(; i<nbn; i++) {
+ const SMDS_MeshNode* aNode = getMeshDS()->FindNode(newIDs[i]);
+ if(aNode) {
+ nbn1++;
+ aNodes[nbn1] = aNode;
+ }
+ }
+ TPythonDump() << "isDone = " << this << ".ChangeElemNodes( "
+ << ide << ", " << newIDs << " )";
+
+ MESSAGE("ChangeElementNodes");
+ bool res = getMeshDS()->ChangeElementNodes( elem, & aNodes[0], nbn1+1 );
+
+ declareMeshModified( /*isReComputeSafe=*/ !res );
+
+ return res;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
-
//=======================================================================
-//function : mirror
-//purpose :
+/*!
+ * \brief Makes a part of the mesh quadratic or bi-quadratic
+ */
//=======================================================================
-SMESH::ListOfGroups*
-SMESH_MeshEditor_i::mirror(const SMESH::long_array & theIDsOfElements,
- const SMESH::AxisStruct & theAxis,
- SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
- CORBA::Boolean theCopy,
- const bool theMakeGroups,
- ::SMESH_Mesh* theTargetMesh)
+void SMESH_MeshEditor_i::convertToQuadratic(CORBA::Boolean theForce3d,
+ CORBA::Boolean theToBiQuad,
+ SMESH::SMESH_IDSource_ptr theObject)
+ throw (SALOME::SALOME_Exception)
{
- 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 );
-
- gp_Trsf aTrsf;
- switch ( theMirrorType ) {
- case SMESH::SMESH_MeshEditor::POINT:
- aTrsf.SetMirror( P );
- break;
- case SMESH::SMESH_MeshEditor::AXIS:
- aTrsf.SetMirror( gp_Ax1( P, V ));
- break;
- default:
- aTrsf.SetMirror( gp_Ax2( P, V ));
+ SMESH_TRY;
+ TIDSortedElemSet elems;
+ bool elemsOK;
+ if ( !( elemsOK = CORBA::is_nil( theObject )))
+ {
+ prepareIdSource( theObject );
+ elemsOK = idSourceToSet( theObject, getMeshDS(), elems,
+ SMDSAbs_All, /*emptyIfIsMesh=*/true );
}
+ if ( elemsOK )
+ {
+ if ( !elems.empty() && (*elems.begin())->GetType() == SMDSAbs_Node )
+ THROW_SALOME_CORBA_EXCEPTION("Group of nodes is not allowed", SALOME::BAD_PARAM);
- ::SMESH_MeshEditor anEditor( myMesh );
- ::SMESH_MeshEditor::PGroupIDs groupIds =
- anEditor.Transform (elements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
+ if ( elems.empty() ) getEditor().ConvertToQuadratic(theForce3d, theToBiQuad);
+ else getEditor().ConvertToQuadratic(theForce3d, elems, theToBiQuad);
- if(theCopy) {
- storeResult(anEditor);
+ declareMeshModified( /*isReComputeSafe=*/false );
}
- return theMakeGroups ? getGroups(groupIds.get()) : 0;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//=======================================================================
-//function : Mirror
+//function : ConvertFromQuadratic
//purpose :
//=======================================================================
-void SMESH_MeshEditor_i::Mirror(const SMESH::long_array & theIDsOfElements,
- const SMESH::AxisStruct & theAxis,
- SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
- CORBA::Boolean theCopy)
+CORBA::Boolean SMESH_MeshEditor_i::ConvertFromQuadratic()
+ throw (SALOME::SALOME_Exception)
{
- if ( !myPreviewMode ) {
- TPythonDump() << this << ".Mirror( "
- << theIDsOfElements << ", "
- << theAxis << ", "
- << mirrorTypeName(theMirrorType) << ", "
- << theCopy << " )";
- }
- mirror(theIDsOfElements, theAxis, theMirrorType, theCopy, false);
+ CORBA::Boolean isDone = getEditor().ConvertFromQuadratic();
+ TPythonDump() << this << ".ConvertFromQuadratic()";
+ declareMeshModified( /*isReComputeSafe=*/!isDone );
+ return isDone;
}
-
//=======================================================================
-//function : MirrorObject
+//function : ConvertToQuadratic
//purpose :
//=======================================================================
-void SMESH_MeshEditor_i::MirrorObject(SMESH::SMESH_IDSource_ptr theObject,
- const SMESH::AxisStruct & theAxis,
- SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
- CORBA::Boolean theCopy)
+void SMESH_MeshEditor_i::ConvertToQuadratic(CORBA::Boolean theForce3d)
+ throw (SALOME::SALOME_Exception)
{
- if ( !myPreviewMode ) {
- TPythonDump() << this << ".MirrorObject( "
- << theObject << ", "
- << theAxis << ", "
- << mirrorTypeName(theMirrorType) << ", "
- << theCopy << " )";
- }
- SMESH::long_array_var anElementsId = theObject->GetIDs();
- mirror(anElementsId, theAxis, theMirrorType, theCopy, false);
+ convertToQuadratic( theForce3d, false );
+ TPythonDump() << this << ".ConvertToQuadratic("<<theForce3d<<")";
}
-//=======================================================================
-//function : MirrorMakeGroups
-//purpose :
-//=======================================================================
+//================================================================================
+/*!
+ * \brief Makes a part of the mesh quadratic
+ */
+//================================================================================
-SMESH::ListOfGroups*
-SMESH_MeshEditor_i::MirrorMakeGroups(const SMESH::long_array& theIDsOfElements,
- const SMESH::AxisStruct& theMirror,
- SMESH::SMESH_MeshEditor::MirrorType theMirrorType)
+void SMESH_MeshEditor_i::ConvertToQuadraticObject(CORBA::Boolean theForce3d,
+ SMESH::SMESH_IDSource_ptr theObject)
+ throw (SALOME::SALOME_Exception)
{
- if ( !myPreviewMode ) {
- TPythonDump() << this << ".MirrorMakeGroups( "
- << theIDsOfElements << ", "
- << theMirror << ", "
- << mirrorTypeName(theMirrorType) << " )";
- }
- return mirror(theIDsOfElements, theMirror, theMirrorType, true, true);
+ convertToQuadratic( theForce3d, false, theObject );
+ TPythonDump() << this << ".ConvertToQuadraticObject("<<theForce3d<<", "<<theObject<<")";
}
-//=======================================================================
-//function : MirrorObjectMakeGroups
-//purpose :
-//=======================================================================
+//================================================================================
+/*!
+ * \brief Makes a part of the mesh bi-quadratic
+ */
+//================================================================================
-SMESH::ListOfGroups*
-SMESH_MeshEditor_i::MirrorObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
- const SMESH::AxisStruct& theMirror,
- SMESH::SMESH_MeshEditor::MirrorType theMirrorType)
+void SMESH_MeshEditor_i::ConvertToBiQuadratic(CORBA::Boolean theForce3d,
+ SMESH::SMESH_IDSource_ptr theObject)
+ throw (SALOME::SALOME_Exception)
{
- if ( !myPreviewMode ) {
- TPythonDump() << this << ".MirrorObjectMakeGroups( "
- << theObject << ", "
- << theMirror << ", "
- << mirrorTypeName(theMirrorType) << " )";
- }
- SMESH::long_array_var anElementsId = theObject->GetIDs();
- return mirror(anElementsId, theMirror, theMirrorType, true, true);
+ convertToQuadratic( theForce3d, true, theObject );
+ TPythonDump() << this << ".ConvertToBiQuadratic("<<theForce3d<<", "<<theObject<<")";
}
-//=======================================================================
-//function : MirrorMakeMesh
-//purpose :
-//=======================================================================
+//================================================================================
+/*!
+ * \brief Makes a part of the mesh linear
+ */
+//================================================================================
-SMESH::SMESH_Mesh_ptr
-SMESH_MeshEditor_i::MirrorMakeMesh(const SMESH::long_array& theIDsOfElements,
- const SMESH::AxisStruct& theMirror,
- SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
- CORBA::Boolean theCopyGroups,
- const char* theMeshName)
+void SMESH_MeshEditor_i::ConvertFromQuadraticObject(SMESH::SMESH_IDSource_ptr theObject)
+ throw (SALOME::SALOME_Exception)
{
- TPythonDump pydump; // to prevent dump at mesh creation
+ SMESH_TRY;
+
+ TPythonDump pyDump;
- SMESH::SMESH_Mesh_var mesh = makeMesh( theMeshName );
- if ( SMESH_Mesh_i* mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh ))
+ TIDSortedElemSet elems;
+ prepareIdSource( theObject );
+ if ( idSourceToSet( theObject, getMeshDS(), elems, SMDSAbs_All, /*emptyIfIsMesh=*/true ))
{
- mirror(theIDsOfElements, theMirror, theMirrorType,
- false, theCopyGroups, & mesh_i->GetImpl());
- mesh_i->CreateGroupServants();
+ 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
+ {
+ getEditor().ConvertFromQuadratic(elems);
+ }
}
+ declareMeshModified( /*isReComputeSafe=*/false );
- if ( !myPreviewMode ) {
- pydump << mesh << " = " << this << ".MirrorMakeMesh( "
- << theIDsOfElements << ", "
- << theMirror << ", "
- << mirrorTypeName(theMirrorType) << ", "
- << theCopyGroups << ", '"
- << theMeshName << "' )";
- }
- return mesh._retn();
+ pyDump << this << ".ConvertFromQuadraticObject( "<<theObject<<" )";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//=======================================================================
-//function : MirrorObjectMakeMesh
-//purpose :
+//function : makeMesh
+//purpose : create a named imported mesh
//=======================================================================
-SMESH::SMESH_Mesh_ptr
-SMESH_MeshEditor_i::MirrorObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject,
- const SMESH::AxisStruct& theMirror,
- SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
- CORBA::Boolean theCopyGroups,
- const char* theMeshName)
+SMESH::SMESH_Mesh_ptr SMESH_MeshEditor_i::makeMesh(const char* theMeshName)
{
- TPythonDump pydump; // to prevent dump at mesh creation
+ SMESH_Gen_i* gen = SMESH_Gen_i::GetSMESHGen();
+ SMESH::SMESH_Mesh_var mesh = gen->CreateEmptyMesh();
+ SALOMEDS::Study_var study = gen->GetCurrentStudy();
+ SALOMEDS::SObject_wrap meshSO = gen->ObjectToSObject( study, mesh );
+ gen->SetName( meshSO, theMeshName, "Mesh" );
+ gen->SetPixMap( meshSO, "ICON_SMESH_TREE_MESH_IMPORTED");
- SMESH::SMESH_Mesh_var mesh = makeMesh( theMeshName );
- if ( SMESH_Mesh_i* mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh ))
- {
- SMESH::long_array_var anElementsId = theObject->GetIDs();
- mirror(anElementsId, theMirror, theMirrorType,
- false, theCopyGroups, & mesh_i->GetImpl());
- mesh_i->CreateGroupServants();
- }
- if ( !myPreviewMode ) {
- pydump << mesh << " = " << this << ".MirrorObjectMakeMesh( "
- << theObject << ", "
- << theMirror << ", "
- << mirrorTypeName(theMirrorType) << ", "
- << theCopyGroups << ", '"
- << theMeshName << "' )";
- }
return mesh._retn();
}
//=======================================================================
-//function : translate
-//purpose :
+//function : dumpGroupsList
+//purpose :
//=======================================================================
-SMESH::ListOfGroups*
-SMESH_MeshEditor_i::translate(const SMESH::long_array & theIDsOfElements,
- const SMESH::DirStruct & theVector,
- CORBA::Boolean theCopy,
- const bool theMakeGroups,
- ::SMESH_Mesh* theTargetMesh)
+void SMESH_MeshEditor_i::dumpGroupsList(TPythonDump & theDumpPython,
+ const SMESH::ListOfGroups * theGroupList)
{
- initData();
-
- TIDSortedElemSet elements;
- arrayToSet(theIDsOfElements, GetMeshDS(), elements);
-
- gp_Trsf aTrsf;
- const SMESH::PointStruct * P = &theVector.PS;
- aTrsf.SetTranslation( gp_Vec( P->x, P->y, P->z ));
-
- ::SMESH_MeshEditor anEditor( myMesh );
- ::SMESH_MeshEditor::PGroupIDs groupIds =
- anEditor.Transform (elements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
-
- if(theCopy)
- storeResult(anEditor);
-
- return theMakeGroups ? getGroups(groupIds.get()) : 0;
+ bool isDumpGroupList = ( theGroupList && theGroupList->length() > 0 );
+ if ( isDumpGroupList )
+ theDumpPython << theGroupList << " = ";
}
-//=======================================================================
-//function : Translate
-//purpose :
-//=======================================================================
+//================================================================================
+/*!
+ \brief Generates the unique group name.
+ \param thePrefix name prefix
+ \return unique name
+*/
+//================================================================================
-void SMESH_MeshEditor_i::Translate(const SMESH::long_array & theIDsOfElements,
- const SMESH::DirStruct & theVector,
- CORBA::Boolean theCopy)
+string SMESH_MeshEditor_i::generateGroupName(const string& thePrefix)
{
- if ( !myPreviewMode ) {
- TPythonDump() << "vector = " << theVector;
- TPythonDump() << this << ".Translate( "
- << theIDsOfElements
- << ", vector, "
- << theCopy << " )";
- }
- translate(theIDsOfElements,
- theVector,
- theCopy,
- false);
-}
+ SMESH::ListOfGroups_var groups = myMesh_i->GetGroups();
+ set<string> groupNames;
-//=======================================================================
-//function : TranslateObject
-//purpose :
-//=======================================================================
+ // 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;
-void SMESH_MeshEditor_i::TranslateObject(SMESH::SMESH_IDSource_ptr theObject,
- const SMESH::DirStruct & theVector,
- CORBA::Boolean theCopy)
-{
- if ( !myPreviewMode ) {
- TPythonDump() << this << ".TranslateObject( "
- << theObject
- << ", vector, "
- << theCopy << " )";
+ CORBA::String_var name = aGroup->GetName();
+ groupNames.insert( name.in() );
}
- SMESH::long_array_var anElementsId = theObject->GetIDs();
- translate(anElementsId,
- theVector,
- theCopy,
- false);
-}
-//=======================================================================
-//function : TranslateMakeGroups
-//purpose :
-//=======================================================================
+ // Find new name
+ string name = thePrefix;
+ int index = 0;
-SMESH::ListOfGroups*
-SMESH_MeshEditor_i::TranslateMakeGroups(const SMESH::long_array& theIDsOfElements,
- const SMESH::DirStruct& theVector)
-{
- if ( !myPreviewMode ) {
- TPythonDump() << "vector = " << theVector;
- TPythonDump() << this << ".TranslateMakeGroups( "
- << theIDsOfElements
- << ", vector )";
- }
- return translate(theIDsOfElements,theVector,true,true);
+ while (!groupNames.insert(name).second)
+ name = SMESH_Comment( thePrefix ) << "_" << index++;
+
+ return name;
}
-//=======================================================================
-//function : TranslateObjectMakeGroups
-//purpose :
-//=======================================================================
+//================================================================================
+/*!
+ * \brief Prepare SMESH_IDSource for work
+ */
+//================================================================================
-SMESH::ListOfGroups*
-SMESH_MeshEditor_i::TranslateObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
- const SMESH::DirStruct& theVector)
+void SMESH_MeshEditor_i::prepareIdSource(SMESH::SMESH_IDSource_ptr theObject)
{
- if ( !myPreviewMode ) {
- TPythonDump() << "vector = " << theVector;
- TPythonDump() << this << ".TranslateObjectMakeGroups( "
- << theObject
- << ", vector )";
+ if ( SMESH::Filter_i* filter = SMESH::DownCast<SMESH::Filter_i*>( theObject ))
+ {
+ SMESH::SMESH_Mesh_var mesh = myMesh_i->_this();
+ filter->SetMesh( mesh );
}
- SMESH::long_array_var anElementsId = theObject->GetIDs();
- return translate(anElementsId, theVector, true, true);
}
-//=======================================================================
-//function : TranslateMakeMesh
-//purpose :
-//=======================================================================
+//================================================================================
+/*!
+ * \brief Duplicates given elements, i.e. creates new elements based on the
+ * same nodes as the given ones.
+ * \param theElements - container of elements to duplicate.
+ * \param theGroupName - a name of group to contain the generated elements.
+ * If a group with such a name already exists, the new elements
+ * are added to the existng group, else a new group is created.
+ * If \a theGroupName is empty, new elements are not added
+ * in any group.
+ * \return a group where the new elements are added. NULL if theGroupName == "".
+ * \sa DoubleNode()
+ */
+//================================================================================
-SMESH::SMESH_Mesh_ptr
-SMESH_MeshEditor_i::TranslateMakeMesh(const SMESH::long_array& theIDsOfElements,
- const SMESH::DirStruct& theVector,
- CORBA::Boolean theCopyGroups,
- const char* theMeshName)
+SMESH::SMESH_Group_ptr
+SMESH_MeshEditor_i::DoubleElements(SMESH::SMESH_IDSource_ptr theElements,
+ const char* theGroupName)
+ throw (SALOME::SALOME_Exception)
{
- TPythonDump pydump; // to prevent dump at mesh creation
- SMESH::SMESH_Mesh_var mesh = makeMesh( theMeshName );
+ SMESH::SMESH_Group_var newGroup;
- if ( SMESH_Mesh_i* mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh )) {
- translate(theIDsOfElements, theVector,
- false, theCopyGroups, & mesh_i->GetImpl());
- mesh_i->CreateGroupServants();
- }
- if ( !myPreviewMode ) {
- pydump << mesh << " = " << this << ".TranslateMakeMesh( "
- << theIDsOfElements << ", "
- << theVector << ", "
- << theCopyGroups << ", '"
- << theMeshName << "' )";
- }
- return mesh._retn();
-}
+ SMESH_TRY;
+ initData();
-//=======================================================================
-//function : TranslateObjectMakeMesh
-//purpose :
-//=======================================================================
+ TPythonDump pyDump;
-SMESH::SMESH_Mesh_ptr
-SMESH_MeshEditor_i::TranslateObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject,
- const SMESH::DirStruct& theVector,
- CORBA::Boolean theCopyGroups,
- const char* theMeshName)
-{
- TPythonDump pydump; // to prevent dump at mesh creation
- SMESH::SMESH_Mesh_var mesh = makeMesh( theMeshName );
+ TIDSortedElemSet elems;
+ prepareIdSource( theElements );
+ if ( idSourceToSet( theElements, getMeshDS(), elems, SMDSAbs_All, /*emptyIfIsMesh=*/true))
+ {
+ getEditor().DoubleElements( elems );
- if ( SMESH_Mesh_i* mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh )) {
- SMESH::long_array_var anElementsId = theObject->GetIDs();
- translate(anElementsId, theVector,
- false, theCopyGroups, & mesh_i->GetImpl());
- mesh_i->CreateGroupServants();
- }
- if ( !myPreviewMode ) {
- pydump << mesh << " = " << this << ".TranslateObjectMakeMesh( "
- << theObject << ", "
- << theVector << ", "
- << theCopyGroups << ", '"
- << theMeshName << "' )";
+ if ( strlen( theGroupName ) && !getEditor().GetLastCreatedElems().IsEmpty() )
+ {
+ // group type
+ SMESH::ElementType type =
+ SMESH::ElementType( getEditor().GetLastCreatedElems().Value(1)->GetType() );
+ // find existing group
+ SMESH::ListOfGroups_var groups = myMesh_i->GetGroups();
+ for ( size_t i = 0; i < groups->length(); ++i )
+ if ( groups[i]->GetType() == type )
+ {
+ CORBA::String_var name = groups[i]->GetName();
+ if ( strcmp( name, theGroupName ) == 0 ) {
+ newGroup = SMESH::SMESH_Group::_narrow( groups[i] );
+ break;
+ }
+ }
+ // create a new group
+ if ( newGroup->_is_nil() )
+ newGroup = myMesh_i->CreateGroup( type, theGroupName );
+ // fill newGroup
+ if ( SMESH_Group_i* group_i = SMESH::DownCast< SMESH_Group_i* >( newGroup ))
+ {
+ SMESHDS_Group* groupDS = static_cast< SMESHDS_Group* >( group_i->GetGroupDS() );
+ const SMESH_SequenceOfElemPtr& aSeq = getEditor().GetLastCreatedElems();
+ for ( int i = 1; i <= aSeq.Length(); i++ )
+ groupDS->SMDSGroup().Add( aSeq(i) );
+ }
+ }
}
- return mesh._retn();
+ // python dump
+ if ( !newGroup->_is_nil() )
+ pyDump << newGroup << " = ";
+ pyDump << this << ".DoubleElements( "
+ << theElements << ", " << "'" << theGroupName <<"')";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+
+ return newGroup._retn();
}
-//=======================================================================
-//function : rotate
-//purpose :
-//=======================================================================
+//================================================================================
+/*!
+ \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
+ they not assigned to elements
+ \return TRUE if operation has been completed successfully, FALSE otherwise
+ \sa DoubleNode(), DoubleNodeGroup(), DoubleNodeGroups()
+*/
+//================================================================================
-SMESH::ListOfGroups*
-SMESH_MeshEditor_i::rotate(const SMESH::long_array & theIDsOfElements,
- const SMESH::AxisStruct & theAxis,
- CORBA::Double theAngle,
- CORBA::Boolean theCopy,
- const bool theMakeGroups,
- ::SMESH_Mesh* theTargetMesh)
+CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theNodes,
+ const SMESH::long_array& theModifiedElems )
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
- TIDSortedElemSet elements;
- arrayToSet(theIDsOfElements, GetMeshDS(), elements);
+ list< int > aListOfNodes;
+ int i, n;
+ for ( i = 0, n = theNodes.length(); i < n; i++ )
+ aListOfNodes.push_back( theNodes[ i ] );
- gp_Pnt P ( theAxis.x, theAxis.y, theAxis.z );
- gp_Vec V ( theAxis.vx, theAxis.vy, theAxis.vz );
+ list< int > aListOfElems;
+ for ( i = 0, n = theModifiedElems.length(); i < n; i++ )
+ aListOfElems.push_back( theModifiedElems[ i ] );
- gp_Trsf aTrsf;
- aTrsf.SetRotation( gp_Ax1( P, V ), theAngle);
+ bool aResult = getEditor().DoubleNodes( aListOfNodes, aListOfElems );
- ::SMESH_MeshEditor anEditor( myMesh );
- ::SMESH_MeshEditor::PGroupIDs groupIds =
- anEditor.Transform (elements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
+ declareMeshModified( /*isReComputeSafe=*/ !aResult );
+
+ // Update Python script
+ TPythonDump() << this << ".DoubleNodes( " << theNodes << ", "<< theModifiedElems << " )";
+
+ return aResult;
- if(theCopy) {
- storeResult(anEditor);
- }
- return theMakeGroups ? getGroups(groupIds.get()) : 0;
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
-//=======================================================================
-//function : Rotate
-//purpose :
-//=======================================================================
+//================================================================================
+/*!
+ \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 theNodeId - identifier of node to be doubled.
+ \param theModifiedElems - identifiers of elements to be updated.
+ \return TRUE if operation has been completed successfully, FALSE otherwise
+ \sa DoubleNodes(), DoubleNodeGroup(), DoubleNodeGroups()
+*/
+//================================================================================
-void SMESH_MeshEditor_i::Rotate(const SMESH::long_array & theIDsOfElements,
- const SMESH::AxisStruct & theAxis,
- CORBA::Double theAngle,
- CORBA::Boolean theCopy)
+CORBA::Boolean SMESH_MeshEditor_i::DoubleNode( CORBA::Long theNodeId,
+ const SMESH::long_array& theModifiedElems )
+ throw (SALOME::SALOME_Exception)
{
- if ( !myPreviewMode ) {
- TPythonDump() << "axis = " << theAxis;
- TPythonDump() << this << ".Rotate( "
- << theIDsOfElements
- << ", axis, "
- << theAngle << ", "
- << theCopy << " )";
- }
- rotate(theIDsOfElements,
- theAxis,
- theAngle,
- theCopy,
- false);
-}
+ SMESH_TRY;
+ SMESH::long_array_var aNodes = new SMESH::long_array;
+ aNodes->length( 1 );
+ aNodes[ 0 ] = theNodeId;
-//=======================================================================
-//function : RotateObject
-//purpose :
-//=======================================================================
+ TPythonDump pyDump; // suppress dump by the next line
-void SMESH_MeshEditor_i::RotateObject(SMESH::SMESH_IDSource_ptr theObject,
- const SMESH::AxisStruct & theAxis,
- CORBA::Double theAngle,
- CORBA::Boolean theCopy)
-{
- if ( !myPreviewMode ) {
- TPythonDump() << "axis = " << theAxis;
- TPythonDump() << this << ".RotateObject( "
- << theObject
- << ", axis, "
- << theAngle << ", "
- << theCopy << " )";
- }
- SMESH::long_array_var anElementsId = theObject->GetIDs();
- rotate(anElementsId,
- theAxis,
- theAngle,
- theCopy,
- false);
-}
+ CORBA::Boolean done = DoubleNodes( aNodes, theModifiedElems );
-//=======================================================================
-//function : RotateMakeGroups
-//purpose :
-//=======================================================================
+ pyDump << this << ".DoubleNode( " << theNodeId << ", " << theModifiedElems << " )";
-SMESH::ListOfGroups*
-SMESH_MeshEditor_i::RotateMakeGroups(const SMESH::long_array& theIDsOfElements,
- const SMESH::AxisStruct& theAxis,
- CORBA::Double theAngle)
-{
- if ( !myPreviewMode ) {
- TPythonDump() << "axis = " << theAxis;
- TPythonDump() << this << ".RotateMakeGroups( "
- << theIDsOfElements
- << ", axis, "
- << theAngle << " )";
- }
- return rotate(theIDsOfElements,theAxis,theAngle,true,true);
+ return done;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
-//=======================================================================
-//function : RotateObjectMakeGroups
-//purpose :
-//=======================================================================
+//================================================================================
+/*!
+ \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 theNodes - group of nodes to be doubled.
+ \param theModifiedElems - group of elements to be updated.
+ \return TRUE if operation has been completed successfully, FALSE otherwise
+ \sa DoubleNode(), DoubleNodes(), DoubleNodeGroups()
+*/
+//================================================================================
-SMESH::ListOfGroups*
-SMESH_MeshEditor_i::RotateObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
- const SMESH::AxisStruct& theAxis,
- CORBA::Double theAngle)
+CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroup(SMESH::SMESH_GroupBase_ptr theNodes,
+ SMESH::SMESH_GroupBase_ptr theModifiedElems )
+ throw (SALOME::SALOME_Exception)
{
- if ( !myPreviewMode ) {
- TPythonDump() << "axis = " << theAxis;
- TPythonDump() << this << ".RotateObjectMakeGroups( "
- << theObject
- << ", axis, "
- << theAngle << " )";
+ SMESH_TRY;
+ if ( CORBA::is_nil( theNodes ) && theNodes->GetType() != SMESH::NODE )
+ return false;
+
+ 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 );
}
- SMESH::long_array_var anElementsId = theObject->GetIDs();
- return rotate(anElementsId,theAxis,theAngle,true,true);
-}
-//=======================================================================
-//function : RotateMakeMesh
-//purpose :
-//=======================================================================
+ TPythonDump pyDump; // suppress dump by the next line
-SMESH::SMESH_Mesh_ptr
-SMESH_MeshEditor_i::RotateMakeMesh(const SMESH::long_array& theIDsOfElements,
- const SMESH::AxisStruct& theAxis,
- CORBA::Double theAngleInRadians,
- CORBA::Boolean theCopyGroups,
- const char* theMeshName)
-{
- TPythonDump pydump; // to prevent dump at mesh creation
- SMESH::SMESH_Mesh_var mesh = makeMesh( theMeshName );
+ bool done = DoubleNodes( aNodes, aModifiedElems );
- if ( SMESH_Mesh_i* mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh )) {
- rotate(theIDsOfElements, theAxis, theAngleInRadians,
- false, theCopyGroups, & mesh_i->GetImpl());
- mesh_i->CreateGroupServants();
- }
- if ( !myPreviewMode ) {
- pydump << mesh << " = " << this << ".RotateMakeMesh( "
- << theIDsOfElements << ", "
- << theAxis << ", "
- << theAngleInRadians << ", "
- << theCopyGroups << ", '"
- << theMeshName << "' )";
- }
- return mesh._retn();
+ pyDump << this << ".DoubleNodeGroup( " << theNodes << ", " << theModifiedElems << " )";
+
+ return done;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
-//=======================================================================
-//function : RotateObjectMakeMesh
-//purpose :
-//=======================================================================
+//================================================================================
+/*!
+ * \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_Mesh_ptr
-SMESH_MeshEditor_i::RotateObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject,
- const SMESH::AxisStruct& theAxis,
- CORBA::Double theAngleInRadians,
- CORBA::Boolean theCopyGroups,
- const char* theMeshName)
+SMESH::SMESH_Group_ptr
+SMESH_MeshEditor_i::DoubleNodeGroupNew( SMESH::SMESH_GroupBase_ptr theNodes,
+ SMESH::SMESH_GroupBase_ptr theModifiedElems )
+ throw (SALOME::SALOME_Exception)
{
- TPythonDump pydump; // to prevent dump at mesh creation
- SMESH::SMESH_Mesh_var mesh = makeMesh( theMeshName );
+ SMESH_TRY;
+ SMESH::SMESH_Group_var aNewGroup;
- if ( SMESH_Mesh_i* mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh )) {
- SMESH::long_array_var anElementsId = theObject->GetIDs();
- rotate(anElementsId, theAxis, theAngleInRadians,
- false, theCopyGroups, & mesh_i->GetImpl());
- mesh_i->CreateGroupServants();
- }
- if ( !myPreviewMode ) {
- pydump << mesh << " = " << this << ".RotateObjectMakeMesh( "
- << theObject << ", "
- << theAxis << ", "
- << theAngleInRadians << ", "
- << theCopyGroups << ", '"
- << theMeshName << "' )";
+ if ( CORBA::is_nil( theNodes ) && theNodes->GetType() != SMESH::NODE )
+ return aNewGroup._retn();
+
+ // 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 );
}
- return mesh._retn();
-}
-//=======================================================================
-//function : FindCoincidentNodes
-//purpose :
-//=======================================================================
+ TPythonDump pyDump; // suppress dump by the next line
-void SMESH_MeshEditor_i::FindCoincidentNodes (CORBA::Double Tolerance,
- SMESH::array_of_long_array_out GroupsOfNodes)
-{
- initData();
+ 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 << aNewGroup << " = ";
+ }
+ }
- ::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
- ::SMESH_MeshEditor anEditor( myMesh );
- set<const SMDS_MeshNode*> nodes; // no input nodes
- anEditor.FindCoincidentNodes( nodes, Tolerance, aListOfListOfNodes );
+ pyDump << this << ".DoubleNodeGroupNew( " << theNodes << ", "
+ << theModifiedElems << " )";
- 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++ ) {
- list< const SMDS_MeshNode* >& aListOfNodes = *llIt;
- list< const SMDS_MeshNode* >::iterator lIt = aListOfNodes.begin();;
- SMESH::long_array& aGroup = (*GroupsOfNodes)[ i ];
- aGroup.length( aListOfNodes.size() );
- for ( int j = 0; lIt != aListOfNodes.end(); lIt++, j++ )
- aGroup[ j ] = (*lIt)->GetID();
- }
- TPythonDump() << "coincident_nodes = " << this << ".FindCoincidentNodes( "
- << Tolerance << " )";
+ return aNewGroup._retn();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
-//=======================================================================
-//function : FindCoincidentNodesOnPart
-//purpose :
-//=======================================================================
-void SMESH_MeshEditor_i::FindCoincidentNodesOnPart(SMESH::SMESH_IDSource_ptr theObject,
- CORBA::Double Tolerance,
- SMESH::array_of_long_array_out GroupsOfNodes)
+//================================================================================
+/*!
+ \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 theNodes - list of groups of nodes to be doubled
+ \param theModifiedElems - list of groups of elements to be updated.
+ \return TRUE if operation has been completed successfully, FALSE otherwise
+ \sa DoubleNode(), DoubleNodeGroup(), DoubleNodes()
+*/
+//================================================================================
+
+CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups(const SMESH::ListOfGroups& theNodes,
+ const SMESH::ListOfGroups& theModifiedElems )
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
- SMESH::long_array_var aElementsId = theObject->GetIDs();
- SMESHDS_Mesh* aMesh = GetMeshDS();
- set<const SMDS_MeshNode*> nodes;
-
- if ( !CORBA::is_nil(SMESH::SMESH_GroupBase::_narrow(theObject)) &&
- SMESH::SMESH_GroupBase::_narrow(theObject)->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);
+ std::list< int > aNodes;
+ int i, n, j, m;
+ for ( i = 0, n = theNodes.length(); i < n; i++ )
+ {
+ SMESH::SMESH_GroupBase_var aGrp = theNodes[ i ];
+ 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 ] );
}
}
- 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()));
- }
+
+ std::list< int > anElems;
+ for ( i = 0, n = theModifiedElems.length(); i < n; i++ )
+ {
+ SMESH::SMESH_GroupBase_var aGrp = theModifiedElems[ i ];
+ 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++ )
+ anElems.push_back( aCurr[ j ] );
}
}
-
-
- ::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
- ::SMESH_MeshEditor anEditor( myMesh );
- if(!nodes.empty())
- anEditor.FindCoincidentNodes( nodes, Tolerance, aListOfListOfNodes );
-
- 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++ ) {
- list< const SMDS_MeshNode* >& aListOfNodes = *llIt;
- list< const SMDS_MeshNode* >::iterator lIt = aListOfNodes.begin();;
- SMESH::long_array& aGroup = (*GroupsOfNodes)[ i ];
- aGroup.length( aListOfNodes.size() );
- for ( int j = 0; lIt != aListOfNodes.end(); lIt++, j++ )
- aGroup[ j ] = (*lIt)->GetID();
- }
- TPythonDump() << "coincident_nodes_on_part = " << this << ".FindCoincidentNodesOnPart( "
- <<theObject<<", "
- << Tolerance << " )";
+
+ bool aResult = getEditor().DoubleNodes( aNodes, anElems );
+
+ declareMeshModified( /*isReComputeSafe=*/false );
+
+ TPythonDump() << this << ".DoubleNodeGroups( " << theNodes << ", " << theModifiedElems << " )";
+
+ return aResult;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
-//=======================================================================
-//function : MergeNodes
-//purpose :
-//=======================================================================
+//================================================================================
+/*!
+ * \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()
+ */
+//================================================================================
-void SMESH_MeshEditor_i::MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes)
+SMESH::SMESH_Group_ptr
+SMESH_MeshEditor_i::DoubleNodeGroupsNew( const SMESH::ListOfGroups& theNodes,
+ const SMESH::ListOfGroups& theModifiedElems )
+ throw (SALOME::SALOME_Exception)
{
- initData();
+ SMESH::SMESH_Group_var aNewGroup;
- SMESHDS_Mesh* aMesh = GetMeshDS();
+ TPythonDump pyDump; // suppress dump by the next line
- TPythonDump aTPythonDump;
- aTPythonDump << this << ".MergeNodes([";
- ::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
- for (int i = 0; i < GroupsOfNodes.length(); i++)
+ bool aResult = DoubleNodeGroups( theNodes, theModifiedElems );
+
+ if ( aResult )
{
- const SMESH::long_array& aNodeGroup = GroupsOfNodes[ i ];
- aListOfListOfNodes.push_back( list< const SMDS_MeshNode* >() );
- list< const SMDS_MeshNode* >& aListOfNodes = aListOfListOfNodes.back();
- for ( int j = 0; j < aNodeGroup.length(); j++ )
- {
- CORBA::Long index = aNodeGroup[ j ];
- const SMDS_MeshNode * node = aMesh->FindNode(index);
- if ( node )
- aListOfNodes.push_back( node );
+ // 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 << aNewGroup << " = ";
}
- if ( aListOfNodes.size() < 2 )
- aListOfListOfNodes.pop_back();
-
- if ( i > 0 ) aTPythonDump << ", ";
- aTPythonDump << aNodeGroup;
}
- ::SMESH_MeshEditor anEditor( myMesh );
- anEditor.MergeNodes( aListOfListOfNodes );
- aTPythonDump << "])";
+ pyDump << this << ".DoubleNodeGroupsNew( " << theNodes << ", "
+ << theModifiedElems << " )";
+
+ return aNewGroup._retn();
}
-//=======================================================================
-//function : FindEqualElements
-//purpose :
-//=======================================================================
-void SMESH_MeshEditor_i::FindEqualElements(SMESH::SMESH_IDSource_ptr theObject,
- SMESH::array_of_long_array_out GroupsOfElementsID)
+
+//================================================================================
+/*!
+ \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 SMESH_MeshEditor_i::DoubleNodeElem( const SMESH::long_array& theElems,
+ const SMESH::long_array& theNodesNot,
+ const SMESH::long_array& theAffectedElems )
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
- if ( !(!CORBA::is_nil(SMESH::SMESH_GroupBase::_narrow(theObject)) &&
- SMESH::SMESH_GroupBase::_narrow(theObject)->GetType() == SMESH::NODE) ) {
- typedef list<int> TListOfIDs;
- set<const SMDS_MeshElement*> elems;
- SMESH::long_array_var aElementsId = theObject->GetIDs();
- SMESHDS_Mesh* aMesh = GetMeshDS();
- for(int i = 0; i < aElementsId->length(); i++) {
- CORBA::Long anID = aElementsId[i];
- const SMDS_MeshElement * elem = aMesh->FindElement(anID);
- if (elem) {
- elems.insert(elem);
- }
- }
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
+ TIDSortedElemSet anElems, aNodes, anAffected;
+ arrayToSet(theElems, aMeshDS, anElems, SMDSAbs_All);
+ arrayToSet(theNodesNot, aMeshDS, aNodes, SMDSAbs_Node);
+ arrayToSet(theAffectedElems, aMeshDS, anAffected, SMDSAbs_All);
- ::SMESH_MeshEditor::TListOfListOfElementsID aListOfListOfElementsID;
- ::SMESH_MeshEditor anEditor( myMesh );
- anEditor.FindEqualElements( elems, aListOfListOfElementsID );
+ bool aResult = getEditor().DoubleNodes( anElems, aNodes, anAffected );
- GroupsOfElementsID = new SMESH::array_of_long_array;
- GroupsOfElementsID->length( aListOfListOfElementsID.size() );
+ // Update Python script
+ TPythonDump() << this << ".DoubleNodeElem( " << theElems << ", "
+ << theNodesNot << ", " << theAffectedElems << " )";
- ::SMESH_MeshEditor::TListOfListOfElementsID::iterator arraysIt = aListOfListOfElementsID.begin();
- for (CORBA::Long j = 0; arraysIt != aListOfListOfElementsID.end(); ++arraysIt, ++j) {
- SMESH::long_array& aGroup = (*GroupsOfElementsID)[ j ];
- TListOfIDs& listOfIDs = *arraysIt;
- aGroup.length( listOfIDs.size() );
- TListOfIDs::iterator idIt = listOfIDs.begin();
- for (int k = 0; idIt != listOfIDs.end(); ++idIt, ++k ) {
- aGroup[ k ] = *idIt;
- }
- }
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return aResult;
- TPythonDump() << "equal_elements = " << this << ".FindEqualElements( "
- <<theObject<<" )";
- }
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
-//=======================================================================
-//function : MergeElements
-//purpose :
-//=======================================================================
+//================================================================================
+/*!
+ \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()
+*/
+//================================================================================
-void SMESH_MeshEditor_i::MergeElements(const SMESH::array_of_long_array& GroupsOfElementsID)
+CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemInRegion ( const SMESH::long_array& theElems,
+ const SMESH::long_array& theNodesNot,
+ GEOM::GEOM_Object_ptr theShape )
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
- TPythonDump aTPythonDump;
- aTPythonDump << this << ".MergeElements( [";
- ::SMESH_MeshEditor::TListOfListOfElementsID aListOfListOfElementsID;
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
+ TIDSortedElemSet anElems, aNodes;
+ arrayToSet(theElems, aMeshDS, anElems, SMDSAbs_All);
+ arrayToSet(theNodesNot, aMeshDS, aNodes, SMDSAbs_Node);
- for (int i = 0; i < GroupsOfElementsID.length(); i++) {
- const SMESH::long_array& anElemsIDGroup = GroupsOfElementsID[ i ];
- aListOfListOfElementsID.push_back( list< int >() );
- list< int >& aListOfElemsID = aListOfListOfElementsID.back();
- for ( int j = 0; j < anElemsIDGroup.length(); j++ ) {
- CORBA::Long id = anElemsIDGroup[ j ];
- aListOfElemsID.push_back( id );
- }
- if ( aListOfElemsID.size() < 2 )
- aListOfListOfElementsID.pop_back();
- if ( i > 0 ) aTPythonDump << ", ";
- aTPythonDump << anElemsIDGroup;
- }
+ TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape );
+ bool aResult = getEditor().DoubleNodesInRegion( anElems, aNodes, aShape );
+
+ // Update Python script
+ TPythonDump() << "isDone = " << this << ".DoubleNodeElemInRegion( " << theElems << ", "
+ << theNodesNot << ", " << theShape << " )";
+
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return aResult;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//================================================================================
+/*!
+ \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
+SMESH_MeshEditor_i::DoubleNodeElemGroup(SMESH::SMESH_GroupBase_ptr theElems,
+ SMESH::SMESH_GroupBase_ptr theNodesNot,
+ SMESH::SMESH_GroupBase_ptr theAffectedElems)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE )
+ return false;
- ::SMESH_MeshEditor anEditor( myMesh );
- anEditor.MergeElements(aListOfListOfElementsID);
+ initData();
- aTPythonDump << "] )";
-}
-//=======================================================================
-//function : MergeEqualElements
-//purpose :
-//=======================================================================
+ 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 );
-void SMESH_MeshEditor_i::MergeEqualElements()
-{
- initData();
+ bool aResult = getEditor().DoubleNodes( anElems, aNodes, anAffected );
- ::SMESH_MeshEditor anEditor( myMesh );
- anEditor.MergeEqualElements();
+ // Update Python script
+ TPythonDump() << "isDone = " << this << ".DoubleNodeElemGroup( " << theElems << ", "
+ << theNodesNot << ", " << theAffectedElems << " )";
- TPythonDump() << this << ".MergeEqualElements()";
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return aResult;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//================================================================================
/*!
- * \brief If the given ID is a valid node ID (nodeID > 0), just move this node, else
- * move the node closest to the point to point's location and return ID of the node
+ * \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()
*/
//================================================================================
-CORBA::Long SMESH_MeshEditor_i::MoveClosestNodeToPoint(CORBA::Double x,
- CORBA::Double y,
- CORBA::Double z,
- CORBA::Long theNodeID)
+SMESH::SMESH_Group_ptr
+SMESH_MeshEditor_i::DoubleNodeElemGroupNew(SMESH::SMESH_GroupBase_ptr theElems,
+ SMESH::SMESH_GroupBase_ptr theNodesNot,
+ SMESH::SMESH_GroupBase_ptr theAffectedElems)
+ throw (SALOME::SALOME_Exception)
+{
+ TPythonDump pyDump;
+ SMESH::ListOfGroups_var twoGroups = DoubleNodeElemGroup2New( theElems,
+ theNodesNot,
+ theAffectedElems,
+ true, false );
+ SMESH::SMESH_GroupBase_var baseGroup = twoGroups[0].in();
+ SMESH::SMESH_Group_var elemGroup = SMESH::SMESH_Group::_narrow( baseGroup );
+
+ pyDump << elemGroup << " = " << this << ".DoubleNodeElemGroupNew( "
+ << theElems << ", "
+ << theNodesNot << ", "
+ << theAffectedElems << " )";
+
+ return elemGroup._retn();
+}
+
+//================================================================================
+/*!
+ * \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::ListOfGroups*
+SMESH_MeshEditor_i::DoubleNodeElemGroup2New(SMESH::SMESH_GroupBase_ptr theElems,
+ SMESH::SMESH_GroupBase_ptr theNodesNot,
+ SMESH::SMESH_GroupBase_ptr theAffectedElems,
+ CORBA::Boolean theElemGroupNeeded,
+ CORBA::Boolean theNodeGroupNeeded)
+ throw (SALOME::SALOME_Exception)
{
- // We keep myNodeSearcher until any mesh modification:
- // 1) initData() deletes myNodeSearcher at any edition,
- // 2) TNodeSearcherDeleter - at any mesh compute event and mesh change
+ SMESH_TRY;
+ SMESH::SMESH_Group_var aNewElemGroup, aNewNodeGroup;
+ SMESH::ListOfGroups_var aTwoGroups = new SMESH::ListOfGroups();
+ aTwoGroups->length( 2 );
+
+ if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE )
+ return aTwoGroups._retn();
initData();
- int nodeID = theNodeID;
- const SMDS_MeshNode* node = GetMeshDS()->FindNode( nodeID );
- if ( !node )
+
+ 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 = getEditor().DoubleNodes( anElems, aNodes, anAffected );
+
+ declareMeshModified( /*isReComputeSafe=*/ !aResult );
+
+ TPythonDump pyDump;
+
+ if ( aResult )
{
- static TNodeSearcherDeleter deleter;
- deleter.Set( myMesh );
- if ( !myNodeSearcher ) {
- ::SMESH_MeshEditor anEditor( myMesh );
- myNodeSearcher = anEditor.GetNodeSearcher();
- }
- gp_Pnt p( x,y,z );
- node = myNodeSearcher->FindClosestTo( p );
- }
- if ( node ) {
- nodeID = node->GetID();
- if ( myPreviewMode ) // make preview data
+ // Create group with newly created elements
+ CORBA::String_var elemGroupName = theElems->GetName();
+ string aNewName = generateGroupName( string(elemGroupName.in()) + "_double");
+ if ( !getEditor().GetLastCreatedElems().IsEmpty() && theElemGroupNeeded )
{
- // in a preview mesh, make edges linked to a node
- TPreviewMesh tmpMesh;
- TIDSortedElemSet linkedNodes;
- ::SMESH_MeshEditor::GetLinkedNodes( node, linkedNodes );
- TIDSortedElemSet::iterator nIt = linkedNodes.begin();
- for ( ; nIt != linkedNodes.end(); ++nIt )
- {
- SMDS_MeshEdge edge( node, cast2Node( *nIt ));
- tmpMesh.Copy( &edge );
- }
- // move copied node
- node = tmpMesh.GetMeshDS()->FindNode( nodeID );
- if ( node )
- tmpMesh.GetMeshDS()->MoveNode(node, x, y, z);
- // fill preview data
- ::SMESH_MeshEditor anEditor( & tmpMesh );
- storeResult( anEditor );
+ SMESH::long_array_var anIds = GetLastCreatedElems();
+ SMESH::ElementType aGroupType = myMesh_i->GetElementType(anIds[0], true);
+ aNewElemGroup = myMesh_i->CreateGroup(aGroupType, aNewName.c_str());
+ aNewElemGroup->Add(anIds);
}
- else
+ if ( !getEditor().GetLastCreatedNodes().IsEmpty() && theNodeGroupNeeded )
{
- GetMeshDS()->MoveNode(node, x, y, z);
+ SMESH::long_array_var anIds = GetLastCreatedNodes();
+ aNewNodeGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
+ aNewNodeGroup->Add(anIds);
}
}
- if ( !myPreviewMode ) {
- TPythonDump() << "nodeID = " << this
- << ".MoveClosestNodeToPoint( "<< x << ", " << y << ", " << z << " )";
- }
+ // Update Python script
- return nodeID;
-}
+ pyDump << "[ ";
+ if ( aNewElemGroup->_is_nil() ) pyDump << "nothing, ";
+ else pyDump << aNewElemGroup << ", ";
+ if ( aNewNodeGroup->_is_nil() ) pyDump << "nothing ] = ";
+ else pyDump << aNewNodeGroup << " ] = ";
-//=======================================================================
-//function : convError
-//purpose :
-//=======================================================================
+ pyDump << this << ".DoubleNodeElemGroup2New( " << theElems << ", "
+ << theNodesNot << ", "
+ << theAffectedElems << ", "
+ << theElemGroupNeeded << ", "
+ << theNodeGroupNeeded <<" )";
-#define RETCASE(enm) case ::SMESH_MeshEditor::enm: return SMESH::SMESH_MeshEditor::enm;
+ aTwoGroups[0] = aNewElemGroup._retn();
+ aTwoGroups[1] = aNewNodeGroup._retn();
+ return aTwoGroups._retn();
-static SMESH::SMESH_MeshEditor::Sew_Error convError( const::SMESH_MeshEditor::Sew_Error e )
-{
- switch ( e ) {
- RETCASE( SEW_OK );
- RETCASE( SEW_BORDER1_NOT_FOUND );
- RETCASE( SEW_BORDER2_NOT_FOUND );
- RETCASE( SEW_BOTH_BORDERS_NOT_FOUND );
- RETCASE( SEW_BAD_SIDE_NODES );
- RETCASE( SEW_VOLUMES_TO_SPLIT );
- RETCASE( SEW_DIFF_NB_OF_ELEMENTS );
- RETCASE( SEW_TOPO_DIFF_SETS_OF_ELEMENTS );
- RETCASE( SEW_BAD_SIDE1_NODES );
- RETCASE( SEW_BAD_SIDE2_NODES );
- }
- return SMESH::SMESH_MeshEditor::SEW_OK;
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
-//=======================================================================
-//function : SewFreeBorders
-//purpose :
-//=======================================================================
+//================================================================================
+/*!
+ \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()
+*/
+//================================================================================
-SMESH::SMESH_MeshEditor::Sew_Error
- SMESH_MeshEditor_i::SewFreeBorders(CORBA::Long FirstNodeID1,
- CORBA::Long SecondNodeID1,
- CORBA::Long LastNodeID1,
- CORBA::Long FirstNodeID2,
- CORBA::Long SecondNodeID2,
- CORBA::Long LastNodeID2,
- CORBA::Boolean CreatePolygons,
- CORBA::Boolean CreatePolyedrs)
+CORBA::Boolean
+SMESH_MeshEditor_i::DoubleNodeElemGroupInRegion(SMESH::SMESH_GroupBase_ptr theElems,
+ SMESH::SMESH_GroupBase_ptr theNodesNot,
+ GEOM::GEOM_Object_ptr theShape )
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
+ if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE )
+ return false;
+
initData();
- SMESHDS_Mesh* aMesh = GetMeshDS();
- const SMDS_MeshNode* aBorderFirstNode = aMesh->FindNode( FirstNodeID1 );
- const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeID1 );
- const SMDS_MeshNode* aBorderLastNode = aMesh->FindNode( LastNodeID1 );
- const SMDS_MeshNode* aSide2FirstNode = aMesh->FindNode( FirstNodeID2 );
- const SMDS_MeshNode* aSide2SecondNode = aMesh->FindNode( SecondNodeID2 );
- const SMDS_MeshNode* aSide2ThirdNode = aMesh->FindNode( LastNodeID2 );
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
+ TIDSortedElemSet anElems, aNodes, anAffected;
+ idSourceToSet( theElems, aMeshDS, anElems, SMDSAbs_All );
+ idSourceToSet( theNodesNot, aMeshDS, aNodes, SMDSAbs_Node );
- if (!aBorderFirstNode ||
- !aBorderSecondNode||
- !aBorderLastNode)
- return SMESH::SMESH_MeshEditor::SEW_BORDER1_NOT_FOUND;
- if (!aSide2FirstNode ||
- !aSide2SecondNode ||
- !aSide2ThirdNode)
- return SMESH::SMESH_MeshEditor::SEW_BORDER2_NOT_FOUND;
+ TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape );
+ bool aResult = getEditor().DoubleNodesInRegion( anElems, aNodes, aShape );
- TPythonDump() << "error = " << this << ".SewFreeBorders( "
- << FirstNodeID1 << ", "
- << SecondNodeID1 << ", "
- << LastNodeID1 << ", "
- << FirstNodeID2 << ", "
- << SecondNodeID2 << ", "
- << LastNodeID2 << ", "
- << CreatePolygons<< ", "
- << CreatePolyedrs<< " )";
- ::SMESH_MeshEditor anEditor( myMesh );
- SMESH::SMESH_MeshEditor::Sew_Error error =
- convError( anEditor.SewFreeBorder (aBorderFirstNode,
- aBorderSecondNode,
- aBorderLastNode,
- aSide2FirstNode,
- aSide2SecondNode,
- aSide2ThirdNode,
- true,
- CreatePolygons,
- CreatePolyedrs) );
+ declareMeshModified( /*isReComputeSafe=*/ !aResult );
- storeResult(anEditor);
+ // Update Python script
+ TPythonDump() << "isDone = " << this << ".DoubleNodeElemGroupInRegion( " << theElems << ", "
+ << theNodesNot << ", " << theShape << " )";
+ return aResult;
- return error;
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
+//================================================================================
+/*!
+ * \brief Re-load elements from a list of groups into a TIDSortedElemSet
+ * \param [in] theGrpList - groups
+ * \param [in] theMeshDS - mesh
+ * \param [out] theElemSet - set of elements
+ * \param [in] theIsNodeGrp - is \a theGrpList includes goups of nodes
+ */
+//================================================================================
+
+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 ) )
+ {
+ SMESH::long_array_var anIDs = aGrp->GetIDs();
+ arrayToSet( anIDs, theMeshDS, theElemSet, theIsNodeGrp ? SMDSAbs_Node : SMDSAbs_All );
+ }
+ }
+}
-//=======================================================================
-//function : SewConformFreeBorders
-//purpose :
-//=======================================================================
+//================================================================================
+/*!
+ \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(), DoubleNodeElemGroupsNew()
+*/
+//================================================================================
-SMESH::SMESH_MeshEditor::Sew_Error
-SMESH_MeshEditor_i::SewConformFreeBorders(CORBA::Long FirstNodeID1,
- CORBA::Long SecondNodeID1,
- CORBA::Long LastNodeID1,
- CORBA::Long FirstNodeID2,
- CORBA::Long SecondNodeID2)
+CORBA::Boolean
+SMESH_MeshEditor_i::DoubleNodeElemGroups(const SMESH::ListOfGroups& theElems,
+ const SMESH::ListOfGroups& theNodesNot,
+ const SMESH::ListOfGroups& theAffectedElems)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
- SMESHDS_Mesh* aMesh = GetMeshDS();
-
- const SMDS_MeshNode* aBorderFirstNode = aMesh->FindNode( FirstNodeID1 );
- const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeID1 );
- const SMDS_MeshNode* aBorderLastNode = aMesh->FindNode( LastNodeID1 );
- const SMDS_MeshNode* aSide2FirstNode = aMesh->FindNode( FirstNodeID2 );
- const SMDS_MeshNode* aSide2SecondNode = aMesh->FindNode( SecondNodeID2 );
- const SMDS_MeshNode* aSide2ThirdNode = 0;
- if (!aBorderFirstNode ||
- !aBorderSecondNode||
- !aBorderLastNode )
- return SMESH::SMESH_MeshEditor::SEW_BORDER1_NOT_FOUND;
- if (!aSide2FirstNode ||
- !aSide2SecondNode)
- return SMESH::SMESH_MeshEditor::SEW_BORDER2_NOT_FOUND;
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
+ TIDSortedElemSet anElems, aNodes, anAffected;
+ listOfGroupToSet(theElems, aMeshDS, anElems, false );
+ listOfGroupToSet(theNodesNot, aMeshDS, aNodes, true );
+ listOfGroupToSet(theAffectedElems, aMeshDS, anAffected, false );
- TPythonDump() << "error = " << this << ".SewConformFreeBorders( "
- << FirstNodeID1 << ", "
- << SecondNodeID1 << ", "
- << LastNodeID1 << ", "
- << FirstNodeID2 << ", "
- << SecondNodeID2 << " )";
+ bool aResult = getEditor().DoubleNodes( anElems, aNodes, anAffected );
- ::SMESH_MeshEditor anEditor( myMesh );
- SMESH::SMESH_MeshEditor::Sew_Error error =
- convError( anEditor.SewFreeBorder (aBorderFirstNode,
- aBorderSecondNode,
- aBorderLastNode,
- aSide2FirstNode,
- aSide2SecondNode,
- aSide2ThirdNode,
- true,
- false, false) );
+ // Update Python script
+ TPythonDump() << "isDone = " << this << ".DoubleNodeElemGroups( " << &theElems << ", "
+ << &theNodesNot << ", " << &theAffectedElems << " )";
- storeResult(anEditor);
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return aResult;
- return error;
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
+//================================================================================
+/*!
+ * \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()
+ */
+//================================================================================
-//=======================================================================
-//function : SewBorderToSide
-//purpose :
-//=======================================================================
+SMESH::SMESH_Group_ptr
+SMESH_MeshEditor_i::DoubleNodeElemGroupsNew(const SMESH::ListOfGroups& theElems,
+ const SMESH::ListOfGroups& theNodesNot,
+ const SMESH::ListOfGroups& theAffectedElems)
+ throw (SALOME::SALOME_Exception)
+{
+ TPythonDump pyDump;
+ SMESH::ListOfGroups_var twoGroups = DoubleNodeElemGroups2New( theElems,
+ theNodesNot,
+ theAffectedElems,
+ true, false );
+ SMESH::SMESH_GroupBase_var baseGroup = twoGroups[0].in();
+ SMESH::SMESH_Group_var elemGroup = SMESH::SMESH_Group::_narrow( baseGroup );
+
+ pyDump << elemGroup << " = " << this << ".DoubleNodeElemGroupsNew( "
+ << theElems << ", "
+ << theNodesNot << ", "
+ << theAffectedElems << " )";
+
+ return elemGroup._retn();
+}
-SMESH::SMESH_MeshEditor::Sew_Error
-SMESH_MeshEditor_i::SewBorderToSide(CORBA::Long FirstNodeIDOnFreeBorder,
- CORBA::Long SecondNodeIDOnFreeBorder,
- CORBA::Long LastNodeIDOnFreeBorder,
- CORBA::Long FirstNodeIDOnSide,
- CORBA::Long LastNodeIDOnSide,
- CORBA::Boolean CreatePolygons,
- CORBA::Boolean CreatePolyedrs)
+//================================================================================
+/*!
+ * \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::ListOfGroups*
+SMESH_MeshEditor_i::DoubleNodeElemGroups2New(const SMESH::ListOfGroups& theElems,
+ const SMESH::ListOfGroups& theNodesNot,
+ const SMESH::ListOfGroups& theAffectedElems,
+ CORBA::Boolean theElemGroupNeeded,
+ CORBA::Boolean theNodeGroupNeeded)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
+ SMESH::SMESH_Group_var aNewElemGroup, aNewNodeGroup;
+ SMESH::ListOfGroups_var aTwoGroups = new SMESH::ListOfGroups();
+ aTwoGroups->length( 2 );
+
initData();
- SMESHDS_Mesh* aMesh = GetMeshDS();
- const SMDS_MeshNode* aBorderFirstNode = aMesh->FindNode( FirstNodeIDOnFreeBorder );
- const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeIDOnFreeBorder );
- const SMDS_MeshNode* aBorderLastNode = aMesh->FindNode( LastNodeIDOnFreeBorder );
- const SMDS_MeshNode* aSide2FirstNode = aMesh->FindNode( FirstNodeIDOnSide );
- const SMDS_MeshNode* aSide2SecondNode = aMesh->FindNode( LastNodeIDOnSide );
- const SMDS_MeshNode* aSide2ThirdNode = 0;
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
+ TIDSortedElemSet anElems, aNodes, anAffected;
+ listOfGroupToSet(theElems, aMeshDS, anElems, false );
+ listOfGroupToSet(theNodesNot, aMeshDS, aNodes, true );
+ listOfGroupToSet(theAffectedElems, aMeshDS, anAffected, false );
- if (!aBorderFirstNode ||
- !aBorderSecondNode||
- !aBorderLastNode )
- return SMESH::SMESH_MeshEditor::SEW_BORDER1_NOT_FOUND;
- if (!aSide2FirstNode ||
- !aSide2SecondNode)
- return SMESH::SMESH_MeshEditor::SEW_BAD_SIDE_NODES;
+ bool aResult = getEditor().DoubleNodes( anElems, aNodes, anAffected );
- TPythonDump() << "error = " << this << ".SewBorderToSide( "
- << FirstNodeIDOnFreeBorder << ", "
- << SecondNodeIDOnFreeBorder << ", "
- << LastNodeIDOnFreeBorder << ", "
- << FirstNodeIDOnSide << ", "
- << LastNodeIDOnSide << ", "
- << CreatePolygons << ", "
- << CreatePolyedrs << ") ";
+ declareMeshModified( /*isReComputeSafe=*/ !aResult );
- ::SMESH_MeshEditor anEditor( myMesh );
- SMESH::SMESH_MeshEditor::Sew_Error error =
- convError( anEditor.SewFreeBorder (aBorderFirstNode,
- aBorderSecondNode,
- aBorderLastNode,
- aSide2FirstNode,
- aSide2SecondNode,
- aSide2ThirdNode,
- false,
- CreatePolygons,
- CreatePolyedrs) );
+ TPythonDump pyDump;
+ if ( aResult )
+ {
+ // Create group with newly created elements
+ CORBA::String_var elemGroupName = theElems[0]->GetName();
+ string aNewName = generateGroupName( string(elemGroupName.in()) + "_double");
+ if ( !getEditor().GetLastCreatedElems().IsEmpty() && theElemGroupNeeded )
+ {
+ SMESH::long_array_var anIds = GetLastCreatedElems();
+ SMESH::ElementType aGroupType = myMesh_i->GetElementType(anIds[0], true);
+ aNewElemGroup = myMesh_i->CreateGroup(aGroupType, aNewName.c_str());
+ aNewElemGroup->Add(anIds);
+ }
+ if ( !getEditor().GetLastCreatedNodes().IsEmpty() && theNodeGroupNeeded )
+ {
+ SMESH::long_array_var anIds = GetLastCreatedNodes();
+ aNewNodeGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
+ aNewNodeGroup->Add(anIds);
+ }
+ }
+
+ // Update Python script
+
+ pyDump << "[ ";
+ if ( aNewElemGroup->_is_nil() ) pyDump << "nothing, ";
+ else pyDump << aNewElemGroup << ", ";
+ if ( aNewNodeGroup->_is_nil() ) pyDump << "nothing ] = ";
+ else pyDump << aNewNodeGroup << " ] = ";
+
+ pyDump << this << ".DoubleNodeElemGroups2New( " << &theElems << ", "
+ << &theNodesNot << ", "
+ << &theAffectedElems << ", "
+ << theElemGroupNeeded << ", "
+ << theNodeGroupNeeded << " )";
+
+ aTwoGroups[0] = aNewElemGroup._retn();
+ aTwoGroups[1] = aNewNodeGroup._retn();
+ return aTwoGroups._retn();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//================================================================================
+/*!
+ \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()
+*/
+//================================================================================
- storeResult(anEditor);
+CORBA::Boolean
+SMESH_MeshEditor_i::DoubleNodeElemGroupsInRegion(const SMESH::ListOfGroups& theElems,
+ const SMESH::ListOfGroups& theNodesNot,
+ GEOM::GEOM_Object_ptr theShape )
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ initData();
- return error;
-}
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
+ TIDSortedElemSet anElems, aNodes;
+ listOfGroupToSet(theElems, aMeshDS, anElems,false );
+ listOfGroupToSet(theNodesNot, aMeshDS, aNodes, true );
-//=======================================================================
-//function : SewSideElements
-//purpose :
-//=======================================================================
+ TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape );
+ bool aResult = getEditor().DoubleNodesInRegion( anElems, aNodes, aShape );
-SMESH::SMESH_MeshEditor::Sew_Error
-SMESH_MeshEditor_i::SewSideElements(const SMESH::long_array& IDsOfSide1Elements,
- const SMESH::long_array& IDsOfSide2Elements,
- CORBA::Long NodeID1OfSide1ToMerge,
- CORBA::Long NodeID1OfSide2ToMerge,
- CORBA::Long NodeID2OfSide1ToMerge,
- CORBA::Long NodeID2OfSide2ToMerge)
+ // Update Python script
+ TPythonDump() << "isDone = " << this << ".DoubleNodeElemGroupsInRegion( " << &theElems << ", "
+ << &theNodesNot << ", " << theShape << " )";
+
+ declareMeshModified( /*isReComputeSafe=*/ !aResult );
+ return aResult;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//================================================================================
+/*!
+ \brief Identify the elements that will be affected by node duplication (actual
+ duplication is not performed.
+ This method is the first step of DoubleNodeElemGroupsInRegion.
+ \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 groups of affected elements
+ \sa DoubleNodeElemGroupsInRegion()
+*/
+//================================================================================
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::AffectedElemGroupsInRegion( const SMESH::ListOfGroups& theElems,
+ const SMESH::ListOfGroups& theNodesNot,
+ GEOM::GEOM_Object_ptr theShape )
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
+ MESSAGE("AffectedElemGroupsInRegion");
+ SMESH::ListOfGroups_var aListOfGroups = new SMESH::ListOfGroups();
+ bool isEdgeGroup = false;
+ bool isFaceGroup = false;
+ bool isVolumeGroup = false;
+ SMESH::SMESH_Group_var aNewEdgeGroup = myMesh_i->CreateGroup(SMESH::EDGE, "affectedEdges");
+ SMESH::SMESH_Group_var aNewFaceGroup = myMesh_i->CreateGroup(SMESH::FACE, "affectedFaces");
+ SMESH::SMESH_Group_var aNewVolumeGroup = myMesh_i->CreateGroup(SMESH::VOLUME, "affectedVolumes");
+
initData();
- SMESHDS_Mesh* aMesh = GetMeshDS();
+ ::SMESH_MeshEditor aMeshEditor(myMesh);
- const SMDS_MeshNode* aFirstNode1ToMerge = aMesh->FindNode( NodeID1OfSide1ToMerge );
- const SMDS_MeshNode* aFirstNode2ToMerge = aMesh->FindNode( NodeID1OfSide2ToMerge );
- const SMDS_MeshNode* aSecondNode1ToMerge = aMesh->FindNode( NodeID2OfSide1ToMerge );
- const SMDS_MeshNode* aSecondNode2ToMerge = aMesh->FindNode( NodeID2OfSide2ToMerge );
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
+ TIDSortedElemSet anElems, aNodes;
+ listOfGroupToSet(theElems, aMeshDS, anElems, false);
+ listOfGroupToSet(theNodesNot, aMeshDS, aNodes, true);
- if (!aFirstNode1ToMerge ||
- !aFirstNode2ToMerge )
- return SMESH::SMESH_MeshEditor::SEW_BAD_SIDE1_NODES;
- if (!aSecondNode1ToMerge||
- !aSecondNode2ToMerge)
- return SMESH::SMESH_MeshEditor::SEW_BAD_SIDE2_NODES;
+ TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape(theShape);
+ TIDSortedElemSet anAffected;
+ bool aResult = aMeshEditor.AffectedElemGroupsInRegion(anElems, aNodes, aShape, anAffected);
- TIDSortedElemSet aSide1Elems, aSide2Elems;
- arrayToSet(IDsOfSide1Elements, aMesh, aSide1Elems);
- arrayToSet(IDsOfSide2Elements, aMesh, aSide2Elems);
- TPythonDump() << "error = " << this << ".SewSideElements( "
- << IDsOfSide1Elements << ", "
- << IDsOfSide2Elements << ", "
- << NodeID1OfSide1ToMerge << ", "
- << NodeID1OfSide2ToMerge << ", "
- << NodeID2OfSide1ToMerge << ", "
- << NodeID2OfSide2ToMerge << ")";
+ declareMeshModified( /*isReComputeSafe=*/ !aResult );
- ::SMESH_MeshEditor anEditor( myMesh );
- SMESH::SMESH_MeshEditor::Sew_Error error =
- convError( anEditor.SewSideElements (aSide1Elems, aSide2Elems,
- aFirstNode1ToMerge,
- aFirstNode2ToMerge,
- aSecondNode1ToMerge,
- aSecondNode2ToMerge));
+ TPythonDump pyDump;
+ if (aResult)
+ {
+ int lg = anAffected.size();
+ MESSAGE("lg="<< lg);
+ SMESH::long_array_var volumeIds = new SMESH::long_array;
+ volumeIds->length(lg);
+ SMESH::long_array_var faceIds = new SMESH::long_array;
+ faceIds->length(lg);
+ SMESH::long_array_var edgeIds = new SMESH::long_array;
+ edgeIds->length(lg);
+ int ivol = 0;
+ int iface = 0;
+ int iedge = 0;
+
+ TIDSortedElemSet::const_iterator eIt = anAffected.begin();
+ for (; eIt != anAffected.end(); ++eIt)
+ {
+ const SMDS_MeshElement* anElem = *eIt;
+ if (!anElem)
+ continue;
+ int elemId = anElem->GetID();
+ if (myMesh->GetElementType(elemId, true) == SMDSAbs_Volume)
+ volumeIds[ivol++] = elemId;
+ else if (myMesh->GetElementType(elemId, true) == SMDSAbs_Face)
+ faceIds[iface++] = elemId;
+ else if (myMesh->GetElementType(elemId, true) == SMDSAbs_Edge)
+ edgeIds[iedge++] = elemId;
+ }
+ volumeIds->length(ivol);
+ faceIds->length(iface);
+ edgeIds->length(iedge);
+
+ aNewVolumeGroup->Add(volumeIds);
+ aNewFaceGroup->Add(faceIds);
+ aNewEdgeGroup->Add(edgeIds);
+ isVolumeGroup = (aNewVolumeGroup->Size() > 0);
+ isFaceGroup = (aNewFaceGroup->Size() > 0);
+ isEdgeGroup = (aNewEdgeGroup->Size() > 0);
+ }
- storeResult(anEditor);
+ int nbGroups = 0;
+ if (isEdgeGroup) nbGroups++;
+ if (isFaceGroup) nbGroups++;
+ if (isVolumeGroup) nbGroups++;
+ aListOfGroups->length(nbGroups);
- return error;
+ int i = 0;
+ if (isEdgeGroup) aListOfGroups[i++] = aNewEdgeGroup._retn();
+ if (isFaceGroup) aListOfGroups[i++] = aNewFaceGroup._retn();
+ if (isVolumeGroup) aListOfGroups[i++] = aNewVolumeGroup._retn();
+
+ // Update Python script
+
+ pyDump << "[ ";
+ if (isEdgeGroup) pyDump << aNewEdgeGroup << ", ";
+ if (isFaceGroup) pyDump << aNewFaceGroup << ", ";
+ if (isVolumeGroup) pyDump << aNewVolumeGroup << ", ";
+ pyDump << "] = ";
+ pyDump << this << ".AffectedElemGroupsInRegion( "
+ << &theElems << ", " << &theNodesNot << ", " << theShape << " )";
+
+ return aListOfGroups._retn();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//================================================================================
/*!
- * \brief Set new nodes for given element
- * \param ide - element id
- * \param newIDs - new node ids
- * \retval CORBA::Boolean - true if result is OK
- */
+ \brief Generated skin mesh (containing 2D cells) from 3D mesh
+ The created 2D mesh elements based on nodes of free faces of boundary volumes
+ \return TRUE if operation has been completed successfully, FALSE otherwise
+*/
//================================================================================
-CORBA::Boolean SMESH_MeshEditor_i::ChangeElemNodes(CORBA::Long ide,
- const SMESH::long_array& newIDs)
+CORBA::Boolean SMESH_MeshEditor_i::Make2DMeshFrom3D()
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
- const SMDS_MeshElement* elem = GetMeshDS()->FindElement(ide);
- if(!elem) return false;
+ bool aResult = getEditor().Make2DMeshFrom3D();
- int nbn = newIDs.length();
- int i=0;
- vector<const SMDS_MeshNode*> aNodes(nbn);
- int nbn1=-1;
- for(; i<nbn; i++) {
- const SMDS_MeshNode* aNode = GetMeshDS()->FindNode(newIDs[i]);
- if(aNode) {
- nbn1++;
- aNodes[nbn1] = aNode;
- }
- }
- TPythonDump() << "isDone = " << this << ".ChangeElemNodes( "
- << ide << ", " << newIDs << " )";
-#ifdef _DEBUG_
- TPythonDump() << "print 'ChangeElemNodes: ', isDone";
-#endif
+ TPythonDump() << "isDone = " << this << ".Make2DMeshFrom3D()";
- return GetMeshDS()->ChangeElementNodes( elem, & aNodes[0], nbn1+1 );
+ declareMeshModified( /*isReComputeSafe=*/ !aResult );
+ return aResult;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return false;
}
-
+
//================================================================================
/*!
- * \brief Update myLastCreated* or myPreviewData
- * \param anEditor - it contains last modification results
+ * \brief Double nodes on shared faces between groups of volumes and create flat elements on demand.
+ * The list of groups must contain at least two groups. The groups have to be disjoint:
+ * no common element into two different groups.
+ * The nodes of the internal faces at the boundaries of the groups are doubled.
+ * Optionally, the internal faces are replaced by flat elements.
+ * Triangles are transformed into prisms, and quadrangles into hexahedrons.
+ * The flat elements are stored in groups of volumes.
+ * These groups are named according to the position of the group in the list:
+ * the group j_n_p is the group of the flat elements that are built between the group #n and the group #p in the list.
+ * If there is no shared faces between the group #n and the group #p in the list, the group j_n_p is not created.
+ * All the flat elements are gathered into the group named "joints3D" (or "joints2D" in 2D situation).
+ * The flat element of the multiple junctions between the simple junction are stored in a group named "jointsMultiples".
+ * @param theDomains - list of groups of volumes
+ * @param createJointElems - if TRUE, create the elements
+ * @return TRUE if operation has been completed successfully, FALSE otherwise
*/
//================================================================================
-void SMESH_MeshEditor_i::storeResult(::SMESH_MeshEditor& anEditor)
+CORBA::Boolean
+SMESH_MeshEditor_i::DoubleNodesOnGroupBoundaries( const SMESH::ListOfGroups& theDomains,
+ CORBA::Boolean createJointElems )
+ throw (SALOME::SALOME_Exception)
{
- if ( myPreviewMode ) { // --- MeshPreviewStruct filling ---
+ bool aResult = false;
- list<int> aNodesConnectivity;
- typedef map<int, int> TNodesMap;
- TNodesMap nodesMap;
+ SMESH_TRY;
+ initData();
+
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
- TPreviewMesh * aPreviewMesh = dynamic_cast< TPreviewMesh* >( anEditor.GetMesh() );
- SMDSAbs_ElementType previewType = aPreviewMesh->myPreviewType;
+ // MESSAGE("theDomains.length = "<<theDomains.length());
+ if ( theDomains.length() <= 1 )
+ THROW_SALOME_CORBA_EXCEPTION("At least 2 groups are required.", SALOME::BAD_PARAM);
+ vector<TIDSortedElemSet> domains;
+ domains.clear();
- SMESHDS_Mesh* aMeshDS = anEditor.GetMeshDS();
- int nbEdges = aMeshDS->NbEdges();
- int nbFaces = aMeshDS->NbFaces();
- int nbVolum = aMeshDS->NbVolumes();
- switch ( previewType ) {
- case SMDSAbs_Edge : nbFaces = nbVolum = 0; break;
- case SMDSAbs_Face : nbEdges = nbVolum = 0; break;
- case SMDSAbs_Volume: nbEdges = nbFaces = 0; break;
- default:;
+ 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 )*/ )
+ {
+// if ( aGrp->GetType() != SMESH::VOLUME )
+// THROW_SALOME_CORBA_EXCEPTION("Not a volume group", SALOME::BAD_PARAM);
+ TIDSortedElemSet domain;
+ domain.clear();
+ domains.push_back(domain);
+ SMESH::long_array_var anIDs = aGrp->GetIDs();
+ arrayToSet( anIDs, aMeshDS, domains[ i ], SMDSAbs_All );
}
- myPreviewData->nodesXYZ.length(aMeshDS->NbNodes());
- myPreviewData->elementTypes.length(nbEdges + nbFaces + nbVolum);
- int i = 0, j = 0;
- SMDS_ElemIteratorPtr itMeshElems = aMeshDS->elementsIterator();
+ }
- while ( itMeshElems->more() ) {
- const SMDS_MeshElement* aMeshElem = itMeshElems->next();
- if ( previewType != SMDSAbs_All && aMeshElem->GetType() != previewType )
- continue;
+ aResult = getEditor().DoubleNodesOnGroupBoundaries( domains, createJointElems );
+ // TODO publish the groups of flat elements in study
- SMDS_ElemIteratorPtr itElemNodes = aMeshElem->nodesIterator();
- while ( itElemNodes->more() ) {
- const SMDS_MeshNode* aMeshNode =
- static_cast<const SMDS_MeshNode*>( itElemNodes->next() );
- int aNodeID = aMeshNode->GetID();
- TNodesMap::iterator anIter = nodesMap.find(aNodeID);
- if ( anIter == nodesMap.end() ) {
- // filling the nodes coordinates
- myPreviewData->nodesXYZ[j].x = aMeshNode->X();
- myPreviewData->nodesXYZ[j].y = aMeshNode->Y();
- myPreviewData->nodesXYZ[j].z = aMeshNode->Z();
- anIter = nodesMap.insert( make_pair(aNodeID, j) ).first;
- j++;
- }
- aNodesConnectivity.push_back(anIter->second);
- }
+ declareMeshModified( /*isReComputeSafe=*/ !aResult );
- // filling the elements types
- SMDSAbs_ElementType aType;
- bool isPoly;
- /*if (aMeshElem->GetType() == SMDSAbs_Volume) {
- aType = SMDSAbs_Node;
- isPoly = false;
- }
- else*/ {
- aType = aMeshElem->GetType();
- isPoly = aMeshElem->IsPoly();
- }
+ // Update Python script
+ TPythonDump() << "isDone = " << this << ".DoubleNodesOnGroupBoundaries( " << &theDomains
+ << ", " << createJointElems << " )";
- myPreviewData->elementTypes[i].SMDS_ElementType = (SMESH::ElementType) aType;
- myPreviewData->elementTypes[i].isPoly = isPoly;
- myPreviewData->elementTypes[i].nbNodesInElement = aMeshElem->NbNodes();
- i++;
+ SMESH_CATCH( SMESH::throwCorbaException );
- }
- myPreviewData->nodesXYZ.length( j );
+ return aResult;
+}
- // filling the elements connectivities
- list<int>::iterator aConnIter = aNodesConnectivity.begin();
- myPreviewData->elementConnectivities.length(aNodesConnectivity.size());
- for( int i = 0; aConnIter != aNodesConnectivity.end(); aConnIter++, i++ )
- myPreviewData->elementConnectivities[i] = *aConnIter;
-
- return;
- }
+//================================================================================
+/*!
+ * \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 )
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ initData();
+
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
+
+ vector<TIDSortedElemSet> faceGroups;
+ faceGroups.clear();
+
+ for ( int i = 0, n = theGroupsOfFaces.length(); i < n; i++ )
{
- // add 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();
- }
- {
- // add 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();
+ 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 = getEditor().CreateFlatElementsOnFacesGroups( faceGroups );
+ // TODO publish the groups of flat elements in study
+
+ declareMeshModified( /*isReComputeSafe=*/ !aResult );
+
+ // Update Python script
+ TPythonDump() << this << ".CreateFlatElementsOnFacesGroups( " << &theGroupsOfFaces << " )";
+ return aResult;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return false;
}
//================================================================================
/*!
- * Return data of mesh edition preview
+ * \brief Identify all the elements around a geom shape, get the faces delimiting
+ * the hole.
+ *
+ * Build groups of volume to remove, groups of faces to replace on the skin of the
+ * object, groups of faces to remove inside the object, (idem edges).
+ * Build ordered list of nodes at the border of each group of faces to replace
+ * (to be used to build a geom subshape).
*/
//================================================================================
-SMESH::MeshPreviewStruct* SMESH_MeshEditor_i::GetPreviewData()
+void SMESH_MeshEditor_i::CreateHoleSkin(CORBA::Double radius,
+ GEOM::GEOM_Object_ptr theShape,
+ const char* groupName,
+ const SMESH::double_array& theNodesCoords,
+ SMESH::array_of_long_array_out GroupsOfNodes)
+ throw (SALOME::SALOME_Exception)
{
- return myPreviewData._retn();
+ SMESH_TRY;
+
+ initData();
+ std::vector<std::vector<int> > aListOfListOfNodes;
+ ::SMESH_MeshEditor aMeshEditor( myMesh );
+
+ theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other
+ if ( !theNodeSearcher )
+ theNodeSearcher = SMESH_MeshAlgos::GetNodeSearcher( *getMeshDS() );
+
+ vector<double> nodesCoords;
+ for (int i = 0; i < theNodesCoords.length(); i++)
+ {
+ nodesCoords.push_back( theNodesCoords[i] );
+ }
+
+ TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape );
+ aMeshEditor.CreateHoleSkin(radius, aShape, theNodeSearcher, groupName,
+ nodesCoords, aListOfListOfNodes);
+
+ GroupsOfNodes = new SMESH::array_of_long_array;
+ GroupsOfNodes->length( aListOfListOfNodes.size() );
+ std::vector<std::vector<int> >::iterator llIt = aListOfListOfNodes.begin();
+ for ( CORBA::Long i = 0; llIt != aListOfListOfNodes.end(); llIt++, i++ )
+ {
+ vector<int>& aListOfNodes = *llIt;
+ vector<int>::iterator lIt = aListOfNodes.begin();;
+ SMESH::long_array& aGroup = (*GroupsOfNodes)[ i ];
+ aGroup.length( aListOfNodes.size() );
+ for ( int j = 0; lIt != aListOfNodes.end(); lIt++, j++ )
+ aGroup[ j ] = (*lIt);
+ }
+ TPythonDump() << "lists_nodes = " << this << ".CreateHoleSkin( "
+ << radius << ", "
+ << theShape
+ << ", '" << groupName << "', "
+ << theNodesCoords << " )";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
-//================================================================================
+// issue 20749 ===================================================================
/*!
- * \brief Returns list of it's IDs of created nodes
- * \retval SMESH::long_array* - list of node ID
+ * \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::long_array* SMESH_MeshEditor_i::GetLastCreatedNodes()
+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)
+ throw (SALOME::SALOME_Exception)
{
- return myLastCreatedNodes._retn();
+ SMESH_TRY;
+ 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;
+ prepareIdSource( idSource );
+ 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
+ getEditor().MakeBoundaryMesh( elements,
+ ::SMESH_MeshEditor::Bnd_Dimension(dim),
+ smesh_group,
+ smesh_mesh,
+ toCopyElements,
+ toCopyExistingBondary);
+
+ 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();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return SMESH::SMESH_Mesh::_nil();
}
//================================================================================
/*!
- * \brief Returns list of it's IDs of created elements
- * \retval SMESH::long_array* - list of elements' ID
+ * \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
*/
//================================================================================
-SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedElems()
+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)
{
- return myLastCreatedElems._retn();
-}
+ SMESH_TRY;
+ initData();
-//=======================================================================
-//function : ConvertToQuadratic
-//purpose :
-//=======================================================================
+ if ( dim > SMESH::BND_1DFROM2D )
+ THROW_SALOME_CORBA_EXCEPTION("Invalid boundary dimension", SALOME::BAD_PARAM);
-void SMESH_MeshEditor_i::ConvertToQuadratic(CORBA::Boolean theForce3d)
-{
- ::SMESH_MeshEditor anEditor( myMesh );
- anEditor.ConvertToQuadratic(theForce3d);
- TPythonDump() << this << ".ConvertToQuadratic( " << theForce3d << " )";
-}
+ // separate groups belonging to this and other mesh
+ SMESH::ListOfIDSources_var groupsOfThisMesh = new SMESH::ListOfIDSources;
+ SMESH::ListOfIDSources_var groupsOfOtherMesh = new SMESH::ListOfIDSources;
+ groupsOfThisMesh->length( groups.length() );
+ groupsOfOtherMesh->length( groups.length() );
+ int nbGroups = 0, nbGroupsOfOtherMesh = 0;
+ for ( int i = 0; i < groups.length(); ++i )
+ {
+ SMESH::SMESH_Mesh_var m = groups[i]->GetMesh();
+ if ( myMesh_i != SMESH::DownCast<SMESH_Mesh_i*>( m ))
+ groupsOfOtherMesh[ nbGroupsOfOtherMesh++ ] = groups[i];
+ else
+ groupsOfThisMesh[ nbGroups++ ] = groups[i];
+ if ( SMESH::DownCast<SMESH_Mesh_i*>( groups[i] ))
+ THROW_SALOME_CORBA_EXCEPTION("expect a group but recieve a mesh", SALOME::BAD_PARAM);
+ }
+ groupsOfThisMesh->length( nbGroups );
+ groupsOfOtherMesh->length( nbGroupsOfOtherMesh );
-//=======================================================================
-//function : ConvertFromQuadratic
-//purpose :
-//=======================================================================
+ int nbAdded = 0;
+ TPythonDump pyDump;
-CORBA::Boolean SMESH_MeshEditor_i::ConvertFromQuadratic()
-{
- ::SMESH_MeshEditor anEditor( myMesh );
- CORBA::Boolean isDone = anEditor.ConvertFromQuadratic();
- TPythonDump() << this << ".ConvertFromQuadratic()";
- return isDone;
-}
+ if ( nbGroupsOfOtherMesh > 0 )
+ {
+ // process groups belonging to another mesh
+ SMESH::SMESH_Mesh_var otherMesh = groupsOfOtherMesh[0]->GetMesh();
+ SMESH::SMESH_MeshEditor_var editor = otherMesh->GetMeshEditor();
+ nbAdded += editor->MakeBoundaryElements( dim, groupName, meshName, toCopyAll,
+ groupsOfOtherMesh, mesh, group );
+ }
-//=======================================================================
-//function : makeMesh
-//purpose : create a named imported mesh
-//=======================================================================
+ SMESH::SMESH_Mesh_var mesh_var;
+ SMESH::SMESH_Group_var group_var;
-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" );
+ // 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();
- SALOMEDS::StudyBuilder_var builder = study->NewBuilder();
- SALOMEDS::GenericAttribute_var anAttr
- = builder->FindOrCreateAttribute( meshSO, "AttributePixMap" );
- SALOMEDS::AttributePixMap::_narrow( anAttr )->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
+ // source mesh
+ SMESH_Mesh* srcMesh = ( toCopyMesh && !toCopyAll ) ? myMesh : tgtMesh;
+ SMESHDS_Mesh* srcMeshDS = srcMesh->GetMeshDS();
- return mesh._retn();
+ // 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 ( groups.length() > 0 )
+ {
+ for ( int i = 0; i < nbGroups; ++i )
+ {
+ elements.clear();
+ if ( idSourceToSet( groupsOfThisMesh[i], srcMeshDS, elements, elemType,/*emptyIfIsMesh=*/0 ))
+ {
+ SMESH::Bnd_Dimension bdim =
+ ( elemType == SMDSAbs_Volume ) ? SMESH::BND_2DFROM3D : SMESH::BND_1DFROM2D;
+ nbAdded += getEditor().MakeBoundaryMesh( elements,
+ ::SMESH_MeshEditor::Bnd_Dimension(bdim),
+ smesh_group,
+ tgtMesh,
+ /*toCopyElements=*/false,
+ /*toCopyExistingBondary=*/srcMesh != tgtMesh,
+ /*toAddExistingBondary=*/true,
+ /*aroundElements=*/true);
+ }
+ }
+ }
+ else
+ {
+ nbAdded += getEditor().MakeBoundaryMesh( elements,
+ ::SMESH_MeshEditor::Bnd_Dimension(dim),
+ smesh_group,
+ tgtMesh,
+ /*toCopyElements=*/false,
+ /*toCopyExistingBondary=*/srcMesh != tgtMesh,
+ /*toAddExistingBondary=*/true);
+ }
+ 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;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
