-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2022 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
#include "SMDS_Mesh0DElement.hxx"
#include "SMDS_MeshFace.hxx"
#include "SMDS_MeshVolume.hxx"
-#include "SMDS_PolyhedralVolumeOfNodes.hxx"
#include "SMDS_SetIterator.hxx"
#include "SMDS_VolumeTool.hxx"
#include "SMESHDS_Group.hxx"
//!< Constructor
TPreviewMesh(SMDSAbs_ElementType previewElements = SMDSAbs_All) {
_isShapeToMesh = (_id = 0);
- _myMeshDS = new SMESHDS_Mesh( _id, true );
+ _meshDS = new SMESHDS_Mesh( _id, true );
myPreviewType = previewElements;
}
//!< Copy a set of elements
{
// copy element nodes
int anElemNbNodes = anElem->NbNodes();
- vector< int > anElemNodesID( anElemNbNodes ) ;
+ vector< smIdType > anElemNodesID( anElemNbNodes ) ;
SMDS_ElemIteratorPtr itElemNodes = anElem->nodesIterator();
- for ( int i = 0; itElemNodes->more(); i++)
+ for ( smIdType i = 0; itElemNodes->more(); i++)
{
const SMDS_MeshNode* anElemNode = cast2Node( itElemNodes->next() );
Copy( anElemNode );
//!< Copy a node
SMDS_MeshNode* Copy( const SMDS_MeshNode* anElemNode )
{
- return _myMeshDS->AddNodeWithID(anElemNode->X(), anElemNode->Y(), anElemNode->Z(),
- anElemNode->GetID());
+ return _meshDS->AddNodeWithID(anElemNode->X(), anElemNode->Y(), anElemNode->Z(),
+ anElemNode->GetID());
}
void RemoveAll()
{
}
void Remove( SMDSAbs_ElementType type )
{
- SMDS_ElemIteratorPtr eIt = GetMeshDS()->elementsIterator( type );
+ Remove( GetMeshDS()->elementsIterator( type ));
+ }
+ void Remove( SMDS_ElemIteratorPtr eIt )
+ {
while ( eIt->more() )
GetMeshDS()->RemoveFreeElement( eIt->next(), /*sm=*/0, /*fromGroups=*/false );
}
//=============================================================================
/*!
- * \brief Deleter of theNodeSearcher at any compute event occurred
+ * \brief Deleter of theNodeSearcher and theElementSearcher at any compute event occurred
*/
//=============================================================================
//!< Delete theNodeSearcher
static void Delete()
{
- if ( theNodeSearcher ) delete theNodeSearcher; theNodeSearcher = 0;
- if ( theElementSearcher ) delete theElementSearcher; theElementSearcher = 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
*/
//================================================================================
- void arrayToSet(const SMESH::long_array & IDs,
- const SMESHDS_Mesh* aMesh,
- TIDSortedElemSet& aMap,
- const SMDSAbs_ElementType aType = SMDSAbs_All,
- SMDS_MeshElement::Filter* aFilter = NULL)
+ void arrayToSet(const SMESH::smIdType_array & IDs,
+ const SMESHDS_Mesh* aMesh,
+ TIDSortedElemSet& aMap,
+ const SMDSAbs_ElementType aType = SMDSAbs_All,
+ SMDS_MeshElement::Filter* aFilter = NULL)
{
SMDS_MeshElement::NonNullFilter filter1;
SMDS_MeshElement::TypeFilter filter2( aType );
*/
//================================================================================
- void idSourceToNodeSet(SMESH::SMESH_IDSource_ptr theObject,
- const SMESHDS_Mesh* theMeshDS,
- TIDSortedNodeSet& theNodeSet)
+ 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 ( CORBA::ULong 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 ))
+ if ( SMESH::DownCast<SMESH_Mesh_i*>( theObject ))
{
- SMDS_NodeIteratorPtr nIt = theMeshDS->nodesIterator();
- while ( nIt->more( ))
+ for ( SMDS_NodeIteratorPtr nIt = theMeshDS->nodesIterator(); nIt->more(); )
if ( const SMDS_MeshElement * elem = nIt->next() )
theNodeSet.insert( elem->begin_nodes(), elem->end_nodes());
}
else
{
- for ( CORBA::ULong i = 0; i < aElementsId->length(); i++ )
- if ( const SMDS_MeshElement * elem = theMeshDS->FindElement( aElementsId[i] ))
- theNodeSet.insert( elem->begin_nodes(), elem->end_nodes());
+ SMESH::array_of_ElementType_var types = theObject->GetTypes();
+ SMESH::smIdType_array_var aElementsId = theObject->GetIDs();
+ if ( types->length() == 1 && types[0] == SMESH::NODE)
+ {
+ for ( CORBA::ULong i = 0; i < aElementsId->length(); i++ )
+ if ( const SMDS_MeshNode * n = theMeshDS->FindNode( aElementsId[i] ))
+ theNodeSet.insert( theNodeSet.end(), n);
+ }
+ else
+ {
+ for ( CORBA::ULong i = 0; i < aElementsId->length(); i++ )
+ if ( const SMDS_MeshElement * elem = theMeshDS->FindElement( aElementsId[i] ))
+ theNodeSet.insert( elem->begin_nodes(), elem->end_nodes());
+ }
}
}
*/
//================================================================================
- string getPartIOR( SMESH::SMESH_IDSource_ptr theMeshPart, SMESH::ElementType type)
+ string getPartIOR( SMESH::SMESH_IDSource_ptr theMeshPart, SMESH::ElementType type = SMESH::ALL )
{
+ if ( SMESH::DownCast<SMESH_Mesh_i*>( theMeshPart ))
+ return "";
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
//================================================================================
SMESH::MeshPreviewStruct* SMESH_MeshEditor_i::GetPreviewData()
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
const bool hasBadElems = ( getEditor().GetError() && getEditor().GetError()->HasBadElems() );
- if ( myIsPreviewMode || hasBadElems ) { // --- MeshPreviewStruct filling ---
-
+ if ( myIsPreviewMode || hasBadElems )
+ {
list<int> aNodesConnectivity;
typedef map<int, int> TNodesMap;
TNodesMap nodesMap;
SMESHDS_Mesh* aMeshDS;
- std::auto_ptr< SMESH_MeshPartDS > aMeshPartDS;
+ std::unique_ptr< SMESH_MeshPartDS > aMeshPartDS;
if ( hasBadElems ) {
- aMeshPartDS.reset( new SMESH_MeshPartDS( getEditor().GetError()->myBadElements ));
+ const list<const SMDS_MeshElement*>& badElems =
+ static_cast<SMESH_BadInputElements*>( getEditor().GetError().get() )->myBadElements;
+ aMeshPartDS.reset( new SMESH_MeshPartDS( badElems ));
aMeshDS = aMeshPartDS.get();
}
else {
aMeshElem->nodeIterator() );
while ( itElemNodes->more() ) {
const SMDS_MeshNode* aMeshNode = itElemNodes->next();
- int aNodeID = aMeshNode->GetID();
+ smIdType aNodeID = aMeshNode->GetID();
TNodesMap::iterator anIter = nodesMap.find(aNodeID);
if ( anIter == nodesMap.end() ) {
// filling the nodes coordinates
*/
//================================================================================
-SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedNodes()
- throw (SALOME::SALOME_Exception)
+SMESH::smIdType_array* SMESH_MeshEditor_i::GetLastCreatedNodes()
{
SMESH_TRY;
- SMESH::long_array_var myLastCreatedNodes = new SMESH::long_array();
+ SMESH::smIdType_array_var myLastCreatedNodes = new SMESH::smIdType_array();
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();
+ myLastCreatedNodes->length( aSeq.size() );
+ for ( size_t i = 0; i < aSeq.size(); i++)
+ myLastCreatedNodes[i] = aSeq[i]->GetID();
return myLastCreatedNodes._retn();
SMESH_CATCH( SMESH::throwCorbaException );
*/
//================================================================================
-SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedElems()
- throw (SALOME::SALOME_Exception)
+SMESH::smIdType_array* SMESH_MeshEditor_i::GetLastCreatedElems()
{
SMESH_TRY;
- SMESH::long_array_var myLastCreatedElems = new SMESH::long_array();
+ SMESH::smIdType_array_var myLastCreatedElems = new SMESH::smIdType_array();
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();
+ myLastCreatedElems->length( aSeq.size() );
+ for ( size_t i = 0; i < aSeq.size(); i++ )
+ myLastCreatedElems[i] = aSeq[i]->GetID();
return myLastCreatedElems._retn();
SMESH_CATCH( SMESH::throwCorbaException );
//purpose : Clears sequences of last created elements and nodes
//=======================================================================
-void SMESH_MeshEditor_i::ClearLastCreated() throw (SALOME::SALOME_Exception)
+void SMESH_MeshEditor_i::ClearLastCreated()
{
SMESH_TRY;
getEditor().ClearLastCreated();
//=======================================================================
SMESH::ComputeError* SMESH_MeshEditor_i::GetLastError()
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
SMESH::ComputeError_var errOut = new SMESH::ComputeError;
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();
+ errOut->hasBadMesh = errIn->HasBadElems();
}
else
{
struct SMESH_MeshEditor_i::_IDSource : public virtual POA_SMESH::SMESH_IDSource,
public virtual SALOME::GenericObj_i
{
- 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::long_array* GetNbElementsByType()
+ SMESH::smIdType_array _ids;
+ SMESH::ElementType _type;
+ SMESH::SMESH_Mesh_ptr _mesh;
+ SMESH::smIdType_array* GetIDs() { return new SMESH::smIdType_array( _ids ); }
+ SMESH::smIdType_array* GetMeshInfo() { return 0; }
+ SMESH::smIdType_array* GetNbElementsByType()
{
- SMESH::long_array_var aRes = new SMESH::long_array();
+ SMESH::smIdType_array_var aRes = new SMESH::smIdType_array();
aRes->length(SMESH::NB_ELEMENT_TYPES);
- for (int i = 0; i < SMESH::NB_ELEMENT_TYPES; i++)
+ for (smIdType i = 0; i < SMESH::NB_ELEMENT_TYPES; i++)
aRes[ i ] = ( i == _type ) ? _ids.length() : 0;
return aRes._retn();
}
}
};
-SMESH::SMESH_IDSource_ptr SMESH_MeshEditor_i::MakeIDSource(const SMESH::long_array& ids,
- SMESH::ElementType type)
+SMESH::SMESH_IDSource_ptr SMESH_MeshEditor_i::MakeIDSource(const SMESH::smIdType_array& ids,
+ SMESH::ElementType type)
{
_IDSource* idSrc = new _IDSource;
idSrc->_mesh = myMesh_i->_this();
return SMESH::DownCast<SMESH_MeshEditor_i::_IDSource*>( idSource );
}
-CORBA::Long* SMESH_MeshEditor_i::GetTemporaryIDs( SMESH::SMESH_IDSource_ptr& idSource,
- int& nbIds)
+SMESH::smIdType* SMESH_MeshEditor_i::GetTemporaryIDs( SMESH::SMESH_IDSource_ptr& idSource,
+ SMESH::smIdType& nbIds)
{
if ( _IDSource* tmpIdSource = SMESH::DownCast<SMESH_MeshEditor_i::_IDSource*>( idSource ))
{
- nbIds = (int) tmpIdSource->_ids.length();
+ nbIds = (SMESH::smIdType) tmpIdSource->_ids.length();
return & tmpIdSource->_ids[0];
}
nbIds = 0;
//=============================================================================
CORBA::Boolean
-SMESH_MeshEditor_i::RemoveElements(const SMESH::long_array & IDsOfElements)
- throw (SALOME::SALOME_Exception)
+SMESH_MeshEditor_i::RemoveElements(const SMESH::smIdType_array & IDsOfElements)
{
SMESH_TRY;
initData();
- list< int > IdList;
+ list< smIdType > IdList;
for ( CORBA::ULong i = 0; i < IDsOfElements.length(); i++ )
IdList.push_back( IDsOfElements[i] );
*/
//=============================================================================
-CORBA::Boolean SMESH_MeshEditor_i::RemoveNodes(const SMESH::long_array & IDsOfNodes)
- throw (SALOME::SALOME_Exception)
+CORBA::Boolean SMESH_MeshEditor_i::RemoveNodes(const SMESH::smIdType_array & IDsOfNodes)
{
SMESH_TRY;
initData();
- list< int > IdList;
+ list< smIdType > IdList;
for ( CORBA::ULong i = 0; i < IDsOfNodes.length(); i++)
IdList.push_back( IDsOfNodes[i] );
//=============================================================================
/*!
- *
+ * Remove orphan nodes
*/
//=============================================================================
-CORBA::Long SMESH_MeshEditor_i::RemoveOrphanNodes()
- throw (SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_MeshEditor_i::RemoveOrphanNodes()
{
SMESH_TRY;
initData();
SMESH::Controls::Filter::GetElementsId( getMeshDS(), predicate, seq );
// remove orphan nodes (if there are any)
- list< int > IdList( seq.begin(), seq.end() );
+ list< smIdType > IdList( seq.begin(), seq.end() );
- int nbNodesBefore = myMesh->NbNodes();
+ SMESH::smIdType nbNodesBefore = myMesh->NbNodes();
getEditor().Remove( IdList, true );
- int nbNodesAfter = myMesh->NbNodes();
+ SMESH::smIdType nbNodesAfter = myMesh->NbNodes();
declareMeshModified( /*isReComputeSafe=*/ IdList.size() == 0 ); // issue 0020693
return nbNodesBefore - nbNodesAfter;
return 0;
}
+//=============================================================================
+/*!
+ * Remove a node and fill a hole appeared by changing surrounding faces
+ */
+//=============================================================================
+
+void SMESH_MeshEditor_i::RemoveNodeWithReconnection( SMESH::smIdType nodeID )
+{
+ SMESH_TRY;
+ initData();
+
+ const SMDS_MeshNode * node = getMeshDS()->FindNode( nodeID );
+ if ( ! node )
+ THROW_SALOME_CORBA_EXCEPTION( SMESH_Comment( "Invalid node ID ") << nodeID,
+ SALOME::BAD_PARAM);
+ if ( node->NbInverseElements( SMDSAbs_Volume ) > 0 )
+ THROW_SALOME_CORBA_EXCEPTION( "RemoveNodeWithReconnection() applies to 2D mesh only",
+ SALOME::BAD_PARAM);
+
+ if ( myIsPreviewMode ) // make preview data
+ {
+ // in a preview mesh, make edges linked to a node
+ TPreviewMesh& tmpMesh = *getPreviewMesh( SMDSAbs_Edge );
+ TIDSortedElemSet linkedNodes;
+ ::SMESH_MeshEditor::GetLinkedNodes( node, linkedNodes );
+ SMDS_MeshNode *nodeCpy1 = tmpMesh.Copy( node );
+ for ( const SMDS_MeshElement* n : linkedNodes )
+ {
+ SMDS_MeshNode *nodeCpy2 = tmpMesh.Copy ( cast2Node( n ));
+ tmpMesh.GetMeshDS()->AddEdge( nodeCpy1, nodeCpy2 );
+ }
+ // copy surrounding faces
+ for ( SMDS_ElemIteratorPtr fIt = node->GetInverseElementIterator( SMDSAbs_Face ); fIt->more(); )
+ tmpMesh.Copy ( fIt->next() );
+
+ // remove copied node
+ if ( nodeCpy1 )
+ getEditor().RemoveNodeWithReconnection( nodeCpy1 );
+ }
+ else
+ {
+ getEditor().RemoveNodeWithReconnection( node );
+
+ // Update Python script
+ TPythonDump() << this << ".RemoveNodeWithReconnection( " << nodeID << " )";
+
+ declareMeshModified( /*isReComputeSafe=*/ true );
+ }
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+}
+
//=============================================================================
/*!
* Add a new node.
*/
//=============================================================================
-CORBA::Long SMESH_MeshEditor_i::AddNode(CORBA::Double x,CORBA::Double y, CORBA::Double z)
- throw (SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_MeshEditor_i::AddNode(CORBA::Double x,CORBA::Double y, CORBA::Double z)
{
SMESH_TRY;
initData();
*/
//=============================================================================
-CORBA::Long SMESH_MeshEditor_i::Add0DElement(CORBA::Long IDOfNode,
- CORBA::Boolean DuplicateElements)
- throw (SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_MeshEditor_i::Add0DElement(SMESH::smIdType IDOfNode,
+ CORBA::Boolean DuplicateElements)
{
SMESH_TRY;
initData();
*/
//=============================================================================
-CORBA::Long SMESH_MeshEditor_i::AddBall(CORBA::Long IDOfNode, CORBA::Double diameter)
- throw (SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_MeshEditor_i::AddBall(SMESH::smIdType IDOfNode, CORBA::Double diameter)
{
SMESH_TRY;
initData();
*/
//=============================================================================
-CORBA::Long SMESH_MeshEditor_i::AddEdge(const SMESH::long_array & IDsOfNodes)
- throw (SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_MeshEditor_i::AddEdge(const SMESH::smIdType_array & IDsOfNodes)
{
SMESH_TRY;
initData();
- int NbNodes = IDsOfNodes.length();
+ SMESH::smIdType NbNodes = IDsOfNodes.length();
SMDS_MeshElement* elem = 0;
if (NbNodes == 2)
{
- CORBA::Long index1 = IDsOfNodes[0];
- CORBA::Long index2 = IDsOfNodes[1];
+ SMESH::smIdType index1 = IDsOfNodes[0];
+ SMESH::smIdType index2 = IDsOfNodes[1];
elem = getMeshDS()->AddEdge( getMeshDS()->FindNode(index1),
getMeshDS()->FindNode(index2));
<< index1 << ", " << index2 <<" ])";
}
if (NbNodes == 3) {
- CORBA::Long n1 = IDsOfNodes[0];
- CORBA::Long n2 = IDsOfNodes[1];
- CORBA::Long n12 = IDsOfNodes[2];
+ SMESH::smIdType n1 = IDsOfNodes[0];
+ SMESH::smIdType n2 = IDsOfNodes[1];
+ SMESH::smIdType n12 = IDsOfNodes[2];
elem = getMeshDS()->AddEdge( getMeshDS()->FindNode(n1),
getMeshDS()->FindNode(n2),
getMeshDS()->FindNode(n12));
*/
//=============================================================================
-CORBA::Long SMESH_MeshEditor_i::AddFace(const SMESH::long_array & IDsOfNodes)
- throw (SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_MeshEditor_i::AddFace(const SMESH::smIdType_array & IDsOfNodes)
{
SMESH_TRY;
initData();
*/
//=============================================================================
-CORBA::Long SMESH_MeshEditor_i::AddPolygonalFace (const SMESH::long_array & IDsOfNodes)
- throw (SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_MeshEditor_i::AddPolygonalFace (const SMESH::smIdType_array & IDsOfNodes)
{
SMESH_TRY;
initData();
if ( ! ( nodes[i] = getMeshDS()->FindNode( IDsOfNodes[i] )))
return 0;
+ if ( NbNodes == 0 )
+ {
+ INFOS("Polygon without nodes is forbidden");
+ return 0;
+ }
+
const SMDS_MeshElement* elem = getMeshDS()->AddPolygonalFace(nodes);
// Update Python script
*/
//=============================================================================
-CORBA::Long SMESH_MeshEditor_i::AddQuadPolygonalFace (const SMESH::long_array & IDsOfNodes)
- throw (SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_MeshEditor_i::AddQuadPolygonalFace (const SMESH::smIdType_array & IDsOfNodes)
{
SMESH_TRY;
initData();
for (int i = 0; i < NbNodes; i++)
nodes[i] = getMeshDS()->FindNode(IDsOfNodes[i]);
+ if ( NbNodes == 0 )
+ {
+ INFOS("Polygon without nodes is forbidden");
+ return 0;
+ }
+
const SMDS_MeshElement* elem = getMeshDS()->AddQuadPolygonalFace(nodes);
// Update Python script
*/
//=============================================================================
-CORBA::Long SMESH_MeshEditor_i::AddVolume(const SMESH::long_array & IDsOfNodes)
- throw (SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_MeshEditor_i::AddVolume(const SMESH::smIdType_array & IDsOfNodes)
{
SMESH_TRY;
initData();
* AddPolyhedralVolume
*/
//=============================================================================
-CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolume (const SMESH::long_array & IDsOfNodes,
+SMESH::smIdType SMESH_MeshEditor_i::AddPolyhedralVolume (const SMESH::smIdType_array & IDsOfNodes,
const SMESH::long_array & Quantities)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
*/
//=============================================================================
-CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolumeByFaces (const SMESH::long_array & IdsOfFaces)
- throw (SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_MeshEditor_i::AddPolyhedralVolumeByFaces (const SMESH::smIdType_array & IdsOfFaces)
{
SMESH_TRY;
initData();
SMESH_MeshEditor_i::Create0DElementsOnAllNodes(SMESH::SMESH_IDSource_ptr theObject,
const char* theGroupName,
CORBA::Boolean theDuplicateElements)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
if ( idSourceToSet( theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
getEditor().Create0DElementsOnAllNodes( elements, elems0D, theDuplicateElements );
- SMESH::long_array_var newElems = new SMESH::long_array;
+ SMESH::smIdType_array_var newElems = new SMESH::smIdType_array;
newElems->length( elems0D.size() );
TIDSortedElemSet::iterator eIt = elems0D.begin();
for ( size_t i = 0; i < elems0D.size(); ++i, ++eIt )
*/
//=============================================================================
-void SMESH_MeshEditor_i::SetNodeOnVertex(CORBA::Long NodeID, CORBA::Long VertexID)
- throw (SALOME::SALOME_Exception)
+void SMESH_MeshEditor_i::SetNodeOnVertex(SMESH::smIdType NodeID, CORBA::Long VertexID)
{
SMESH_TRY;
*/
//=============================================================================
-void SMESH_MeshEditor_i::SetNodeOnEdge(CORBA::Long NodeID, CORBA::Long EdgeID,
+void SMESH_MeshEditor_i::SetNodeOnEdge(SMESH::smIdType NodeID, CORBA::Long EdgeID,
CORBA::Double paramOnEdge)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
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);
-
+ {
+ SMESH_Comment txt("Invalid paramOnEdge. It must vary in range [ ");
+ txt << f << ", " << l << " ]";
+ THROW_SALOME_CORBA_EXCEPTION(txt.c_str(), SALOME::BAD_PARAM);
+ }
mesh->SetNodeOnEdge( node, EdgeID, paramOnEdge );
myMesh->SetIsModified( true );
*/
//=============================================================================
-void SMESH_MeshEditor_i::SetNodeOnFace(CORBA::Long NodeID, CORBA::Long FaceID,
+void SMESH_MeshEditor_i::SetNodeOnFace(SMESH::smIdType NodeID, CORBA::Long FaceID,
CORBA::Double u, CORBA::Double v)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
SMESHDS_Mesh * mesh = getMeshDS();
v > surf.LastVParameter() );
if ( isOut ) {
-#ifdef _DEBUG_
- 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_Comment txt("Invalid UV. U must vary in range [ ");
+ txt << surf.FirstUParameter() << ", " << surf.LastUParameter() << " ], ";
+ txt << "V must vary in range [ ";
+ txt << surf.FirstVParameter() << ", " << surf.LastVParameter() << " ]";
+ THROW_SALOME_CORBA_EXCEPTION(txt.c_str(), SALOME::BAD_PARAM);
}
mesh->SetNodeOnFace( node, FaceID, u, v );
*/
//=============================================================================
-void SMESH_MeshEditor_i::SetNodeInVolume(CORBA::Long NodeID, CORBA::Long SolidID)
- throw (SALOME::SALOME_Exception)
+void SMESH_MeshEditor_i::SetNodeInVolume(SMESH::smIdType NodeID, CORBA::Long SolidID)
{
SMESH_TRY;
SMESHDS_Mesh * mesh = getMeshDS();
*/
//=============================================================================
-void SMESH_MeshEditor_i::SetMeshElementOnShape(CORBA::Long ElementID,
+void SMESH_MeshEditor_i::SetMeshElementOnShape(SMESH::smIdType ElementID,
CORBA::Long ShapeID)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
SMESHDS_Mesh * mesh = getMeshDS();
*/
//=============================================================================
-CORBA::Boolean SMESH_MeshEditor_i::InverseDiag(CORBA::Long NodeID1,
- CORBA::Long NodeID2)
- throw (SALOME::SALOME_Exception)
+CORBA::Boolean SMESH_MeshEditor_i::InverseDiag(SMESH::smIdType NodeID1,
+ SMESH::smIdType NodeID2)
{
SMESH_TRY;
initData();
*/
//=============================================================================
-CORBA::Boolean SMESH_MeshEditor_i::DeleteDiag(CORBA::Long NodeID1,
- CORBA::Long NodeID2)
- throw (SALOME::SALOME_Exception)
+CORBA::Boolean SMESH_MeshEditor_i::DeleteDiag(SMESH::smIdType NodeID1,
+ SMESH::smIdType NodeID2)
{
SMESH_TRY;
initData();
return 0;
}
+//=============================================================================
+/*!
+ * \brief Split a diagonal of a quadrangle formed by two adjacent triangles
+ * so that four new triangles appear in place of the two triangles
+ */
+//=============================================================================
+
+void SMESH_MeshEditor_i::AddNodeOnSegment(SMESH::smIdType nodeID1,
+ SMESH::smIdType nodeID2,
+ CORBA::Double position)
+{
+ SMESH_TRY;
+ initData();
+
+ const SMDS_MeshNode * n1 = getMeshDS()->FindNode( nodeID1 );
+ const SMDS_MeshNode * n2 = getMeshDS()->FindNode( nodeID2 );
+ if ( !n1 )
+ THROW_SALOME_CORBA_EXCEPTION( SMESH_Comment( "Invalid node ID: ") << nodeID1,
+ SALOME::BAD_PARAM);
+ if ( !n2 )
+ THROW_SALOME_CORBA_EXCEPTION( SMESH_Comment( "Invalid node ID: ") << nodeID2,
+ SALOME::BAD_PARAM);
+
+ if ( myIsPreviewMode ) // make preview data
+ {
+ TPreviewMesh* tmpMesh = getPreviewMesh();
+ TIDSortedElemSet elemSet, avoidSet;
+ TopoDS_Shape shape;
+ while ( const SMDS_MeshElement* face = SMESH_MeshAlgos::FindFaceInSet( n1, n2,
+ elemSet, avoidSet ))
+ {
+ if ( avoidSet.empty() )
+ {
+ shape = getMeshDS()->IndexToShape( face->GetShapeID() );
+ if ( !shape.IsNull() )
+ {
+ tmpMesh->ShapeToMesh( TopoDS_Shape() );
+ tmpMesh->ShapeToMesh( shape );
+ }
+ }
+ SMDS_MeshElement* faceCopy = tmpMesh->Copy ( face );
+ avoidSet.insert( face );
+
+ if ( !shape.IsNull() )
+ tmpMesh->GetMeshDS()->SetMeshElementOnShape( faceCopy, shape );
+ }
+ n1 = tmpMesh->GetMeshDS()->FindNode( nodeID1 );
+ n2 = tmpMesh->GetMeshDS()->FindNode( nodeID2 );
+
+ if ( !shape.IsNull() )
+ {
+ tmpMesh->GetMeshDS()->SetMeshElementOnShape( n1, shape );
+ tmpMesh->GetMeshDS()->SetMeshElementOnShape( n2, shape );
+ }
+ }
+
+ getEditor().SplitEdge( n1, n2, position );
+
+ if ( !myIsPreviewMode )
+ {
+ // Update Python script
+ TPythonDump() << this << ".AddNodeOnSegment( "
+ << nodeID1 << ", " << nodeID2 << ", " << position << " )";
+
+ declareMeshModified( /*isReComputeSafe=*/true );
+ }
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+}
+
+//=============================================================================
+/*!
+ * \brief Split a face into triangles by adding a new node onto the face
+ * and connecting the new node with face nodes
+ */
+//=============================================================================
+
+void SMESH_MeshEditor_i::AddNodeOnFace(SMESH::smIdType theFaceID,
+ CORBA::Double theX,
+ CORBA::Double theY,
+ CORBA::Double theZ)
+{
+ SMESH_TRY;
+ initData();
+
+ const SMDS_MeshElement * face = getMeshDS()->FindElement( theFaceID );
+ if ( !face )
+ THROW_SALOME_CORBA_EXCEPTION( SMESH_Comment( "Invalid face ID: ") << theFaceID,
+ SALOME::BAD_PARAM);
+ if ( face->GetType() != SMDSAbs_Face )
+ THROW_SALOME_CORBA_EXCEPTION( "The element is not a face ", SALOME::BAD_PARAM );
+
+ if ( myIsPreviewMode ) // make preview data
+ {
+ TPreviewMesh* tmpMesh = getPreviewMesh();
+ face = tmpMesh->Copy ( face );
+ }
+
+ getEditor().SplitFace( face, theX, theY, theZ );
+
+ if ( !myIsPreviewMode )
+ {
+ // Update Python script
+ TPythonDump() << this << ".AddNodeOnFace( "
+ << theFaceID << ", "
+ << theX << ", "
+ << theY << ", "
+ << theZ << " )";
+
+ declareMeshModified( /*isReComputeSafe=*/true );
+ }
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+}
+
//=============================================================================
/*!
*
*/
//=============================================================================
-CORBA::Boolean SMESH_MeshEditor_i::Reorient(const SMESH::long_array & IDsOfElements)
- throw (SALOME::SALOME_Exception)
+CORBA::Boolean SMESH_MeshEditor_i::Reorient(const SMESH::smIdType_array & IDsOfElements)
{
SMESH_TRY;
initData();
for ( CORBA::ULong i = 0; i < IDsOfElements.length(); i++ )
{
- CORBA::Long index = IDsOfElements[i];
+ SMESH::smIdType index = IDsOfElements[i];
const SMDS_MeshElement * elem = getMeshDS()->FindElement(index);
if ( elem )
getEditor().Reorient( elem );
//=============================================================================
CORBA::Boolean SMESH_MeshEditor_i::ReorientObject(SMESH::SMESH_IDSource_ptr theObject)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
prepareIdSource( theObject );
- SMESH::long_array_var anElementsId = theObject->GetIDs();
+ SMESH::smIdType_array_var anElementsId = theObject->GetIDs();
CORBA::Boolean isDone = Reorient(anElementsId);
// Update Python script
const SMESH::DirStruct& theDirection,
CORBA::Long theFace,
const SMESH::PointStruct& thePoint)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData(/*deleteSearchers=*/false);
if ( dirVec.Magnitude() < std::numeric_limits< double >::min() )
THROW_SALOME_CORBA_EXCEPTION("Zero size vector", SALOME::BAD_PARAM);
- int nbReori = getEditor().Reorient2D( elements, dirVec, face );
+ TIDSortedElemSet refFaces = { face };
+ int nbReori = getEditor().Reorient2D( elements, dirVec, refFaces, /*allowNonManifold=*/true );
if ( nbReori ) {
declareMeshModified( /*isReComputeSafe=*/false );
return 0;
}
+//=======================================================================
+//function : Reorient2DByNeighbours
+//purpose : Reorient faces contained in a list of objectFaces
+// equally to faces contained in a list of referenceFaces.
+//=======================================================================
+
+CORBA::Long
+SMESH_MeshEditor_i::Reorient2DByNeighbours(const SMESH::ListOfIDSources& theObjectFaces,
+ const SMESH::ListOfIDSources& theReferenceFaces)
+{
+ SMESH_TRY;
+ initData(/*deleteSearchers=*/false);
+
+ if ( theObjectFaces.length() == 0 )
+ return 0;
+
+ // get object faces
+ TIDSortedElemSet objFaces;
+ bool invalidObjFaces = false;
+ for ( CORBA::ULong i = 0; i < theObjectFaces.length(); ++i )
+ {
+ IDSource_Error err;
+ if ( !idSourceToSet( theObjectFaces[i], getMeshDS(), objFaces, SMDSAbs_Face,
+ /*emptyIfIsMesh=*/1, &err ) &&
+ err == IDSource_INVALID )
+ invalidObjFaces = true;
+ }
+ if ( objFaces.empty() && invalidObjFaces )
+ THROW_SALOME_CORBA_EXCEPTION("No valid faces in given groups", SALOME::BAD_PARAM);
+
+ // get reference faces
+ TIDSortedElemSet refFaces;
+ for ( CORBA::ULong i = 0; i < theReferenceFaces.length(); ++i )
+ {
+ idSourceToSet( theReferenceFaces[i], getMeshDS(), refFaces, SMDSAbs_Face, /*emptyIfIsMesh=*/1 );
+ }
+ if ( refFaces.empty() && theReferenceFaces.length() > 0 )
+ THROW_SALOME_CORBA_EXCEPTION("Reference faces are invalid", SALOME::BAD_PARAM);
+
+
+ gp_Vec zeroVec( 0,0,0 );
+
+ // reorient
+ int nbReori = getEditor().Reorient2D( objFaces, zeroVec, refFaces, /*allowNonManifold=*/false );
+
+ if ( nbReori )
+ declareMeshModified( /*isReComputeSafe=*/false );
+
+ TPythonDump() << this << ".Reorient2DByNeighbours("
+ << theObjectFaces << ", "
+ << theReferenceFaces << ")";
+
+ return nbReori;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
//=======================================================================
//function : Reorient2DBy3D
//purpose : Reorient faces basing on orientation of adjacent volumes.
CORBA::Long SMESH_MeshEditor_i::Reorient2DBy3D(const SMESH::ListOfIDSources& faceGroups,
SMESH::SMESH_IDSource_ptr volumeGroup,
CORBA::Boolean outsideNormal)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
*/
//=============================================================================
-CORBA::Boolean SMESH_MeshEditor_i::TriToQuad (const SMESH::long_array & IDsOfElements,
+CORBA::Boolean SMESH_MeshEditor_i::TriToQuad (const SMESH::smIdType_array & IDsOfElements,
SMESH::NumericalFunctor_ptr Criterion,
CORBA::Double MaxAngle)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
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();
TPythonDump aTPythonDump; // suppress dump in TriToQuad()
prepareIdSource( theObject );
- SMESH::long_array_var anElementsId = theObject->GetIDs();
+ SMESH::smIdType_array_var anElementsId = theObject->GetIDs();
CORBA::Boolean isDone = TriToQuad(anElementsId, Criterion, MaxAngle);
if ( !myIsPreviewMode ) {
*/
//=============================================================================
-CORBA::Boolean SMESH_MeshEditor_i::QuadToTri (const SMESH::long_array & IDsOfElements,
+CORBA::Boolean SMESH_MeshEditor_i::QuadToTri (const SMESH::smIdType_array & IDsOfElements,
SMESH::NumericalFunctor_ptr Criterion)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
CORBA::Boolean SMESH_MeshEditor_i::QuadToTriObject (SMESH::SMESH_IDSource_ptr theObject,
SMESH::NumericalFunctor_ptr Criterion)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
TPythonDump aTPythonDump; // suppress dump in QuadToTri()
prepareIdSource( theObject );
- SMESH::long_array_var anElementsId = theObject->GetIDs();
+ SMESH::smIdType_array_var anElementsId = theObject->GetIDs();
CORBA::Boolean isDone = QuadToTri(anElementsId, Criterion);
SMESH::NumericalFunctor_i* aNumericalFunctor =
//================================================================================
void SMESH_MeshEditor_i::QuadTo4Tri (SMESH::SMESH_IDSource_ptr theObject)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
getEditor().QuadTo4Tri( faces );
TPythonDump() << this << ".QuadTo4Tri( " << theObject << " )";
+ declareMeshModified( /*isReComputeSafe=*/false );
+
SMESH_CATCH( SMESH::throwCorbaException );
}
*/
//=============================================================================
-CORBA::Boolean SMESH_MeshEditor_i::SplitQuad (const SMESH::long_array & IDsOfElements,
+CORBA::Boolean SMESH_MeshEditor_i::SplitQuad (const SMESH::smIdType_array & IDsOfElements,
CORBA::Boolean Diag13)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
CORBA::Boolean SMESH_MeshEditor_i::SplitQuadObject (SMESH::SMESH_IDSource_ptr theObject,
CORBA::Boolean Diag13)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
TPythonDump aTPythonDump; // suppress dump in SplitQuad()
prepareIdSource( theObject );
- SMESH::long_array_var anElementsId = theObject->GetIDs();
+ SMESH::smIdType_array_var anElementsId = theObject->GetIDs();
CORBA::Boolean isDone = SplitQuad(anElementsId, Diag13);
// Update Python script
//=============================================================================
/*!
* Find better splitting of the given quadrangle.
- * \param IDOfQuad ID of the quadrangle to be splitted.
+ * \param IDOfQuad ID of the quadrangle to be split.
* \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.
*/
//=============================================================================
-CORBA::Long SMESH_MeshEditor_i::BestSplit (CORBA::Long IDOfQuad,
- SMESH::NumericalFunctor_ptr Criterion)
- throw (SALOME::SALOME_Exception)
+CORBA::Short SMESH_MeshEditor_i::BestSplit (SMESH::smIdType IDOfQuad,
+ SMESH::NumericalFunctor_ptr Criterion)
{
SMESH_TRY;
initData();
void SMESH_MeshEditor_i::SplitVolumesIntoTetra (SMESH::SMESH_IDSource_ptr elems,
CORBA::Short methodFlags)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
::SMESH_MeshEditor::TFacetOfElem elemSet;
const int noneFacet = -1;
- SMDS_ElemIteratorPtr volIt = myMesh_i->GetElements( elems, SMESH::VOLUME );
- while( volIt->more() )
- elemSet.insert( elemSet.end(), make_pair( volIt->next(), noneFacet ));
+ prepareIdSource( elems );
+ if ( SMDS_ElemIteratorPtr volIt = myMesh_i->GetElements( elems, SMESH::VOLUME ))
+ while ( volIt->more() )
+ elemSet.insert( elemSet.end(), make_pair( volIt->next(), noneFacet ));
getEditor().SplitVolumes( elemSet, int( methodFlags ));
declareMeshModified( /*isReComputeSafe=*/true ); // it does not influence Compute()
const SMESH::DirStruct& facetToSplitNormal,
CORBA::Short methodFlags,
CORBA::Boolean allDomains)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
facetToSplitNormal.PS.y,
facetToSplitNormal.PS.z ));
TIDSortedElemSet elemSet;
- SMESH::long_array_var anElementsId = elems->GetIDs();
+ prepareIdSource( elems );
+ SMESH::smIdType_array_var anElementsId = elems->GetIDs();
SMDS_MeshElement::GeomFilter filter( SMDSGeom_HEXA );
arrayToSet( anElementsId, getMeshDS(), elemSet, SMDSAbs_Volume, &filter );
//================================================================================
void SMESH_MeshEditor_i::SplitBiQuadraticIntoLinear(const SMESH::ListOfIDSources& theElems)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
//=======================================================================
CORBA::Boolean
-SMESH_MeshEditor_i::Smooth(const SMESH::long_array & IDsOfElements,
- const SMESH::long_array & IDsOfFixedNodes,
- CORBA::Long MaxNbOfIterations,
+SMESH_MeshEditor_i::Smooth(const SMESH::smIdType_array & IDsOfElements,
+ const SMESH::smIdType_array & IDsOfFixedNodes,
+ CORBA::Short MaxNbOfIterations,
CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method)
- throw (SALOME::SALOME_Exception)
{
return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
MaxAspectRatio, Method, false );
//=======================================================================
CORBA::Boolean
-SMESH_MeshEditor_i::SmoothParametric(const SMESH::long_array & IDsOfElements,
- const SMESH::long_array & IDsOfFixedNodes,
- CORBA::Long MaxNbOfIterations,
+SMESH_MeshEditor_i::SmoothParametric(const SMESH::smIdType_array & IDsOfElements,
+ const SMESH::smIdType_array & IDsOfFixedNodes,
+ CORBA::Short MaxNbOfIterations,
CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method)
- throw (SALOME::SALOME_Exception)
{
return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
MaxAspectRatio, Method, true );
CORBA::Boolean
SMESH_MeshEditor_i::SmoothObject(SMESH::SMESH_IDSource_ptr theObject,
- const SMESH::long_array & IDsOfFixedNodes,
- CORBA::Long MaxNbOfIterations,
+ const SMESH::smIdType_array & IDsOfFixedNodes,
+ CORBA::Short MaxNbOfIterations,
CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method)
- throw (SALOME::SALOME_Exception)
{
return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
MaxAspectRatio, Method, false);
CORBA::Boolean
SMESH_MeshEditor_i::SmoothParametricObject(SMESH::SMESH_IDSource_ptr theObject,
- const SMESH::long_array & IDsOfFixedNodes,
- CORBA::Long MaxNbOfIterations,
+ const SMESH::smIdType_array & IDsOfFixedNodes,
+ CORBA::Short 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,
+SMESH_MeshEditor_i::smooth(const SMESH::smIdType_array & IDsOfElements,
+ const SMESH::smIdType_array & IDsOfFixedNodes,
+ CORBA::Short MaxNbOfIterations,
CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method,
bool IsParametric)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
set<const SMDS_MeshNode*> fixedNodes;
for ( CORBA::ULong i = 0; i < IDsOfFixedNodes.length(); i++) {
- CORBA::Long index = IDsOfFixedNodes[i];
+ SMESH::smIdType index = IDsOfFixedNodes[i];
const SMDS_MeshNode * node = aMesh->FindNode(index);
if ( node )
fixedNodes.insert( node );
CORBA::Boolean
SMESH_MeshEditor_i::smoothObject(SMESH::SMESH_IDSource_ptr theObject,
- const SMESH::long_array & IDsOfFixedNodes,
- CORBA::Long MaxNbOfIterations,
+ const SMESH::smIdType_array & IDsOfFixedNodes,
+ CORBA::Short 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();
+ SMESH::smIdType_array_var anElementsId = theObject->GetIDs();
CORBA::Boolean isDone = smooth (anElementsId, IDsOfFixedNodes, MaxNbOfIterations,
MaxAspectRatio, Method, IsParametric);
//=============================================================================
void SMESH_MeshEditor_i::RenumberNodes()
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
// Update Python script
//=============================================================================
void SMESH_MeshEditor_i::RenumberElements()
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
// Update Python script
//=======================================================================
SMESH::ListOfGroups* SMESH_MeshEditor_i::getGroups(const std::list<int>* groupIDs)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
if ( !groupIDs )
CORBA::Long theNbOfSteps,
CORBA::Double theTolerance,
const bool theMakeGroups)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
TIDSortedElemSet elemsNodes[2];
for ( int i = 0, nb = theNodes.length(); i < nb; ++i ) {
- SMDS_ElemIteratorPtr nIt = myMesh_i->GetElements( theNodes[i], SMESH::NODE );
- while ( nIt->more() ) elemsNodes[1].insert( nIt->next() );
+ if ( SMDS_ElemIteratorPtr nIt = myMesh_i->GetElements( theNodes[i], SMESH::NODE ))
+ while ( nIt->more() ) elemsNodes[1].insert( nIt->next() );
}
for ( int i = 0, nb = theEdges.length(); i < nb; ++i )
idSourceToSet( theEdges[i], getMeshDS(), elemsNodes[0], SMDSAbs_Edge );
bool myIsExtrusionByNormal;
static int makeFlags( CORBA::Boolean MakeGroups,
- CORBA::Boolean LinearVariation = false,
+ CORBA::Boolean ScaleVariation = false,
+ CORBA::Boolean AngleVariation = false,
CORBA::Boolean ByAverageNormal = false,
CORBA::Boolean UseInputElemsOnly = false,
CORBA::Long Flags = 0,
if ( MakeGroups ) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_GROUPS;
if ( ByAverageNormal ) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_BY_AVG_NORMAL;
if ( UseInputElemsOnly) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_USE_INPUT_ELEMS_ONLY;
- if ( LinearVariation ) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_SCALE_LINEAR_VARIATION;
+ if ( ScaleVariation ) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_SCALE_LINEAR_VARIATION;
+ if ( AngleVariation ) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_ANGLE_LINEAR_VARIATION;
if ( MakeBoundary ) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_BOUNDARY;
return Flags;
}
ExtrusionParams(const SMESH::DirStruct & theDir,
CORBA::Long theNbOfSteps,
const SMESH::double_array & theScaleFactors,
- CORBA::Boolean theLinearVariation,
+ CORBA::Boolean theScaleVariation,
+ const SMESH::double_array & theAngles,
+ CORBA::Boolean theAngleVariation,
const SMESH::double_array & theBasePoint,
CORBA::Boolean theMakeGroups):
::SMESH_MeshEditor::ExtrusParam ( gp_Vec( theDir.PS.x,
theDir.PS.z ),
theNbOfSteps,
toList( theScaleFactors ),
+ toList( theAngles ),
TBasePoint( theBasePoint ),
- makeFlags( theMakeGroups, theLinearVariation )),
+ makeFlags( theMakeGroups, theScaleVariation, theAngleVariation )),
myIsExtrusionByNormal( false )
{
}
theDir.PS.z ),
theNbOfSteps,
std::list<double>(),
+ std::list<double>(),
0,
- makeFlags( theMakeGroups, false, false, false,
+ makeFlags( theMakeGroups, false, false, false, false,
theExtrFlags, false ),
theSewTolerance ),
myIsExtrusionByNormal( false )
CORBA::Boolean theMakeGroups ):
::SMESH_MeshEditor::ExtrusParam ( theStepSize,
theNbOfSteps,
- makeFlags( theMakeGroups, false,
+ makeFlags( theMakeGroups, false, false,
theByAverageNormal, theUseInputElemsOnly ),
theDim),
myIsExtrusionByNormal( true )
Flags() &= ~(::SMESH_MeshEditor::EXTRUSION_FLAG_GROUPS);
}
- private:
-
static std::list<double> toList( const SMESH::double_array & theScaleFactors )
{
std::list<double> scales;
return scales;
}
+ private:
+
// structure used to convert SMESH::double_array to gp_XYZ*
struct TBasePoint
{
* \param [in] nbOfSteps - number of elements to generate from one element
* \param [in] toMakeGroups - if true, new elements will be included into new groups
* corresponding to groups the input elements included in.
- * \return ListOfGroups - new groups craeted if \a toMakeGroups is true
+ * \return ListOfGroups - new groups created if \a toMakeGroups is true
*/
//=======================================================================
const SMESH::ListOfIDSources & theFaces,
const SMESH::DirStruct & theStepVector,
CORBA::Long theNbOfSteps,
+ CORBA::Boolean theToMakeGroups,
const SMESH::double_array & theScaleFactors,
- CORBA::Boolean theLinearVariation,
+ CORBA::Boolean theScalesVariation,
const SMESH::double_array & theBasePoint,
- CORBA::Boolean theToMakeGroups)
- throw (SALOME::SALOME_Exception)
+ const SMESH::double_array & theAngles,
+ CORBA::Boolean theAnglesVariation)
{
SMESH_TRY;
initData();
- ExtrusionParams params( theStepVector, theNbOfSteps, theScaleFactors,
- theLinearVariation, theBasePoint, theToMakeGroups );
+ ExtrusionParams params( theStepVector, theNbOfSteps, theScaleFactors, theScalesVariation,
+ theAngles, theAnglesVariation, theBasePoint, theToMakeGroups );
TIDSortedElemSet elemsNodes[2];
for ( int i = 0, nb = theNodes.length(); i < nb; ++i ) {
- SMDS_ElemIteratorPtr nIt = myMesh_i->GetElements( theNodes[i], SMESH::NODE );
- while ( nIt->more() ) elemsNodes[1].insert( nIt->next() );
+ if ( SMDS_ElemIteratorPtr nIt = myMesh_i->GetElements( theNodes[i], SMESH::NODE ))
+ while ( nIt->more() ) elemsNodes[1].insert( nIt->next() );
}
for ( int i = 0, nb = theEdges.length(); i < nb; ++i )
idSourceToSet( theEdges[i], getMeshDS(), elemsNodes[0], SMDSAbs_Edge );
{
dumpGroupsList( aPythonDump, aGroups );
aPythonDump << this<< ".ExtrusionSweepObjects( "
- << theNodes << ", "
- << theEdges << ", "
- << theFaces << ", "
- << theStepVector << ", "
- << TVar( theNbOfSteps ) << ", "
- << theToMakeGroups << " )";
+ << theNodes << ", "
+ << theEdges << ", "
+ << theFaces << ", "
+ << theStepVector << ", "
+ << TVar( theNbOfSteps ) << ", "
+ << theToMakeGroups << ", "
+ << TVar( theScaleFactors ) << ", "
+ << theScalesVariation << ", "
+ << TVar( theBasePoint ) << ", "
+ << TVar( theAngles ) << ", "
+ << theAnglesVariation << " )";
}
else
{
CORBA::Boolean useInputElemsOnly,
CORBA::Boolean makeGroups,
CORBA::Short dim)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
//=======================================================================
SMESH::ListOfGroups*
-SMESH_MeshEditor_i::AdvancedExtrusion(const SMESH::long_array & theIDsOfElements,
- const SMESH::DirStruct & theStepVector,
- CORBA::Long theNbOfSteps,
- CORBA::Long theExtrFlags,
- CORBA::Double theSewTolerance,
- CORBA::Boolean theMakeGroups)
- throw (SALOME::SALOME_Exception)
+SMESH_MeshEditor_i::AdvancedExtrusion(const SMESH::smIdType_array & theIDsOfElements,
+ const SMESH::DirStruct & theStepVector,
+ CORBA::Long theNbOfSteps,
+ CORBA::Long theExtrFlags,
+ CORBA::Double theSewTolerance,
+ CORBA::Boolean theMakeGroups)
{
SMESH_TRY;
initData();
SMESH_MeshEditor_i::ExtrusionAlongPathObjects(const SMESH::ListOfIDSources & theNodes,
const SMESH::ListOfIDSources & theEdges,
const SMESH::ListOfIDSources & theFaces,
- SMESH::SMESH_IDSource_ptr thePathMesh,
+ SMESH::SMESH_IDSource_ptr thePathObject,
GEOM::GEOM_Object_ptr thePathShape,
- CORBA::Long theNodeStart,
+ SMESH::smIdType theNodeStart,
CORBA::Boolean theHasAngles,
const SMESH::double_array & theAngles,
- CORBA::Boolean theLinearVariation,
+ CORBA::Boolean theAnglesVariation,
CORBA::Boolean theHasRefPoint,
const SMESH::PointStruct & theRefPoint,
bool theMakeGroups,
+ const SMESH::double_array & theScaleFactors,
+ CORBA::Boolean theScalesVariation,
SMESH::SMESH_MeshEditor::Extrusion_Error& theError)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
SMESH::ListOfGroups_var aGroups = new SMESH::ListOfGroups;
theError = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
- if ( thePathMesh->_is_nil() )
+ if ( thePathObject->_is_nil() )
return aGroups._retn();
- // get a sub-mesh
- SMESH_subMesh* aSubMesh = 0;
- SMESH_Mesh_i* aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( thePathMesh );
- if ( thePathShape->_is_nil() )
+
+ SMDS_ElemIteratorPtr pathEdgesIterator;
+
+ SMESH_Mesh_i* aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( thePathObject );
+ if ( !CORBA::is_nil( thePathShape ) && aMeshImp )
{
- // thePathMesh should be either a sub-mesh or a mesh with 1D elements only
- if ( SMESH_subMesh_i* sm = SMESH::DownCast<SMESH_subMesh_i*>( thePathMesh ))
+ // get a sub-mesh of thePathShape
+ TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( thePathShape );
+ SMESH_subMesh* aSubMesh = aMeshImp->GetImpl().GetSubMesh( aShape );
+ if ( !aSubMesh )
+ return aGroups._retn();
+
+ if ( !aSubMesh->GetSubMeshDS() )
{
- SMESH::SMESH_Mesh_var mesh = thePathMesh->GetMesh();
- aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
- if ( !aMeshImp ) return aGroups._retn();
- aSubMesh = aMeshImp->GetImpl().GetSubMeshContaining( sm->GetId() );
- if ( !aSubMesh ) return aGroups._retn();
+ SMESHDS_Mesh * meshDS = aMeshImp->GetImpl().GetMeshDS();
+ meshDS->AddCompoundSubmesh( aShape, TopAbs_EDGE );
+ if ( !aSubMesh->GetSubMeshDS() )
+ return aGroups._retn();
}
- else if ( !aMeshImp ||
- aMeshImp->NbEdges() != aMeshImp->NbElements() )
- {
+ theError = SMESH::SMESH_MeshEditor::EXTR_PATH_NOT_EDGE;
+ pathEdgesIterator = aSubMesh->GetSubMeshDS()->GetElements();
+ if ( !pathEdgesIterator->more() ||
+ pathEdgesIterator->next()->GetType() != SMDSAbs_Edge )
return aGroups._retn();
- }
+
+ pathEdgesIterator = aSubMesh->GetSubMeshDS()->GetElements();
}
else
{
- if ( !aMeshImp ) return aGroups._retn();
- TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( thePathShape );
- aSubMesh = aMeshImp->GetImpl().GetSubMesh( aShape );
- if ( !aSubMesh /*|| !aSubMesh->GetSubMeshDS()*/ )
+ theError = SMESH::SMESH_MeshEditor::EXTR_PATH_NOT_EDGE;
+ prepareIdSource( thePathObject );
+ pathEdgesIterator = SMESH_Mesh_i::GetElements( thePathObject, SMESH::EDGE );
+ if ( !pathEdgesIterator || !pathEdgesIterator->more() )
return aGroups._retn();
}
- SMDS_MeshNode* nodeStart =
- (SMDS_MeshNode*)aMeshImp->GetImpl().GetMeshDS()->FindNode(theNodeStart);
- if ( !nodeStart ) {
- theError = SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE;
- return aGroups._retn();
+ if ( !aMeshImp )
+ {
+ SMESH::SMESH_Mesh_var pathMesh = thePathObject->GetMesh();
+ aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( pathMesh );
}
+
+ theError = SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE;
+ const SMDS_MeshNode* nodeStart = aMeshImp->GetImpl().GetMeshDS()->FindNode( theNodeStart );
+ if ( !nodeStart )
+ return aGroups._retn();
+
+
TIDSortedElemSet elemsNodes[2];
for ( int i = 0, nb = theNodes.length(); i < nb; ++i ) {
- SMDS_ElemIteratorPtr nIt = myMesh_i->GetElements( theNodes[i], SMESH::NODE );
- while ( nIt->more() ) elemsNodes[1].insert( nIt->next() );
+ if ( SMDS_ElemIteratorPtr nIt = myMesh_i->GetElements( theNodes[i], SMESH::NODE ))
+ while ( nIt->more() ) elemsNodes[1].insert( nIt->next() );
}
for ( int i = 0, nb = theEdges.length(); i < nb; ++i )
idSourceToSet( theEdges[i], getMeshDS(), elemsNodes[0], SMDSAbs_Edge );
for ( int i = 0, nb = theFaces.length(); i < nb; ++i )
idSourceToSet( theFaces[i], getMeshDS(), elemsNodes[0], SMDSAbs_Face );
- list<double> angles;
- for ( CORBA::ULong i = 0; i < theAngles.length(); i++ ) {
- angles.push_back( theAngles[i] );
- }
+ list<double> angles = ExtrusionParams::toList( theAngles );
+ list<double> scales = ExtrusionParams::toList( theScaleFactors );
gp_Pnt refPnt( theRefPoint.x, theRefPoint.y, theRefPoint.z );
+ const gp_Pnt *refPntPtr = theHasRefPoint ? &refPnt : 0;
int nbOldGroups = myMesh->NbGroup();
theMakeGroups = false;
}
- ::SMESH_MeshEditor::Extrusion_Error error;
- if ( !aSubMesh )
- error = getEditor().ExtrusionAlongTrack( workElements, &(aMeshImp->GetImpl()), nodeStart,
- theHasAngles, angles, theLinearVariation,
- theHasRefPoint, refPnt, theMakeGroups );
- else
- error = getEditor().ExtrusionAlongTrack( workElements, aSubMesh, nodeStart,
- theHasAngles, angles, theLinearVariation,
- theHasRefPoint, refPnt, theMakeGroups );
+ ::SMESH_MeshEditor::Extrusion_Error error =
+ getEditor().ExtrusionAlongTrack( workElements,
+ &(aMeshImp->GetImpl()), pathEdgesIterator, nodeStart,
+ angles, theAnglesVariation,
+ scales, theScalesVariation,
+ refPntPtr, theMakeGroups );
declareMeshModified( /*isReComputeSafe=*/true );
theError = convExtrError( error );
<< theNodes << ", "
<< theEdges << ", "
<< theFaces << ", "
- << thePathMesh << ", "
+ << thePathObject << ", "
<< thePathShape << ", "
<< theNodeStart << ", "
<< theHasAngles << ", "
<< TVar( theAngles ) << ", "
- << theLinearVariation << ", "
+ << theAnglesVariation << ", "
<< theHasRefPoint << ", "
<< "SMESH.PointStruct( "
<< TVar( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
<< TVar( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
<< TVar( theHasRefPoint ? theRefPoint.z : 0 ) << " ), "
- << theMakeGroups << " )";
+ << theMakeGroups << ", "
+ << TVar( theScaleFactors ) << ", "
+ << theScalesVariation << " )";
}
else
{
SMESH_subMesh* aSubMesh = aMeshImp->GetImpl().GetSubMesh( aShape );
if ( !aSubMesh || !aSubMesh->GetSubMeshDS())
return aResult._retn();
- int nbSteps = aSubMesh->GetSubMeshDS()->NbElements();
+ smIdType nbSteps = aSubMesh->GetSubMeshDS()->NbElements();
if ( nbSteps == nbAngles )
{
aResult.inout() = theAngles;
CORBA::Boolean theCopy,
bool theMakeGroups,
::SMESH_Mesh* theTargetMesh)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
//purpose :
//=======================================================================
-void SMESH_MeshEditor_i::Mirror(const SMESH::long_array & theIDsOfElements,
+void SMESH_MeshEditor_i::Mirror(const SMESH::smIdType_array & theIDsOfElements,
const SMESH::AxisStruct & theAxis,
SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
CORBA::Boolean theCopy)
- throw (SALOME::SALOME_Exception)
{
if ( !myIsPreviewMode ) {
TPythonDump() << this << ".Mirror( "
const SMESH::AxisStruct & theAxis,
SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
CORBA::Boolean theCopy)
- throw (SALOME::SALOME_Exception)
{
if ( !myIsPreviewMode ) {
TPythonDump() << this << ".MirrorObject( "
//=======================================================================
SMESH::ListOfGroups*
-SMESH_MeshEditor_i::MirrorMakeGroups(const SMESH::long_array& theIDsOfElements,
+SMESH_MeshEditor_i::MirrorMakeGroups(const SMESH::smIdType_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_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::SMESH_Mesh_ptr
-SMESH_MeshEditor_i::MirrorMakeMesh(const SMESH::long_array& theIDsOfElements,
+SMESH_MeshEditor_i::MirrorMakeMesh(const SMESH::smIdType_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;
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;
CORBA::Boolean theCopy,
bool theMakeGroups,
::SMESH_Mesh* theTargetMesh)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
//purpose :
//=======================================================================
-void SMESH_MeshEditor_i::Translate(const SMESH::long_array & theIDsOfElements,
- const SMESH::DirStruct & theVector,
- CORBA::Boolean theCopy)
- throw (SALOME::SALOME_Exception)
+void SMESH_MeshEditor_i::Translate(const SMESH::smIdType_array & theIDsOfElements,
+ const SMESH::DirStruct & theVector,
+ CORBA::Boolean theCopy)
{
if (!myIsPreviewMode) {
TPythonDump() << this << ".Translate( "
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( "
//=======================================================================
SMESH::ListOfGroups*
-SMESH_MeshEditor_i::TranslateMakeGroups(const SMESH::long_array& theIDsOfElements,
- const SMESH::DirStruct& theVector)
- throw (SALOME::SALOME_Exception)
+SMESH_MeshEditor_i::TranslateMakeGroups(const SMESH::smIdType_array& theIDsOfElements,
+ const SMESH::DirStruct& theVector)
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
<< theIDsOfElements << ", "
<< theVector << " )";
}
- return aGroups;
+ return aGroups ? aGroups : new SMESH::ListOfGroups();
}
//=======================================================================
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()
<< theObject << ", "
<< theVector << " )";
}
- return aGroups;
+ return aGroups ? aGroups : new SMESH::ListOfGroups();
}
//=======================================================================
//=======================================================================
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_MeshEditor_i::TranslateMakeMesh(const SMESH::smIdType_array& theIDsOfElements,
+ const SMESH::DirStruct& theVector,
+ CORBA::Boolean theCopyGroups,
+ const char* theMeshName)
{
SMESH_Mesh_i* mesh_i;
SMESH::SMESH_Mesh_var mesh;
const SMESH::DirStruct& theVector,
CORBA::Boolean theCopyGroups,
const char* theMeshName)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
SMESH_Mesh_i* mesh_i;
CORBA::Boolean theCopy,
bool theMakeGroups,
::SMESH_Mesh* theTargetMesh)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
//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)
+void SMESH_MeshEditor_i::Rotate(const SMESH::smIdType_array & theIDsOfElements,
+ const SMESH::AxisStruct & theAxis,
+ CORBA::Double theAngle,
+ CORBA::Boolean theCopy)
{
if (!myIsPreviewMode) {
TPythonDump() << this << ".Rotate( "
const SMESH::AxisStruct & theAxis,
CORBA::Double theAngle,
CORBA::Boolean theCopy)
- throw (SALOME::SALOME_Exception)
{
if ( !myIsPreviewMode ) {
TPythonDump() << this << ".RotateObject( "
//=======================================================================
SMESH::ListOfGroups*
-SMESH_MeshEditor_i::RotateMakeGroups(const SMESH::long_array& theIDsOfElements,
- const SMESH::AxisStruct& theAxis,
- CORBA::Double theAngle)
- throw (SALOME::SALOME_Exception)
+SMESH_MeshEditor_i::RotateMakeGroups(const SMESH::smIdType_array& theIDsOfElements,
+ const SMESH::AxisStruct& theAxis,
+ CORBA::Double theAngle)
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
<< theAxis << ", "
<< TVar( theAngle ) << " )";
}
- return aGroups;
+ return aGroups ? aGroups : new 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()
<< theAxis << ", "
<< TVar( theAngle ) << " )";
}
- return aGroups;
+ return aGroups ? aGroups : new SMESH::ListOfGroups();
}
//=======================================================================
//=======================================================================
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_MeshEditor_i::RotateMakeMesh(const SMESH::smIdType_array& theIDsOfElements,
+ const SMESH::AxisStruct& theAxis,
+ CORBA::Double theAngleInRadians,
+ CORBA::Boolean theCopyGroups,
+ const char* theMeshName)
{
SMESH_TRY;
SMESH::SMESH_Mesh_var mesh;
CORBA::Double theAngleInRadians,
CORBA::Boolean theCopyGroups,
const char* theMeshName)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
SMESH::SMESH_Mesh_var mesh;
CORBA::Boolean theCopy,
bool theMakeGroups,
::SMESH_Mesh* theTargetMesh)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
const SMESH::PointStruct& thePoint,
const SMESH::double_array& theScaleFact,
CORBA::Boolean theCopy)
- throw (SALOME::SALOME_Exception)
{
if ( !myIsPreviewMode ) {
TPythonDump() << this << ".Scale( "
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()
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;
return mesh._retn();
}
+//================================================================================
+/*!
+ * \brief Make an offset mesh from a source 2D mesh
+ * \param [inout] theObject - source mesh. New elements are added to this mesh
+ * if \a theMeshName is empty.
+ * \param [in] theValue - offset value
+ * \param [in] theCopyGroups - to generate groups
+ * \param [in] theMeshName - optional name of a new mesh
+ * \param [out] theGroups - new groups
+ * \return SMESH::SMESH_Mesh_ptr - the modified mesh
+ */
+//================================================================================
+
+SMESH::SMESH_Mesh_ptr SMESH_MeshEditor_i::Offset( SMESH::SMESH_IDSource_ptr theObject,
+ CORBA::Double theValue,
+ CORBA::Boolean theCopyGroups,
+ CORBA::Boolean theCopyElements,
+ const char* theMeshName,
+ SMESH::ListOfGroups_out theGroups)
+{
+ SMESH_TRY;
+ initData();
+
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
+
+ SMESH::SMESH_Mesh_var mesh_var;
+ ::SMESH_MeshEditor::PGroupIDs groupIds;
+
+ TPythonDump pyDump;
+
+ TIDSortedElemSet elements, copyElements;
+ if ( idSourceToSet( theObject, aMeshDS, elements, SMDSAbs_Face,
+ /*emptyIfIsMesh=*/ !myIsPreviewMode ))
+ {
+ // mesh to modify
+ SMESH_Mesh* tgtMesh = 0;
+ if ( myIsPreviewMode )
+ {
+ TPreviewMesh * tmpMesh = getPreviewMesh();
+ tgtMesh = tmpMesh;
+ tmpMesh->Copy( elements, copyElements );
+ elements.swap( copyElements );
+ theCopyGroups = false;
+ theCopyElements = false;
+ }
+ else
+ {
+ mesh_var =
+ *theMeshName ? makeMesh( theMeshName ) : SMESH::SMESH_Mesh::_duplicate( myMesh_i->_this() );
+ SMESH_Mesh_i* mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh_var );
+ tgtMesh = & mesh_i->GetImpl();
+ }
+ groupIds = getEditor().Offset( elements, theValue, tgtMesh,
+ theCopyGroups, theCopyElements, !myIsPreviewMode );
+
+ tgtMesh->GetMeshDS()->Modified();
+ }
+
+ if ( myIsPreviewMode )
+ {
+ //getPreviewMesh()->Remove( SMESHUtils::elemSetIterator( copyElements ));
+ }
+ else
+ {
+ if ( *theMeshName && mesh_var->NbFaces() == 0 )
+ {
+ // new mesh empty, remove it
+ SALOMEDS::Study_var study = SMESH_Gen_i::GetSMESHGen()->getStudyServant();
+ SALOMEDS::StudyBuilder_var builder = study->NewBuilder();
+ SALOMEDS::SObject_wrap meshSO = SMESH_Gen_i::GetSMESHGen()->ObjectToSObject( mesh_var );
+ builder->RemoveObjectWithChildren( meshSO );
+ THROW_SALOME_CORBA_EXCEPTION("Offset failed", SALOME::INTERNAL_ERROR);
+ }
+ if ( !groupIds ) // nothing changed in the current mesh
+ THROW_SALOME_CORBA_EXCEPTION("Offset failed", SALOME::INTERNAL_ERROR);
+
+ theGroups = theCopyGroups ? getGroups( groupIds.get() ) : new SMESH::ListOfGroups;
+
+ // result of Offset() is a tuple (mesh, groups)
+ if ( mesh_var->_is_nil() ) pyDump << myMesh_i->_this() << ", ";
+ else pyDump << mesh_var << ", ";
+ pyDump << theGroups << " = " << this << ".Offset( "
+ << theObject << ", "
+ << theValue << ", "
+ << theCopyGroups << ", "
+ << theCopyElements << ", "
+ << "'" << theMeshName<< "')";
+ }
+
+ return mesh_var._retn();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return SMESH::SMESH_Mesh::_nil();
+}
//=======================================================================
//function : findCoincidentNodes
FindCoincidentNodes (CORBA::Double Tolerance,
SMESH::array_of_long_array_out GroupsOfNodes,
CORBA::Boolean SeparateCornersAndMedium)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
CORBA::Double Tolerance,
SMESH::array_of_long_array_out GroupsOfNodes,
CORBA::Boolean SeparateCornersAndMedium)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
TIDSortedNodeSet nodes;
+ prepareIdSource( theObject );
idSourceToNodeSet( theObject, getMeshDS(), nodes );
findCoincidentNodes( nodes, Tolerance, GroupsOfNodes, SeparateCornersAndMedium );
//================================================================================
/*!
- * \brief Finds nodes coinsident with Tolerance within Object excluding nodes within
+ * \brief Finds nodes coincident with Tolerance within Objects excluding nodes within
* ExceptSubMeshOrGroups
*/
//================================================================================
void SMESH_MeshEditor_i::
-FindCoincidentNodesOnPartBut(SMESH::SMESH_IDSource_ptr theObject,
+FindCoincidentNodesOnPartBut(const SMESH::ListOfIDSources& theObjects,
CORBA::Double theTolerance,
SMESH::array_of_long_array_out theGroupsOfNodes,
const SMESH::ListOfIDSources& theExceptSubMeshOrGroups,
CORBA::Boolean theSeparateCornersAndMedium)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
TIDSortedNodeSet nodes;
- idSourceToNodeSet( theObject, getMeshDS(), nodes );
-
+ for ( CORBA::ULong i = 0; i < theObjects.length(); ++i )
+ {
+ prepareIdSource( theObjects[i] );
+ idSourceToNodeSet( theObjects[i], getMeshDS(), nodes );
+ }
for ( CORBA::ULong i = 0; i < theExceptSubMeshOrGroups.length(); ++i )
{
- SMDS_ElemIteratorPtr nodeIt = myMesh_i->GetElements( theExceptSubMeshOrGroups[i],
- SMESH::NODE );
- while ( nodeIt->more() )
- nodes.erase( cast2Node( nodeIt->next() ));
+ if ( SMDS_ElemIteratorPtr nodeIt = myMesh_i->GetElements( theExceptSubMeshOrGroups[i],
+ SMESH::NODE ))
+ while ( nodeIt->more() )
+ nodes.erase( cast2Node( nodeIt->next() ));
}
findCoincidentNodes( nodes, theTolerance, theGroupsOfNodes, theSeparateCornersAndMedium );
TPythonDump() << "coincident_nodes_on_part = " << this << ".FindCoincidentNodesOnPartBut( "
- << theObject<<", "
+ << theObjects <<", "
<< theTolerance << ", "
<< theExceptSubMeshOrGroups << ", "
<< theSeparateCornersAndMedium << " )";
void SMESH_MeshEditor_i::MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes,
const SMESH::ListOfIDSources& NodesToKeep,
CORBA::Boolean AvoidMakingHoles)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
for ( CORBA::ULong i = 0; i < NodesToKeep.length(); ++i )
{
prepareIdSource( NodesToKeep[i] );
- SMDS_ElemIteratorPtr nodeIt = myMesh_i->GetElements( NodesToKeep[i], SMESH::NODE );
- while ( nodeIt->more() )
- setOfNodesToKeep.insert( setOfNodesToKeep.end(), cast2Node( nodeIt->next() ));
+ if ( SMDS_ElemIteratorPtr nodeIt = myMesh_i->GetElements( NodesToKeep[i], SMESH::NODE ))
+ while ( nodeIt->more() )
+ setOfNodesToKeep.insert( setOfNodesToKeep.end(), cast2Node( nodeIt->next() ));
}
::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
//purpose :
//=======================================================================
-void SMESH_MeshEditor_i::FindEqualElements(SMESH::SMESH_IDSource_ptr theObject,
- SMESH::array_of_long_array_out GroupsOfElementsID)
- throw (SALOME::SALOME_Exception)
+void SMESH_MeshEditor_i::FindEqualElements(const SMESH::ListOfIDSources& theObjects,
+ const SMESH::ListOfIDSources& theExceptObjects,
+ SMESH::array_of_long_array_out theGroupsOfElementsID)
{
SMESH_TRY;
initData();
- SMESH::SMESH_GroupBase_var group = SMESH::SMESH_GroupBase::_narrow(theObject);
- if ( !(!group->_is_nil() && group->GetType() == SMESH::NODE) )
+ theGroupsOfElementsID = new SMESH::array_of_long_array;
+
+ TIDSortedElemSet elems;
+ bool hasOkObject = false;
+ bool emptyIfIsMesh= ( theObjects.length() == 1 && theExceptObjects.length() == 0 );
+
+ for ( CORBA::ULong i = 0; i < theObjects.length(); ++i )
{
- TIDSortedElemSet elems;
- idSourceToSet( theObject, getMeshDS(), elems, SMDSAbs_All, /*emptyIfIsMesh=*/true);
+ SMESH::SMESH_GroupBase_var group = SMESH::SMESH_GroupBase::_narrow( theObjects[i] );
+ if ( !( !group->_is_nil() && group->GetType() == SMESH::NODE ))
+ if ( idSourceToSet( theObjects[i], getMeshDS(), elems, SMDSAbs_All, emptyIfIsMesh ))
+ hasOkObject = true;
+ }
+
+ if ( hasOkObject )
+ {
+ for ( CORBA::ULong i = 0; i < theExceptObjects.length(); ++i )
+ {
+ if ( SMDS_ElemIteratorPtr elemIt = myMesh_i->GetElements( theExceptObjects[i], SMESH::ALL ))
+ while ( elemIt->more() )
+ elems.erase( elemIt->next() );
+ }
::SMESH_MeshEditor::TListOfListOfElementsID aListOfListOfElementsID;
getEditor().FindEqualElements( elems, aListOfListOfElementsID );
- GroupsOfElementsID = new SMESH::array_of_long_array;
- GroupsOfElementsID->length( aListOfListOfElementsID.size() );
+ theGroupsOfElementsID->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;
+ SMESH::long_array& aGroup = (*theGroupsOfElementsID)[ j ];
+ list<smIdType>& listOfIDs = *arraysIt;
aGroup.length( listOfIDs.size() );
- list<int>::iterator idIt = listOfIDs.begin();
- for (int k = 0; idIt != listOfIDs.end(); ++idIt, ++k )
+ list<smIdType>::iterator idIt = listOfIDs.begin();
+ for (smIdType k = 0; idIt != listOfIDs.end(); ++idIt, ++k )
aGroup[ k ] = *idIt;
}
TPythonDump() << "equal_elements = " << this << ".FindEqualElements( "
- <<theObject<<" )";
+ << theObjects << ", "
+ << theExceptObjects << " )";
}
SMESH_CATCH( SMESH::throwCorbaException );
//purpose :
//=======================================================================
-void SMESH_MeshEditor_i::MergeElements(const SMESH::array_of_long_array& GroupsOfElementsID)
- throw (SALOME::SALOME_Exception)
+void SMESH_MeshEditor_i::MergeElements(const SMESH::array_of_long_array& theGroupsOfElementsID,
+ const SMESH::ListOfIDSources& theElementsToKeep)
{
SMESH_TRY;
initData();
TPythonDump aTPythonDump;
aTPythonDump << this << ".MergeElements( [";
+ NCollection_Map< int > idsToKeep;
+ for ( CORBA::ULong i = 0; i < theElementsToKeep.length(); i++ )
+ {
+ if ( CORBA::is_nil( theElementsToKeep[i] ))
+ continue;
+ SMESH::array_of_ElementType_var elemTypes = theElementsToKeep[i]->GetTypes();
+ if ( elemTypes->length() == 1 && elemTypes[0] == SMESH::NODE )
+ continue;
+ SMESH::smIdType_array_var elementsId = theElementsToKeep[i]->GetIDs();
+ for ( CORBA::ULong j = 0; j < elementsId->length(); ++j )
+ idsToKeep.Add( elementsId[ j ]);
+ }
+
::SMESH_MeshEditor::TListOfListOfElementsID aListOfListOfElementsID;
- for ( CORBA::ULong i = 0; i < GroupsOfElementsID.length(); i++ ) {
- const SMESH::long_array& anElemsIDGroup = GroupsOfElementsID[ i ];
- aListOfListOfElementsID.push_back( list< int >() );
- list< int >& aListOfElemsID = aListOfListOfElementsID.back();
- for ( CORBA::ULong j = 0; j < anElemsIDGroup.length(); j++ ) {
- CORBA::Long id = anElemsIDGroup[ j ];
- aListOfElemsID.push_back( id );
+ for ( CORBA::ULong i = 0; i < theGroupsOfElementsID.length(); i++ )
+ {
+ const SMESH::long_array& anElemsIDGroup = theGroupsOfElementsID[ i ];
+ aListOfListOfElementsID.push_back( list< smIdType >() );
+ list< smIdType >& aListOfElemsID = aListOfListOfElementsID.back();
+ for ( CORBA::ULong j = 0; j < anElemsIDGroup.length(); j++ )
+ {
+ SMESH::smIdType id = anElemsIDGroup[ j ];
+ if ( idsToKeep.Contains( id )) aListOfElemsID.push_front( id );
+ else aListOfElemsID.push_back( id );
}
if ( aListOfElemsID.size() < 2 )
aListOfListOfElementsID.pop_back();
declareMeshModified( /*isReComputeSafe=*/true );
- aTPythonDump << "] )";
+ aTPythonDump << "], " << theElementsToKeep << " )";
SMESH_CATCH( SMESH::throwCorbaException );
}
//=======================================================================
void SMESH_MeshEditor_i::MergeEqualElements()
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
*/
//=============================================================================
-CORBA::Boolean SMESH_MeshEditor_i::MoveNode(CORBA::Long NodeID,
- CORBA::Double x,
- CORBA::Double y,
- CORBA::Double z)
- throw (SALOME::SALOME_Exception)
+CORBA::Boolean SMESH_MeshEditor_i::MoveNode(SMESH::smIdType NodeID,
+ CORBA::Double x,
+ CORBA::Double y,
+ CORBA::Double z)
{
SMESH_TRY;
initData(/*deleteSearchers=*/false);
// 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 ));
*/
//================================================================================
-CORBA::Long SMESH_MeshEditor_i::FindNodeClosestTo(CORBA::Double x,
+SMESH::smIdType 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
*/
//================================================================================
-CORBA::Long SMESH_MeshEditor_i::MoveClosestNodeToPoint(CORBA::Double x,
- CORBA::Double y,
- CORBA::Double z,
- CORBA::Long theNodeID)
- throw (SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_MeshEditor_i::MoveClosestNodeToPoint(CORBA::Double x,
+ CORBA::Double y,
+ CORBA::Double z,
+ SMESH::smIdType theNodeID)
{
SMESH_TRY;
// We keep theNodeSearcher until any mesh modification:
theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other
- int nodeID = theNodeID;
+ smIdType nodeID = theNodeID;
const SMDS_MeshNode* node = getMeshDS()->FindNode( nodeID );
if ( !node ) // preview moving node
{
*/
//=======================================================================
-SMESH::long_array* SMESH_MeshEditor_i::FindElementsByPoint(CORBA::Double x,
+SMESH::smIdType_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;
+ SMESH::smIdType_array_var res = new SMESH::smIdType_array;
vector< const SMDS_MeshElement* > foundElems;
theSearchersDeleter.Set( myMesh );
// 'ALL' type means elements of any type excluding nodes
//=======================================================================
-SMESH::long_array*
+SMESH::smIdType_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::smIdType_array_var res = new SMESH::smIdType_array;
+ prepareIdSource( elementIDs );
if ( type != SMESH::NODE )
{
SMESH::array_of_ElementType_var types = elementIDs->GetTypes();
type != types[0] ) // but search of elements of dim > 0
return res._retn();
}
+
+ SMESH::SMESH_Mesh_var mesh = elementIDs->GetMesh();
+ SMESH_Mesh_i* mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
+ if ( mesh_i != myMesh_i )
+ {
+ SMESH::SMESH_MeshEditor_var editor=
+ myIsPreviewMode ? mesh_i->GetMeshEditPreviewer() : mesh_i->GetMeshEditor();
+ return editor->FindAmongElementsByPoint( elementIDs, x,y,z, type );
+ }
+
if ( SMESH::DownCast<SMESH_Mesh_i*>( elementIDs )) // elementIDs is the whole mesh
return FindElementsByPoint( x,y,z, 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,
- ( type == SMESH::NODE ? SMDSAbs_All : (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 );
+ SMDS_ElemIteratorPtr elemIt;
+ if ( ! SMESH::DownCast<SMESH_Mesh_i*>( elementIDs ))
+ {
+ //prepareIdSource( elementIDs );
+ elemIt = myMesh_i->GetElements( elementIDs, type );
+ if ( !elemIt )
+ return res._retn();
+ }
+ theElementSearcher = SMESH_MeshAlgos::GetElementSearcher( *getMeshDS(), elemIt );
}
vector< const SMDS_MeshElement* > foundElems;
return 0;
}
+//=======================================================================
+//function : ProjectPoint
+//purpose : Project a point to a mesh object.
+// Return ID of an element of given type where the given point is projected
+// and coordinates of the projection point.
+// In the case if nothing found, return -1 and []
+//=======================================================================
+
+SMESH::smIdType SMESH_MeshEditor_i::ProjectPoint(CORBA::Double x,
+ CORBA::Double y,
+ CORBA::Double z,
+ SMESH::ElementType type,
+ SMESH::SMESH_IDSource_ptr meshObject,
+ SMESH::double_array_out projecton)
+{
+ if ( CORBA::is_nil( meshObject ))
+ THROW_SALOME_CORBA_EXCEPTION("NULL meshObject", SALOME::BAD_PARAM);
+
+ SMESH_TRY;
+
+ SMESH::SMESH_Mesh_var mesh = meshObject->GetMesh();
+ SMESH_Mesh_i* mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
+ if ( mesh_i != myMesh_i )
+ {
+ SMESH::SMESH_MeshEditor_var editor=
+ myIsPreviewMode ? mesh_i->GetMeshEditPreviewer() : mesh_i->GetMeshEditor();
+ return editor->ProjectPoint( x,y,z, type, meshObject, projecton );
+ }
+
+
+ theSearchersDeleter.Set( myMesh, getPartIOR( meshObject, type ));
+ if ( !theElementSearcher )
+ {
+ // create a searcher from meshObject
+
+ SMDS_ElemIteratorPtr elemIt;
+ if ( ! SMESH::DownCast<SMESH_Mesh_i*>( meshObject ))
+ {
+ prepareIdSource( meshObject );
+ elemIt = myMesh_i->GetElements( meshObject, type );
+ if ( !elemIt )
+ return -1;
+ }
+ theElementSearcher = SMESH_MeshAlgos::GetElementSearcher( *getMeshDS(), elemIt );
+ }
+
+ const SMDS_MeshElement* elem = 0;
+ gp_XYZ pProj = theElementSearcher->Project( gp_Pnt( x,y,z ),
+ SMDSAbs_ElementType( type ),
+ &elem );
+
+ projecton = new SMESH::double_array();
+ if ( elem && !elem->IsNull() )
+ {
+ projecton->length( 3 );
+ projecton[0] = pProj.X();
+ projecton[1] = pProj.Y();
+ projecton[2] = pProj.Z();
+ return elem->GetID();
+ }
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return -1;
+}
+
//=======================================================================
//function : GetPointState
//purpose : Return point state in a closed 2D mesh in terms of TopAbs_State enumeration.
CORBA::Short SMESH_MeshEditor_i::GetPointState(CORBA::Double x,
CORBA::Double y,
CORBA::Double z)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
theSearchersDeleter.Set( myMesh );
//=======================================================================
CORBA::Boolean SMESH_MeshEditor_i::IsManifold()
- throw (SALOME::SALOME_Exception)
{
bool isManifold = true;
//=======================================================================
CORBA::Boolean SMESH_MeshEditor_i::IsCoherentOrientation2D()
- throw (SALOME::SALOME_Exception)
{
bool isGoodOri = true;
return isGoodOri;
}
+//=======================================================================
+//function : Get1DBranches
+//purpose : Partition given 1D elements into groups of contiguous edges.
+// A node where number of meeting edges != 2 is a group end.
+// An optional startNode is used to orient groups it belongs to.
+//return : a list of edge groups and a list of corresponding node groups.
+// If a group is closed, the first and last nodes of the group are same.
+//=======================================================================
+
+SMESH::array_of_long_array*
+SMESH_MeshEditor_i::Get1DBranches( SMESH::SMESH_IDSource_ptr theEdges,
+ SMESH::smIdType theStartNode,
+ SMESH::array_of_long_array_out theNodeGroups )
+{
+ if ( CORBA::is_nil( theEdges ))
+ THROW_SALOME_CORBA_EXCEPTION("Get1DBranches(): NULL group given", SALOME::BAD_PARAM);
+
+ SMESH::array_of_long_array_var edgeGroupArray = new SMESH::array_of_long_array;
+ theNodeGroups = new SMESH::array_of_long_array;
+
+ SMESH_TRY;
+
+ prepareIdSource( theEdges );
+
+ SMESH_MeshAlgos::TElemGroupVector edgeBranches;
+ SMESH_MeshAlgos::TNodeGroupVector nodeBranches;
+ SMESH_MeshAlgos::Get1DBranches( SMESH_Mesh_i::GetElements( theEdges, SMESH::EDGE ),
+ edgeBranches,
+ nodeBranches,
+ getMeshDS()->FindNode( theStartNode ));
+
+ edgeGroupArray->length( edgeBranches.size() );
+ for ( size_t iG = 0; iG < edgeBranches.size(); ++iG )
+ {
+ edgeGroupArray[ iG ].length( edgeBranches[ iG ].size() );
+ for ( size_t i = 0; i < edgeBranches[ iG ].size(); ++i )
+ edgeGroupArray[ iG ][ i ] = edgeBranches[ iG ][ i ]->GetID();
+ }
+
+ theNodeGroups->length( nodeBranches.size() );
+ for ( size_t iG = 0; iG < nodeBranches.size(); ++iG )
+ {
+ theNodeGroups[ iG ].length( nodeBranches[ iG ].size() );
+ for ( size_t i = 0; i < nodeBranches[ iG ].size(); ++i )
+ theNodeGroups[ iG ][ i ] = nodeBranches[ iG ][ i ]->GetID();
+ }
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+
+ return edgeGroupArray._retn();
+}
+
+//=======================================================================
+//function : FindSharpEdges
+//purpose : Return sharp edges of faces and non-manifold ones. Optionally add existing edges.
+//=======================================================================
+
+SMESH::ListOfEdges* SMESH_MeshEditor_i::FindSharpEdges(CORBA::Double theAngle,
+ CORBA::Boolean theAddExisting)
+{
+ SMESH::ListOfEdges_var resultEdges = new SMESH::ListOfEdges;
+ SMESH_TRY;
+
+ initData();
+
+ std::vector< SMESH_MeshAlgos::Edge > edges =
+ SMESH_MeshAlgos::FindSharpEdges( getMeshDS(), theAngle, theAddExisting );
+
+ if ( myIsPreviewMode ) // fill a preview mesh with edges
+ {
+ TPreviewMesh* mesh = getPreviewMesh( SMDSAbs_Edge );
+ SMDS_Mesh* meshDS = mesh->GetMeshDS();
+ for ( size_t i = 0; i < edges.size(); ++i )
+ {
+ SMESH_NodeXYZ xyz1( edges[i]._node1), xyz2( edges[i]._node2);
+ SMDS_MeshNode* n1 = meshDS->AddNode( xyz1.X(), xyz1.Y(), xyz1.Z() );
+ SMDS_MeshNode* n2 = meshDS->AddNode( xyz2.X(), xyz2.Y(), xyz2.Z() );
+ if ( edges[i]._medium )
+ {
+ xyz1.Set( edges[i]._medium );
+ SMDS_MeshNode* nm = meshDS->AddNode( xyz1.X(), xyz1.Y(), xyz1.Z() );
+ mesh->GetMeshDS()->AddEdge( n1, n2, nm );
+ }
+ else
+ {
+ mesh->GetMeshDS()->AddEdge( n1, n2 );
+ }
+ }
+ }
+ else
+ {
+ resultEdges->length( edges.size() );
+ for ( size_t i = 0; i < edges.size(); ++i )
+ {
+ resultEdges[ i ].node1 = edges[i]._node1->GetID();
+ resultEdges[ i ].node2 = edges[i]._node2->GetID();
+ resultEdges[ i ].medium = edges[i]._medium ? edges[i]._medium->GetID() : 0;
+ }
+ }
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return resultEdges._retn();
+}
+
//=======================================================================
//function : FindFreeBorders
//purpose : Returns all or only closed FreeBorder's.
//=======================================================================
SMESH::ListOfFreeBorders* SMESH_MeshEditor_i::FindFreeBorders(CORBA::Boolean closedOnly)
- throw (SALOME::SALOME_Exception)
{
SMESH::ListOfFreeBorders_var resBorders = new SMESH::ListOfFreeBorders;
SMESH_TRY;
//purpose : Fill with 2D elements a hole defined by a FreeBorder.
//=======================================================================
-void SMESH_MeshEditor_i::FillHole(const SMESH::FreeBorder& theHole)
- throw (SALOME::SALOME_Exception)
+SMESH::SMESH_Group_ptr
+SMESH_MeshEditor_i::FillHole(const SMESH::FreeBorder& theHole,
+ const char* theGroupName)
{
initData();
SMESH_TRY;
+ // prepare a preview mesh
MeshEditor_I::TPreviewMesh* previewMesh = 0;
SMDS_Mesh* meshDS = getMeshDS();
if ( myIsPreviewMode )
meshDS = previewMesh->GetMeshDS();
}
+ // fill the hole
std::vector<const SMDS_MeshElement*> newFaces;
SMESH_MeshAlgos::FillHole( bordNodes, *meshDS, newFaces );
if ( myIsPreviewMode )
{
+ // show new faces
previewMesh->Clear();
for ( size_t i = 0; i < newFaces.size(); ++i )
previewMesh->Copy( newFaces[i] );
}
else
{
+ // return new faces via a group
+ SMESH::SMESH_Group_var group;
+ if ( theGroupName && theGroupName[0] && !newFaces.empty() )
+ {
+ SMESH::ListOfGroups_var groups = myMesh_i->GetGroups();
+ for ( CORBA::ULong i = 0; i < groups->length(); ++i )
+ {
+ SMESH::SMESH_GroupBase_var g = groups[ i ];
+ if ( g->GetType() != SMESH::FACE ) continue;
+ SMESH::SMESH_Group_var standalone = SMESH::SMESH_Group::_narrow( g );
+ if ( standalone->_is_nil() ) continue;
+ CORBA::String_var name = g->GetName();
+ if ( strcmp( theGroupName, name.in() ) == 0 )
+ {
+ group = standalone;
+ break;
+ }
+ }
+ if ( group->_is_nil() )
+ group = myMesh_i->CreateGroup( SMESH::FACE, theGroupName );
+
+ if ( !group->_is_nil() )
+ {
+ SMESH_GroupBase_i * grpI = SMESH::DownCast< SMESH_GroupBase_i* >( group );
+ SMESHDS_Group* grpDS = static_cast< SMESHDS_Group* >( grpI->GetGroupDS() );
+ for ( size_t i = 0; i < newFaces.size(); ++i )
+ grpDS->Add( newFaces[ i ]);
+ }
+ }
+
+ // fill LastCreated
getEditor().ClearLastCreated();
SMESH_SequenceOfElemPtr& aSeq =
const_cast<SMESH_SequenceOfElemPtr&>( getEditor().GetLastCreatedElems() );
- for ( size_t i = 0; i < newFaces.size(); ++i )
- aSeq.Append( newFaces[i] );
+ aSeq.swap( newFaces );
- TPythonDump() << this << ".FillHole( SMESH.FreeBorder(" << theHole.nodeIDs << " ))";
+ TPythonDump pyDump;
+ if ( group->_is_nil() ) pyDump << "_group = ";
+ else pyDump << group << " = ";
+ pyDump << this << ".FillHole( SMESH.FreeBorder(" << theHole.nodeIDs << " ))";
+
+ return group._retn();
}
SMESH_CATCH( SMESH::throwCorbaException );
+
+ return SMESH::SMESH_Group::_nil();
}
//=======================================================================
SewCoincidentFreeBorders(const SMESH::CoincidentFreeBorders& freeBorders,
CORBA::Boolean createPolygons,
CORBA::Boolean createPolyhedra)
- throw (SALOME::SALOME_Exception)
{
CORBA::Short nbSewed = 0;
//=======================================================================
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_MeshEditor_i::SewFreeBorders(SMESH::smIdType FirstNodeID1,
+ SMESH::smIdType SecondNodeID1,
+ SMESH::smIdType LastNodeID1,
+ SMESH::smIdType FirstNodeID2,
+ SMESH::smIdType SecondNodeID2,
+ SMESH::smIdType LastNodeID2,
+ CORBA::Boolean CreatePolygons,
+ CORBA::Boolean CreatePolyedrs)
{
SMESH_TRY;
initData();
//=======================================================================
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)
+SMESH_MeshEditor_i::SewConformFreeBorders(SMESH::smIdType FirstNodeID1,
+ SMESH::smIdType SecondNodeID1,
+ SMESH::smIdType LastNodeID1,
+ SMESH::smIdType FirstNodeID2,
+ SMESH::smIdType SecondNodeID2)
{
SMESH_TRY;
initData();
//=======================================================================
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)
+SMESH_MeshEditor_i::SewBorderToSide(SMESH::smIdType FirstNodeIDOnFreeBorder,
+ SMESH::smIdType SecondNodeIDOnFreeBorder,
+ SMESH::smIdType LastNodeIDOnFreeBorder,
+ SMESH::smIdType FirstNodeIDOnSide,
+ SMESH::smIdType LastNodeIDOnSide,
+ CORBA::Boolean CreatePolygons,
+ CORBA::Boolean CreatePolyedrs)
{
SMESH_TRY;
initData();
//=======================================================================
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_MeshEditor_i::SewSideElements(const SMESH::smIdType_array& IDsOfSide1Elements,
+ const SMESH::smIdType_array& IDsOfSide2Elements,
+ SMESH::smIdType NodeID1OfSide1ToMerge,
+ SMESH::smIdType NodeID1OfSide2ToMerge,
+ SMESH::smIdType NodeID2OfSide1ToMerge,
+ SMESH::smIdType NodeID2OfSide2ToMerge)
{
SMESH_TRY;
initData();
*/
//================================================================================
-CORBA::Boolean SMESH_MeshEditor_i::ChangeElemNodes(CORBA::Long ide,
- const SMESH::long_array& newIDs)
- throw (SALOME::SALOME_Exception)
+CORBA::Boolean SMESH_MeshEditor_i::ChangeElemNodes(SMESH::smIdType ide,
+ const SMESH::smIdType_array& newIDs)
{
SMESH_TRY;
initData();
const SMDS_MeshElement* elem = getMeshDS()->FindElement(ide);
- if(!elem) return false;
+ 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;
- }
+ for ( int i = 0; i < nbn; i++ ) {
+ const SMDS_MeshNode* aNode = getMeshDS()->FindNode( newIDs[ i ]);
+ if ( !aNode )
+ return false;
+ aNodes[ i ] = aNode;
}
TPythonDump() << "isDone = " << this << ".ChangeElemNodes( "
<< ide << ", " << newIDs << " )";
- bool res = getMeshDS()->ChangeElementNodes( elem, & aNodes[0], nbn1+1 );
+ bool res = getMeshDS()->ChangeElementNodes( elem, & aNodes[0], aNodes.size() );
declareMeshModified( /*isReComputeSafe=*/ !res );
void SMESH_MeshEditor_i::convertToQuadratic(CORBA::Boolean theForce3d,
CORBA::Boolean theToBiQuad,
SMESH::SMESH_IDSource_ptr theObject)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
bool elemsOK;
if ( !( elemsOK = CORBA::is_nil( theObject )))
{
- elemsOK = idSourceToSet( theObject, getMeshDS(), elems,
- SMDSAbs_All, /*emptyIfIsMesh=*/true );
+ elemsOK = idSourceToSet( theObject, getMeshDS(), elems,
+ SMDSAbs_All, /*emptyIfIsMesh=*/true );
}
if ( elemsOK )
{
//=======================================================================
CORBA::Boolean SMESH_MeshEditor_i::ConvertFromQuadratic()
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
//=======================================================================
void SMESH_MeshEditor_i::ConvertToQuadratic(CORBA::Boolean theForce3d)
- throw (SALOME::SALOME_Exception)
{
convertToQuadratic( theForce3d, false );
TPythonDump() << this << ".ConvertToQuadratic("<<theForce3d<<")";
void SMESH_MeshEditor_i::ConvertToQuadraticObject(CORBA::Boolean theForce3d,
SMESH::SMESH_IDSource_ptr theObject)
- throw (SALOME::SALOME_Exception)
{
convertToQuadratic( theForce3d, false, theObject );
TPythonDump() << this << ".ConvertToQuadraticObject("<<theForce3d<<", "<<theObject<<")";
void SMESH_MeshEditor_i::ConvertToBiQuadratic(CORBA::Boolean theForce3d,
SMESH::SMESH_IDSource_ptr theObject)
- throw (SALOME::SALOME_Exception)
{
convertToQuadratic( theForce3d, true, theObject );
TPythonDump() << this << ".ConvertToBiQuadratic("<<theForce3d<<", "<<theObject<<")";
//================================================================================
void SMESH_MeshEditor_i::ConvertFromQuadraticObject(SMESH::SMESH_IDSource_ptr theObject)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
*/
//================================================================================
-std::string SMESH_MeshEditor_i::generateGroupName(const std::string& thePrefix)
+std::string SMESH_MeshEditor_i::GenerateGroupName(const std::string& thePrefix)
{
SMESH::ListOfGroups_var groups = myMesh_i->GetGroups();
set<std::string> groupNames;
}
if ( emptyIfIsMesh && SMESH::DownCast<SMESH_Mesh_i*>( theIDSource ))
{
- if ( error && getMeshDS()->GetMeshInfo().NbElements( theType ) == 0 )
+ if ( error && theMeshDS->GetMeshInfo().NbElements( theType ) == 0 )
*error = IDSource_EMPTY;
return true;
}
+ if ( getMeshDS() == theMeshDS ) // check if theIDSource belongs to myMesh
+ {
+ SMESH::SMESH_Mesh_var mesh = theIDSource->GetMesh();
+ SMESH_Mesh_i* mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
+ if ( mesh_i && mesh_i != myMesh_i )
+ {
+ if ( error )
+ *error = IDSource_INVALID;
+ return false;
+ }
+ }
prepareIdSource( theIDSource );
- SMESH::long_array_var anIDs = theIDSource->GetIDs();
+ SMESH::smIdType_array_var anIDs = theIDSource->GetIDs();
if ( anIDs->length() == 0 )
{
if ( error ) *error = IDSource_EMPTY;
* \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.
+ * are added to the existing 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 == "".
SMESH::SMESH_Group_ptr
SMESH_MeshEditor_i::DoubleElements(SMESH::SMESH_IDSource_ptr theElements,
const char* theGroupName)
- throw (SALOME::SALOME_Exception)
{
SMESH::SMESH_Group_var newGroup;
{
getEditor().DoubleElements( elems );
- if ( strlen( theGroupName ) && !getEditor().GetLastCreatedElems().IsEmpty() )
+ if ( strlen( theGroupName ) && !getEditor().GetLastCreatedElems().empty() )
{
// group type
SMESH::ElementType type =
- SMESH::ElementType( getEditor().GetLastCreatedElems().Value(1)->GetType() );
+ SMESH::ElementType( getEditor().GetLastCreatedElems()[0]->GetType() );
// find existing group
SMESH::ListOfGroups_var groups = myMesh_i->GetGroups();
for ( size_t i = 0; i < groups->length(); ++i )
{
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) );
+ for ( size_t i = 0; i < aSeq.size(); i++ )
+ groupDS->SMDSGroup().Add( aSeq[i] );
}
}
}
*/
//================================================================================
-CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theNodes,
- const SMESH::long_array& theModifiedElems )
- throw (SALOME::SALOME_Exception)
+CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::smIdType_array& theNodes,
+ const SMESH::smIdType_array& theModifiedElems )
{
SMESH_TRY;
initData();
*/
//================================================================================
-CORBA::Boolean SMESH_MeshEditor_i::DoubleNode( CORBA::Long theNodeId,
- const SMESH::long_array& theModifiedElems )
- throw (SALOME::SALOME_Exception)
+CORBA::Boolean SMESH_MeshEditor_i::DoubleNode( SMESH::smIdType theNodeId,
+ const SMESH::smIdType_array& theModifiedElems )
{
SMESH_TRY;
- SMESH::long_array_var aNodes = new SMESH::long_array;
+ SMESH::smIdType_array_var aNodes = new SMESH::smIdType_array;
aNodes->length( 1 );
aNodes[ 0 ] = theNodeId;
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroup(SMESH::SMESH_GroupBase_ptr theNodes,
SMESH::SMESH_GroupBase_ptr theModifiedElems )
- throw (SALOME::SALOME_Exception)
{
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;
+ SMESH::smIdType_array_var aNodes = theNodes->GetListOfID();
+ SMESH::smIdType_array_var aModifiedElems;
if ( !CORBA::is_nil( theModifiedElems ) )
aModifiedElems = theModifiedElems->GetListOfID();
else
- {
- aModifiedElems = new SMESH::long_array;
- aModifiedElems->length( 0 );
- }
+ aModifiedElems = new SMESH::smIdType_array;
TPythonDump pyDump; // suppress dump by the next line
SMESH::SMESH_Group_ptr
SMESH_MeshEditor_i::DoubleNodeGroupNew( SMESH::SMESH_GroupBase_ptr theNodes,
SMESH::SMESH_GroupBase_ptr theModifiedElems )
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
SMESH::SMESH_Group_var aNewGroup;
return aNewGroup._retn();
// Duplicate nodes
- SMESH::long_array_var aNodes = theNodes->GetListOfID();
- SMESH::long_array_var aModifiedElems;
+ SMESH::smIdType_array_var aNodes = theNodes->GetListOfID();
+ SMESH::smIdType_array_var aModifiedElems;
if ( !CORBA::is_nil( theModifiedElems ) )
aModifiedElems = theModifiedElems->GetListOfID();
else {
- aModifiedElems = new SMESH::long_array;
+ aModifiedElems = new SMESH::smIdType_array;
aModifiedElems->length( 0 );
}
if ( aResult )
{
// Create group with newly created nodes
- SMESH::long_array_var anIds = GetLastCreatedNodes();
+ SMESH::smIdType_array_var anIds = GetLastCreatedNodes();
if (anIds->length() > 0) {
std::string anUnindexedName (theNodes->GetName());
- std::string aNewName = generateGroupName(anUnindexedName + "_double");
+ std::string aNewName = GenerateGroupName(anUnindexedName + "_double");
aNewGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
aNewGroup->Add(anIds);
pyDump << aNewGroup << " = ";
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups(const SMESH::ListOfGroups& theNodes,
const SMESH::ListOfGroups& theModifiedElems )
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
std::list< int > aNodes;
- int i, n, j, m;
+ smIdType 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();
+ SMESH::smIdType_array_var aCurr = aGrp->GetListOfID();
for ( j = 0, m = aCurr->length(); j < m; j++ )
aNodes.push_back( aCurr[ j ] );
}
SMESH::SMESH_GroupBase_var aGrp = theModifiedElems[ i ];
if ( !CORBA::is_nil( aGrp ) && aGrp->GetType() != SMESH::NODE )
{
- SMESH::long_array_var aCurr = aGrp->GetListOfID();
+ SMESH::smIdType_array_var aCurr = aGrp->GetListOfID();
for ( j = 0, m = aCurr->length(); j < m; j++ )
anElems.push_back( aCurr[ j ] );
}
SMESH::SMESH_Group_ptr
SMESH_MeshEditor_i::DoubleNodeGroupsNew( const SMESH::ListOfGroups& theNodes,
const SMESH::ListOfGroups& theModifiedElems )
- throw (SALOME::SALOME_Exception)
{
SMESH::SMESH_Group_var aNewGroup;
if ( aResult )
{
// Create group with newly created nodes
- SMESH::long_array_var anIds = GetLastCreatedNodes();
+ SMESH::smIdType_array_var anIds = GetLastCreatedNodes();
if (anIds->length() > 0) {
std::string anUnindexedName (theNodes[0]->GetName());
- std::string aNewName = generateGroupName(anUnindexedName + "_double");
+ std::string aNewName = GenerateGroupName(anUnindexedName + "_double");
aNewGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
aNewGroup->Add(anIds);
pyDump << aNewGroup << " = ";
*/
//================================================================================
-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)
+CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElem( const SMESH::smIdType_array& theElems,
+ const SMESH::smIdType_array& theNodesNot,
+ const SMESH::smIdType_array& theAffectedElems )
{
SMESH_TRY;
initData();
*/
//================================================================================
-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)
+CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemInRegion ( const SMESH::smIdType_array& theElems,
+ const SMESH::smIdType_array& theNodesNot,
+ GEOM::GEOM_Object_ptr theShape )
{
SMESH_TRY;
initData();
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 )
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,
SMESH::SMESH_GroupBase_ptr theAffectedElems,
CORBA::Boolean theElemGroupNeeded,
CORBA::Boolean theNodeGroupNeeded)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
SMESH::SMESH_Group_var aNewElemGroup, aNewNodeGroup;
{
// Create group with newly created elements
CORBA::String_var elemGroupName = theElems->GetName();
- std::string aNewName = generateGroupName( std::string(elemGroupName.in()) + "_double");
- if ( !getEditor().GetLastCreatedElems().IsEmpty() && theElemGroupNeeded )
+ std::string aNewName = GenerateGroupName( std::string(elemGroupName.in()) + "_double");
+ if ( !getEditor().GetLastCreatedElems().empty() && theElemGroupNeeded )
{
- SMESH::long_array_var anIds = GetLastCreatedElems();
+ SMESH::smIdType_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 )
+ if ( !getEditor().GetLastCreatedNodes().empty() && theNodeGroupNeeded )
{
- SMESH::long_array_var anIds = GetLastCreatedNodes();
+ SMESH::smIdType_array_var anIds = GetLastCreatedNodes();
aNewNodeGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
aNewNodeGroup->Add(anIds);
}
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 )
if ( !CORBA::is_nil( aGrp ) && (theIsNodeGrp ? aGrp->GetType() == SMESH::NODE
: aGrp->GetType() != SMESH::NODE ) )
{
- SMESH::long_array_var anIDs = aGrp->GetIDs();
+ SMESH::smIdType_array_var anIDs = aGrp->GetIDs();
arrayToSet( anIDs, theMeshDS, theElemSet, theIsNodeGrp ? SMDSAbs_Node : SMDSAbs_All );
}
}
SMESH_MeshEditor_i::DoubleNodeElemGroups(const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot,
const SMESH::ListOfGroups& theAffectedElems)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
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,
const SMESH::ListOfGroups& theAffectedElems,
CORBA::Boolean theElemGroupNeeded,
CORBA::Boolean theNodeGroupNeeded)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
SMESH::SMESH_Group_var aNewElemGroup, aNewNodeGroup;
{
// Create group with newly created elements
CORBA::String_var elemGroupName = theElems[0]->GetName();
- std::string aNewName = generateGroupName( std::string(elemGroupName.in()) + "_double");
- if ( !getEditor().GetLastCreatedElems().IsEmpty() && theElemGroupNeeded )
+ std::string aNewName = GenerateGroupName( std::string(elemGroupName.in()) + "_double");
+ if ( !getEditor().GetLastCreatedElems().empty() && theElemGroupNeeded )
{
- SMESH::long_array_var anIds = GetLastCreatedElems();
+ SMESH::smIdType_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 )
+ if ( !getEditor().GetLastCreatedNodes().empty() && theNodeGroupNeeded )
{
- SMESH::long_array_var anIds = GetLastCreatedNodes();
+ SMESH::smIdType_array_var anIds = GetLastCreatedNodes();
aNewNodeGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
aNewNodeGroup->Add(anIds);
}
SMESH_MeshEditor_i::DoubleNodeElemGroupsInRegion(const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot,
GEOM::GEOM_Object_ptr theShape )
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
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 theNodesNot - list of groups of nodes not to 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.
SMESH_MeshEditor_i::AffectedElemGroupsInRegion( const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot,
GEOM::GEOM_Object_ptr theShape )
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
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");
+ SMESH::SMESH_Group_var aNewEdgeGroup = SMESH::SMESH_Group::_nil();
+ SMESH::SMESH_Group_var aNewFaceGroup = SMESH::SMESH_Group::_nil();
+ SMESH::SMESH_Group_var aNewVolumeGroup = SMESH::SMESH_Group::_nil();
initData();
SMESHDS_Mesh* aMeshDS = getMeshDS();
TIDSortedElemSet anElems, aNodes;
- listOfGroupToSet(theElems, aMeshDS, anElems, false);
+ bool isNodeGrp = theElems.length() ? theElems[0]->GetType() == SMESH::NODE : false;
+ listOfGroupToSet(theElems, aMeshDS, anElems, isNodeGrp);
listOfGroupToSet(theNodesNot, aMeshDS, aNodes, true);
TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape(theShape);
TIDSortedElemSet anAffected;
bool aResult = aMeshEditor.AffectedElemGroupsInRegion(anElems, aNodes, aShape, anAffected);
-
declareMeshModified( /*isReComputeSafe=*/ !aResult );
TPythonDump pyDump;
- if (aResult)
- {
- int lg = anAffected.size();
- 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);
+ if ( aResult && anAffected.size() > 0 )
+ {
+ SMESH::smIdType_array_var volumeIds = new SMESH::smIdType_array;
+ SMESH::smIdType_array_var faceIds = new SMESH::smIdType_array;
+ SMESH::smIdType_array_var edgeIds = new SMESH::smIdType_array;
+ volumeIds->length( anAffected.size() );
+ faceIds ->length( anAffected.size() );
+ edgeIds ->length( anAffected.size() );
+
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;
+ smIdType elemId = anElem->GetID();
+ switch ( anElem->GetType() ) {
+ case SMDSAbs_Volume: volumeIds[ivol++] = elemId; break;
+ case SMDSAbs_Face: faceIds[iface++] = elemId; break;
+ case SMDSAbs_Edge: edgeIds[iedge++] = elemId; break;
+ default:;
+ }
}
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);
+ int nbGroups = 0;
+ if ( ivol > 0 )
+ {
+ aNewVolumeGroup = myMesh_i->CreateGroup(SMESH::VOLUME,
+ GenerateGroupName("affectedVolumes").c_str());
+ aNewVolumeGroup->Add(volumeIds);
+ aListOfGroups->length( nbGroups+1 );
+ aListOfGroups[ nbGroups++ ] = aNewVolumeGroup._retn();
+ }
+ if ( iface > 0 )
+ {
+ aNewFaceGroup = myMesh_i->CreateGroup(SMESH::FACE,
+ GenerateGroupName("affectedFaces").c_str());
+ aNewFaceGroup->Add(faceIds);
+ aListOfGroups->length( nbGroups+1 );
+ aListOfGroups[ nbGroups++ ] = aNewFaceGroup._retn();
+ }
+ if ( iedge > 0 )
+ {
+ aNewEdgeGroup = myMesh_i->CreateGroup(SMESH::EDGE,
+ GenerateGroupName("affectedEdges").c_str());
+ aNewEdgeGroup->Add(edgeIds);
+ aListOfGroups->length( nbGroups+1 );
+ aListOfGroups[ nbGroups++ ] = aNewEdgeGroup._retn();
+ }
}
- int nbGroups = 0;
- if (isEdgeGroup) nbGroups++;
- if (isFaceGroup) nbGroups++;
- if (isVolumeGroup) nbGroups++;
- aListOfGroups->length(nbGroups);
-
- 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( "
+ pyDump << aListOfGroups << " = " << this << ".AffectedElemGroupsInRegion( "
<< &theElems << ", " << &theNodesNot << ", " << theShape << " )";
return aListOfGroups._retn();
//================================================================================
/*!
\brief Generated skin mesh (containing 2D cells) from 3D mesh
- The created 2D mesh elements based on nodes of free faces of boundary volumes
+ 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::Make2DMeshFrom3D()
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
SMESH_MeshEditor_i::DoubleNodesOnGroupBoundaries( const SMESH::ListOfGroups& theDomains,
CORBA::Boolean createJointElems,
CORBA::Boolean onAllBoundaries )
- throw (SALOME::SALOME_Exception)
{
bool isOK = false;
{
// if ( aGrp->GetType() != SMESH::VOLUME )
// THROW_SALOME_CORBA_EXCEPTION("Not a volume group", SALOME::BAD_PARAM);
- SMESH::long_array_var anIDs = aGrp->GetIDs();
+ SMESH::smIdType_array_var anIDs = aGrp->GetIDs();
arrayToSet( anIDs, aMeshDS, domains[ i ], SMDSAbs_All );
}
}
CORBA::Boolean
SMESH_MeshEditor_i::CreateFlatElementsOnFacesGroups( const SMESH::ListOfGroups& theGroupsOfFaces )
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
TIDSortedElemSet faceGroup;
faceGroup.clear();
faceGroups.push_back(faceGroup);
- SMESH::long_array_var anIDs = aGrp->GetIDs();
+ SMESH::smIdType_array_var anIDs = aGrp->GetIDs();
arrayToSet( anIDs, aMeshDS, faceGroups[ i ], SMDSAbs_All );
}
}
const char* groupName,
const SMESH::double_array& theNodesCoords,
SMESH::array_of_long_array_out GroupsOfNodes)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
CORBA::Boolean toCopyElements,
CORBA::Boolean toCopyExistingBondary,
SMESH::SMESH_Group_out group)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
const SMESH::ListOfIDSources& groups,
SMESH::SMESH_Mesh_out mesh,
SMESH::SMESH_Group_out group)
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
for ( CORBA::ULong i = 0; i < groups.length(); ++i )
{
SMESH::SMESH_Mesh_var m = groups[i]->GetMesh();
- if ( myMesh_i != SMESH::DownCast<SMESH_Mesh_i*>( m ))
+ if ( !m->_is_nil() && myMesh_i != SMESH::DownCast<SMESH_Mesh_i*>( m ))
groupsOfOtherMesh[ nbGroupsOfOtherMesh++ ] = groups[i];
else
groupsOfThisMesh[ nbGroups++ ] = groups[i];
// group of boundary elements
SMESH_Group* smesh_group = 0;
SMDSAbs_ElementType elemType = (dim == SMESH::BND_2DFROM3D) ? SMDSAbs_Volume : SMDSAbs_Face;
- if ( strlen(groupName) )
+ if ( strlen( groupName ))
{
SMESH::ElementType groupType = SMESH::ElementType( int(elemType)-1 );
group_var = mesh_i->CreateGroup( groupType, groupName );
void SMESH_MeshEditor_i::MakePolyLine(SMESH::ListOfPolySegments& theSegments,
const char* theGroupName)
- throw (SALOME::SALOME_Exception)
{
if ( theSegments.length() == 0 )
THROW_SALOME_CORBA_EXCEPTION("No segments given", SALOME::BAD_PARAM );
}
else if ( theGroupName[0] ) // find/create a group of segments
{
- SMESH_Mesh::GroupIteratorPtr grpIt = myMesh->GetGroups();
- while ( !groupDS && grpIt->more() )
- {
- SMESH_Group* group = grpIt->next();
- if ( group->GetGroupDS()->GetType() == SMDSAbs_Edge &&
- strcmp( group->GetName(), theGroupName ) == 0 )
- {
- groupDS = dynamic_cast< SMESHDS_Group* >( group->GetGroupDS() );
- }
- }
+ // SMESH_Mesh::GroupIteratorPtr grpIt = myMesh->GetGroups();
+ // while ( !groupDS && grpIt->more() )
+ // {
+ // SMESH_Group* group = grpIt->next();
+ // if ( group->GetGroupDS()->GetType() == SMDSAbs_Edge &&
+ // strcmp( group->GetName(), theGroupName ) == 0 )
+ // {
+ // groupDS = dynamic_cast< SMESHDS_Group* >( group->GetGroupDS() );
+ // }
+ // }
if ( !groupDS )
{
SMESH::SMESH_Group_var groupVar = myMesh_i->CreateGroup( SMESH::EDGE, theGroupName );
}
// convert input polySegments
- ::SMESH_MeshEditor::TListOfPolySegments segments( theSegments.length() );
+ SMESH_MeshAlgos::TListOfPolySegments segments( theSegments.length() );
for ( CORBA::ULong i = 0; i < theSegments.length(); ++i )
{
- SMESH::PolySegment& segIn = theSegments[ i ];
- ::SMESH_MeshEditor::PolySegment& segOut = segments[ i ];
+ SMESH::PolySegment& segIn = theSegments[ i ];
+ SMESH_MeshAlgos::PolySegment& segOut = segments[ i ];
segOut.myNode1[0] = meshDS->FindNode( segIn.node1ID1 );
segOut.myNode2[0] = meshDS->FindNode( segIn.node1ID2 );
segOut.myNode1[1] = meshDS->FindNode( segIn.node2ID1 );
segOut.myNode2[1] = meshDS->FindNode( segIn.node2ID2 );
+ segOut.myXYZ[0].SetCoord( segIn.xyz1.x,
+ segIn.xyz1.y,
+ segIn.xyz1.z);
+ segOut.myXYZ[1].SetCoord( segIn.xyz2.x,
+ segIn.xyz2.y,
+ segIn.xyz2.z);
segOut.myVector.SetCoord( segIn.vector.PS.x,
segIn.vector.PS.y,
segIn.vector.PS.z );
- if ( !segOut.myNode1[0] )
- THROW_SALOME_CORBA_EXCEPTION( SMESH_Comment( "Invalid node ID: ") << segIn.node1ID1,
- SALOME::BAD_PARAM );
- if ( !segOut.myNode1[1] )
- THROW_SALOME_CORBA_EXCEPTION( SMESH_Comment( "Invalid node ID: ") << segIn.node2ID1,
- SALOME::BAD_PARAM );
}
// get a static ElementSearcher
theElementSearcher = SMESH_MeshAlgos::GetElementSearcher( *getMeshDS() );
// compute
- getEditor().MakePolyLine( segments, groupDS, theElementSearcher );
+ std::vector<const SMDS_MeshElement*> newEdges;
+ std::vector<const SMDS_MeshNode*> newNodes;
+ SMESH_MeshAlgos::MakePolyLine( meshDS, segments, newEdges, newNodes,
+ groupDS ? &groupDS->SMDSGroup() : 0,
+ theElementSearcher );
+
+ const_cast< SMESH_SequenceOfElemPtr& >( getEditor().GetLastCreatedElems() ).
+ swap( newEdges );
+ const_cast< SMESH_SequenceOfElemPtr& >( getEditor().GetLastCreatedNodes() ).
+ assign( newNodes.begin(), newNodes.end() );
// return vectors
if ( myIsPreviewMode )
{
for ( CORBA::ULong i = 0; i < theSegments.length(); ++i )
{
- SMESH::PolySegment& segOut = theSegments[ i ];
- ::SMESH_MeshEditor::PolySegment& segIn = segments[ i ];
+ SMESH::PolySegment& segOut = theSegments[ i ];
+ SMESH_MeshAlgos::PolySegment& segIn = segments[ i ];
segOut.vector.PS.x = segIn.myVector.X();
segOut.vector.PS.y = segIn.myVector.Y();
segOut.vector.PS.z = segIn.myVector.Z();
SMESH_CATCH( SMESH::throwCorbaException );
return;
}
+
+//================================================================================
+/*!
+ * \brief Create a slot of given width around given 1D elements lying on a triangle mesh.
+ * The slot is constructed by cutting faces by cylindrical surfaces made
+ * around each segment. Segments are expected to be created by MakePolyLine().
+ * \return Edges located at the slot boundary
+ */
+//================================================================================
+
+SMESH::ListOfEdges* SMESH_MeshEditor_i::MakeSlot(SMESH::SMESH_GroupBase_ptr theSegments,
+ CORBA::Double theWidth)
+{
+ if ( CORBA::is_nil( theSegments ) ||
+ theSegments->GetType() != SMESH::EDGE )
+ THROW_SALOME_CORBA_EXCEPTION("No segments given", SALOME::BAD_PARAM );
+ if ( myMesh->NbFaces() == 0 )
+ THROW_SALOME_CORBA_EXCEPTION("No faces in the mesh", SALOME::BAD_PARAM );
+
+ SMESH::ListOfEdges_var resultEdges = new SMESH::ListOfEdges;
+
+ SMESH_TRY;
+ initData(/*deleteSearchers=*/false);
+
+ SMESHDS_Mesh* meshDS = getMeshDS();
+
+ // get standalone face groups to be updated
+ std::vector< SMDS_MeshGroup* > faceGroups;
+ const std::set<SMESHDS_GroupBase*>& allGroups = meshDS->GetGroups();
+ std::set<SMESHDS_GroupBase*>::const_iterator grIt = allGroups.begin();
+ for ( ; grIt != allGroups.end(); ++grIt )
+ if ( const SMESHDS_Group* gr = dynamic_cast< const SMESHDS_Group* >( *grIt ))
+ if ( gr->GetType() == SMDSAbs_Face )
+ faceGroups.push_back( & const_cast< SMESHDS_Group* >( gr )->SMDSGroup() );
+
+ std::vector< SMESH_MeshAlgos::Edge > edges =
+ SMESH_MeshAlgos::MakeSlot( SMESH_Mesh_i::GetElements( theSegments, SMESH::EDGE ),
+ theWidth, meshDS, faceGroups );
+
+ resultEdges->length( edges.size() );
+ for ( size_t i = 0; i < edges.size(); ++i )
+ {
+ resultEdges[ i ].node1 = edges[i]._node1->GetID();
+ resultEdges[ i ].node2 = edges[i]._node2->GetID();
+ resultEdges[ i ].medium = edges[i]._medium ? edges[i]._medium->GetID() : 0;
+ }
+
+ meshDS->Modified();
+ SMESH_CATCH( SMESH::throwCorbaException );
+
+ TSearchersDeleter::Delete(); // face searcher becomes invalid as some faces were removed
+
+ return resultEdges._retn();
+}