*/
//================================================================================
- 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)
+ if ( SMESH::DownCast<SMESH_Mesh_i*>( theObject ))
{
- 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 ))
- {
- 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::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
+ {
+ 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 = 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_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()
facetToSplitNormal.PS.y,
facetToSplitNormal.PS.z ));
TIDSortedElemSet elemSet;
+ prepareIdSource( elems );
SMESH::long_array_var anElementsId = elems->GetIDs();
SMDS_MeshElement::GeomFilter filter( SMDSGeom_HEXA );
arrayToSet( anElementsId, getMeshDS(), elemSet, SMDSAbs_Volume, &filter );
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 );
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 );
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 );
initData();
TIDSortedNodeSet nodes;
+ prepareIdSource( theObject );
idSourceToNodeSet( theObject, getMeshDS(), nodes );
findCoincidentNodes( nodes, Tolerance, GroupsOfNodes, SeparateCornersAndMedium );
//================================================================================
/*!
- * \brief Finds nodes coincident 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,
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 << " )";
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)
+void SMESH_MeshEditor_i::FindEqualElements(const SMESH::ListOfIDSources& theObjects,
+ const SMESH::ListOfIDSources& theExceptObjects,
+ SMESH::array_of_long_array_out theGroupsOfElementsID)
throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
- SMESH::SMESH_GroupBase_var group = SMESH::SMESH_GroupBase::_narrow(theObject);
- if ( !(!group->_is_nil() && group->GetType() == SMESH::NODE) )
+ 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 )
+ {
+ 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 )
{
- TIDSortedElemSet elems;
- idSourceToSet( theObject, getMeshDS(), elems, SMDSAbs_All, /*emptyIfIsMesh=*/true);
+ 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 ];
+ SMESH::long_array& aGroup = (*theGroupsOfElementsID)[ j ];
list<int>& listOfIDs = *arraysIt;
aGroup.length( listOfIDs.size() );
list<int>::iterator idIt = listOfIDs.begin();
}
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)
+void SMESH_MeshEditor_i::MergeElements(const SMESH::array_of_long_array& theGroupsOfElementsID,
+ const SMESH::ListOfIDSources& theElementsToKeep)
throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
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::long_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 ];
+ for ( CORBA::ULong i = 0; i < theGroupsOfElementsID.length(); i++ )
+ {
+ const SMESH::long_array& anElemsIDGroup = theGroupsOfElementsID[ i ];
aListOfListOfElementsID.push_back( list< int >() );
list< int >& aListOfElemsID = aListOfListOfElementsID.back();
- for ( CORBA::ULong j = 0; j < anElemsIDGroup.length(); j++ ) {
+ for ( CORBA::ULong j = 0; j < anElemsIDGroup.length(); j++ )
+ {
CORBA::Long id = anElemsIDGroup[ j ];
- aListOfElemsID.push_back( id );
+ 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 );
}
SMESH_TRY;
SMESH::long_array_var res = new SMESH::long_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;
CORBA::Long SMESH_MeshEditor_i::ProjectPoint(CORBA::Double x,
CORBA::Double y,
CORBA::Double z,
- SMESH::SMESH_IDSource_ptr meshObject,
SMESH::ElementType type,
+ SMESH::SMESH_IDSource_ptr meshObject,
SMESH::double_array_out projecton)
throw (SALOME::SALOME_Exception)
{
{
SMESH::SMESH_MeshEditor_var editor=
myIsPreviewMode ? mesh_i->GetMeshEditPreviewer() : mesh_i->GetMeshEditor();
- return editor->ProjectPoint( x,y,z, meshObject, type, projecton );
+ return editor->ProjectPoint( x,y,z, type, meshObject, projecton );
}
- theSearchersDeleter.Set( myMesh, getPartIOR( meshObject ));
+ 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 );
}
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,
+ CORBA::Long theStartNode,
+ SMESH::array_of_long_array_out theNodeGroups )
+ throw (SALOME::SALOME_Exception)
+{
+ 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)
+ throw (SALOME::SALOME_Exception)
+{
+ 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.
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 )
{
*/
//================================================================================
-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();
if ( anIDs->length() == 0 )
SMESH::long_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 << " = ";
SMESH::long_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 << " = ";
{
// Create group with newly created elements
CORBA::String_var elemGroupName = theElems->GetName();
- std::string aNewName = generateGroupName( std::string(elemGroupName.in()) + "_double");
+ std::string aNewName = GenerateGroupName( std::string(elemGroupName.in()) + "_double");
if ( !getEditor().GetLastCreatedElems().empty() && theElemGroupNeeded )
{
SMESH::long_array_var anIds = GetLastCreatedElems();
{
// Create group with newly created elements
CORBA::String_var elemGroupName = theElems[0]->GetName();
- std::string aNewName = generateGroupName( std::string(elemGroupName.in()) + "_double");
+ std::string aNewName = GenerateGroupName( std::string(elemGroupName.in()) + "_double");
if ( !getEditor().GetLastCreatedElems().empty() && theElemGroupNeeded )
{
SMESH::long_array_var anIds = GetLastCreatedElems();
if ( ivol > 0 )
{
aNewVolumeGroup = myMesh_i->CreateGroup(SMESH::VOLUME,
- generateGroupName("affectedVolumes").c_str());
+ 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());
+ 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());
+ GenerateGroupName("affectedEdges").c_str());
aNewEdgeGroup->Add(edgeIds);
aListOfGroups->length( nbGroups+1 );
aListOfGroups[ nbGroups++ ] = aNewEdgeGroup._retn();
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];
}
// 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 );
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 consrtucted 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)
+ throw (SALOME::SALOME_Exception)
+{
+ 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();
+
+ std::vector< SMESH_MeshAlgos::Edge > edges =
+ SMESH_MeshAlgos::MakeSlot( SMESH_Mesh_i::GetElements( theSegments, SMESH::EDGE ),
+ theWidth, meshDS );
+
+ 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();
+}