myPreviewType = previewElements;
}
//!< Destructor
- virtual ~TPreviewMesh() { delete _myMeshDS; }
+ virtual ~TPreviewMesh() { delete _myMeshDS; _myMeshDS = 0; }
//!< Copy a set of elements
void Copy(const TIDSortedElemSet & theElements,
TIDSortedElemSet& theCopyElements,
if ( type == theAvoidType ||
( theSelectType != SMDSAbs_All && type != theSelectType ))
continue;
-
- if ( const SMDS_MeshElement* anElemCopy = Copy( anElem ))
+ const SMDS_MeshElement* anElemCopy;
+ if ( type == SMDSAbs_Node)
+ anElemCopy = Copy( cast2Node(anElem) );
+ else
+ anElemCopy = Copy( anElem );
+ if ( anElemCopy )
theCopyElements.insert( theCopyElements.end(), anElemCopy );
}
}
SMESH_Mesh* myMesh;
string myMeshPartIOR;
//!< Constructor
- TSearchersDeleter(): SMESH_subMeshEventListener( false ), // won't be deleted by submesh
+ TSearchersDeleter(): SMESH_subMeshEventListener( false, // won't be deleted by submesh
+ "SMESH_MeshEditor_i::TSearchersDeleter"),
myMesh(0) {}
//!< Delete theNodeSearcher
static void Delete()
SMESH::long_array* GetIDs() { return new SMESH::long_array( _ids ); }
SMESH::long_array* GetMeshInfo() { return 0; }
SMESH::SMESH_Mesh_ptr GetMesh() { return SMESH::SMESH_Mesh::_duplicate( _mesh ); }
+ bool IsMeshInfoCorrect() { return true; }
SMESH::array_of_ElementType* GetTypes()
{
SMESH::array_of_ElementType_var types = new SMESH::array_of_ElementType;
- types->length( 1 );
- types[0] = _type;
+ if ( _ids.length() > 0 ) {
+ types->length( 1 );
+ types[0] = _type;
+ }
return types._retn();
}
};
for ( int i = 0; i < seq.size(); i++ )
IdList.push_back( seq[i] );
- bool ret = anEditor.Remove( IdList, true );
+ int nbNodesBefore = myMesh->NbNodes();
+ anEditor.Remove( IdList, true );
myMesh->GetMeshDS()->Modified();
if ( IdList.size() )
myMesh->SetIsModified( true );
+ int nbNodesAfter = myMesh->NbNodes();
- return ret;
+ return nbNodesBefore - nbNodesAfter;
}
//=============================================================================
elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
nodes[4], nodes[5], nodes[6], nodes[7]);
}
+ else if (NbNodes == 9) {
+ elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
+ nodes[4], nodes[5], nodes[6], nodes[7], nodes[8] );
+ }
else if (NbNodes > 2) {
elem = GetMeshDS()->AddPolygonalFace(nodes);
}
case 10:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],
n[6],n[7],n[8],n[9]);
break;
+ case 12:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],
+ n[6],n[7],n[8],n[9],n[10],n[11]);
+ break;
case 13:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],
n[7],n[8],n[9],n[10],n[11],n[12]);
break;
n[8],n[9],n[10],n[11],n[12],n[13],n[14],
n[15],n[16],n[17],n[18],n[19]);
break;
+ case 27:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],
+ n[8],n[9],n[10],n[11],n[12],n[13],n[14],
+ n[15],n[16],n[17],n[18],n[19],
+ n[20],n[21],n[22],n[23],n[24],n[25],n[26]);
+ break;
}
// Update Python script
gp_Vec stepVec( P->x, P->y, P->z );
TIDSortedElemSet* workElements = & elements;
- TPreviewMesh tmpMesh( SMDSAbs_Face );
- SMESH_Mesh* mesh = myMesh;
-
+
+ SMDSAbs_ElementType aType = SMDSAbs_Face;
+ //::SMESH_MeshEditor::ExtrusionFlags aFlag = ::SMESH_MeshEditor::ExtrusionFlags::EXTRUSION_FLAG_BOUNDARY;
+ if (theElementType == SMDSAbs_Node)
+ {
+ aType = SMDSAbs_Edge;
+ //aFlag = ::SMESH_MeshEditor::ExtrusionFlags::EXTRUSION_FLAG_SEW;
+ }
+ TPreviewMesh tmpMesh( aType );
+ SMESH_Mesh* mesh = myMesh;
+
if ( myPreviewMode ) {
SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
tmpMesh.Copy( elements, copyElements, select, avoid );
TElemOfElemListMap aHystory;
::SMESH_MeshEditor anEditor( mesh );
- ::SMESH_MeshEditor::PGroupIDs groupIds =
+ ::SMESH_MeshEditor::PGroupIDs groupIds =
anEditor.ExtrusionSweep (*workElements, stepVec, theNbOfSteps, aHystory, theMakeGroups);
myMesh->GetMeshDS()->Modified();
}
}
+//=======================================================================
+//function : ExtrusionSweep0D
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::ExtrusionSweep0D(const SMESH::long_array & theIDsOfElements,
+ const SMESH::DirStruct & theStepVector,
+ CORBA::Long theNbOfSteps)
+{
+ extrusionSweep (theIDsOfElements, theStepVector, theNbOfSteps, false, SMDSAbs_Node );
+ if (!myPreviewMode) {
+ TPythonDump() << this << ".ExtrusionSweep0D( "
+ << theIDsOfElements << ", " << theStepVector <<", " << theNbOfSteps << " )";
+ }
+}
//=======================================================================
//function : ExtrusionSweepObject
}
}
+//=======================================================================
+//function : ExtrusionSweepObject0D
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::ExtrusionSweepObject0D(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::DirStruct & theStepVector,
+ CORBA::Long theNbOfSteps)
+{
+ SMESH::long_array_var anElementsId = theObject->GetIDs();
+ extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false, SMDSAbs_Node );
+ if ( !myPreviewMode ) {
+ TPythonDump() << this << ".ExtrusionSweepObject0D( "
+ << theObject << ", " << theStepVector << ", " << theNbOfSteps << " )";
+ }
+}
+
//=======================================================================
//function : ExtrusionSweepObject1D
//purpose :
return aGroups;
}
+//=======================================================================
+//function : ExtrusionSweepMakeGroups0D
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::ExtrusionSweepMakeGroups0D(const SMESH::long_array& theIDsOfElements,
+ const SMESH::DirStruct& theStepVector,
+ CORBA::Long theNbOfSteps)
+{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
+ SMESH::ListOfGroups* aGroups = extrusionSweep(theIDsOfElements, theStepVector, theNbOfSteps, true,SMDSAbs_Node);
+
+ if (!myPreviewMode) {
+ DumpGroupsList(aPythonDump, aGroups);
+ aPythonDump << this << ".ExtrusionSweepMakeGroups0D( " << theIDsOfElements
+ << ", " << theStepVector <<", " << theNbOfSteps << " )";
+ }
+ return aGroups;
+}
+
//=======================================================================
//function : ExtrusionSweepObjectMakeGroups
//purpose :
return aGroups;
}
+//=======================================================================
+//function : ExtrusionSweepObject0DMakeGroups
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::ExtrusionSweepObject0DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
+ const SMESH::DirStruct& theStepVector,
+ CORBA::Long theNbOfSteps)
+{
+ TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
+
+ SMESH::long_array_var anElementsId = theObject->GetIDs();
+ SMESH::ListOfGroups * aGroups = extrusionSweep(anElementsId, theStepVector,
+ theNbOfSteps, true, SMDSAbs_Node);
+ if (!myPreviewMode) {
+ DumpGroupsList(aPythonDump, aGroups);
+ aPythonDump << this << ".ExtrusionSweepObject0DMakeGroups( " << theObject
+ << ", " << theStepVector << ", " << theNbOfSteps << " )";
+ }
+ return aGroups;
+}
+
//=======================================================================
//function : ExtrusionSweepObject1DMakeGroups
//purpose :
anEditor.Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
if(theCopy || myPreviewMode)
- storeResult(anEditor);
- else
+ storeResult(anEditor); // store preview data or new elements
+
+ if ( !myPreviewMode )
{
- myMesh->SetIsModified( true );
- myMesh->GetMeshDS()->Modified();
+ if ( theTargetMesh )
+ {
+ theTargetMesh->GetMeshDS()->Modified();
+ }
+ else
+ {
+ myMesh->GetMeshDS()->Modified();
+ myMesh->SetIsModified( true );
+ }
}
return theMakeGroups ? getGroups(groupIds.get()) : 0;
}
if(theCopy || myPreviewMode)
storeResult(anEditor);
- else
+
+ if ( !myPreviewMode )
{
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true );
+ if ( theTargetMesh )
+ {
+ theTargetMesh->GetMeshDS()->Modified();
+ }
+ else
+ {
+ myMesh->GetMeshDS()->Modified();
+ myMesh->SetIsModified( true );
+ }
}
return theMakeGroups ? getGroups(groupIds.get()) : 0;
if(theCopy || myPreviewMode)
storeResult(anEditor);
- else
+
+ if ( !myPreviewMode )
{
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true );
+ if ( theTargetMesh )
+ {
+ theTargetMesh->GetMeshDS()->Modified();
+ }
+ else
+ {
+ myMesh->GetMeshDS()->Modified();
+ myMesh->SetIsModified( true );
+ }
}
return theMakeGroups ? getGroups(groupIds.get()) : 0;
if(theCopy || myPreviewMode )
storeResult(anEditor);
- else
+
+ if ( !myPreviewMode )
{
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true );
+ if ( theTargetMesh )
+ {
+ theTargetMesh->GetMeshDS()->Modified();
+ }
+ else
+ {
+ myMesh->GetMeshDS()->Modified();
+ myMesh->SetIsModified( true );
+ }
}
+
return theMakeGroups ? getGroups(groupIds.get()) : 0;
}
::SMESH_MeshEditor anEditor( myMesh );
anEditor.MergeEqualElements();
+ myMesh->GetMeshDS()->Modified();
+
TPythonDump() << this << ".MergeEqualElements()";
}
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodesOnGroupBoundaries( const SMESH::ListOfGroups& theDomains,
CORBA::Boolean createJointElems )
+ throw (SALOME::SALOME_Exception)
{
initData();
for ( int i = 0, n = theDomains.length(); i < n; i++ )
{
SMESH::SMESH_GroupBase_var aGrp = theDomains[ i ];
- if ( !CORBA::is_nil( aGrp ) && ( aGrp->GetType() != SMESH::NODE ) )
+ if ( !CORBA::is_nil( aGrp ) /*&& ( aGrp->GetType() != SMESH::NODE )*/ )
{
+// if ( aGrp->GetType() != SMESH::VOLUME )
+// THROW_SALOME_CORBA_EXCEPTION("Not a volume group", SALOME::BAD_PARAM);
TIDSortedElemSet domain;
domain.clear();
domains.push_back(domain);
if ( dim > SMESH::BND_1DFROM2D )
THROW_SALOME_CORBA_EXCEPTION("Invalid boundary dimension", SALOME::BAD_PARAM);
- // check that groups belongs to to this mesh and is not this mesh
- const int nbGroups = groups.length();
- for ( int i = 0; i < nbGroups; ++i )
+ // separate groups belonging to this and other mesh
+ SMESH::ListOfIDSources_var groupsOfThisMesh = new SMESH::ListOfIDSources;
+ SMESH::ListOfIDSources_var groupsOfOtherMesh = new SMESH::ListOfIDSources;
+ groupsOfThisMesh->length( groups.length() );
+ groupsOfOtherMesh->length( groups.length() );
+ int nbGroups = 0, nbGroupsOfOtherMesh = 0;
+ for ( int i = 0; i < groups.length(); ++i )
{
SMESH::SMESH_Mesh_var m = groups[i]->GetMesh();
if ( myMesh_i != SMESH::DownCast<SMESH_Mesh_i*>( m ))
- THROW_SALOME_CORBA_EXCEPTION("group does not belong to this mesh", SALOME::BAD_PARAM);
+ groupsOfOtherMesh[ nbGroupsOfOtherMesh++ ] = groups[i];
+ else
+ groupsOfThisMesh[ nbGroups++ ] = groups[i];
if ( SMESH::DownCast<SMESH_Mesh_i*>( groups[i] ))
THROW_SALOME_CORBA_EXCEPTION("expect a group but recieve a mesh", SALOME::BAD_PARAM);
}
+ groupsOfThisMesh->length( nbGroups );
+ groupsOfOtherMesh->length( nbGroupsOfOtherMesh );
+ int nbAdded = 0;
TPythonDump pyDump;
- int nbAdded = 0;
+ if ( nbGroupsOfOtherMesh > 0 )
+ {
+ // process groups belonging to another mesh
+ SMESH::SMESH_Mesh_var otherMesh = groupsOfOtherMesh[0]->GetMesh();
+ SMESH::SMESH_MeshEditor_var editor = otherMesh->GetMeshEditor();
+ nbAdded += editor->MakeBoundaryElements( dim, groupName, meshName, toCopyAll,
+ groupsOfOtherMesh, mesh, group );
+ }
+
SMESH::SMESH_Mesh_var mesh_var;
SMESH::SMESH_Group_var group_var;
TIDSortedElemSet elements;
- if ( nbGroups > 0 )
+ if ( groups.length() > 0 )
{
for ( int i = 0; i < nbGroups; ++i )
{
elements.clear();
- if ( idSourceToSet( groups[i], srcMeshDS, elements, elemType,/*emptyIfIsMesh=*/false ))
+ if ( idSourceToSet( groupsOfThisMesh[i], srcMeshDS, elements, elemType,/*emptyIfIsMesh=*/0 ))
{
SMESH::Bnd_Dimension bdim =
( elemType == SMDSAbs_Volume ) ? SMESH::BND_2DFROM3D : SMESH::BND_1DFROM2D;
