#include "SMESH_MeshEditor_i.hxx"
-#include "SMDS_Mesh0DElement.hxx"
#include "SMDS_LinearEdge.hxx"
+#include "SMDS_Mesh0DElement.hxx"
#include "SMDS_MeshFace.hxx"
#include "SMDS_MeshVolume.hxx"
#include "SMDS_PolyhedralVolumeOfNodes.hxx"
-#include "SMESH_subMeshEventListener.hxx"
-#include "SMESH_Gen_i.hxx"
+#include "SMDS_SetIterator.hxx"
+#include "SMESHDS_Group.hxx"
+#include "SMESH_ControlsDef.hxx"
#include "SMESH_Filter_i.hxx"
-#include "SMESH_subMesh_i.hxx"
+#include "SMESH_Gen_i.hxx"
#include "SMESH_Group_i.hxx"
#include "SMESH_PythonDump.hxx"
-#include "SMESH_ControlsDef.hxx"
+#include "SMESH_subMeshEventListener.hxx"
+#include "SMESH_subMesh_i.hxx"
#include "utilities.h"
#include "Utils_ExceptHandlers.hxx"
using namespace std;
using SMESH::TPythonDump;
+using SMESH::TVar;
namespace {
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 );
}
}
struct TSearchersDeleter : public SMESH_subMeshEventListener
{
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()
}
}
//!< set self on all submeshes and delete theNodeSearcher if other mesh is set
- void Set(SMESH_Mesh* mesh)
+ void Set(SMESH_Mesh* mesh, const string& meshPartIOR = string())
{
- if ( myMesh != mesh )
+ if ( myMesh != mesh || myMeshPartIOR != meshPartIOR)
{
if ( myMesh ) {
Delete();
Unset( myMesh );
}
myMesh = mesh;
+ myMeshPartIOR = meshPartIOR;
if ( SMESH_subMesh* myMainSubMesh = mesh->GetSubMeshContaining(1) ) {
const TDependsOnMap & subMeshes = myMainSubMesh->DependsOn();
TDependsOnMap::const_iterator sm;
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;
}
//=============================================================================
// Update Python script
TPythonDump() << "nodeID = " << this << ".AddNode( "
- << x << ", " << y << ", " << z << " )";
+ << TVar( x ) << ", " << TVar( y ) << ", " << TVar( z )<< " )";
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true ); // issue 0020693
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
// Update Python script
TPythonDump() << "isDone = " << this << ".TriToQuad( "
- << IDsOfElements << ", " << aNumericalFunctor << ", " << MaxAngle << " )";
+ << IDsOfElements << ", " << aNumericalFunctor << ", " << TVar( MaxAngle ) << " )";
::SMESH_MeshEditor anEditor( myMesh );
// Update Python script
aTPythonDump << "isDone = " << this << ".TriToQuadObject("
- << theObject << ", " << aNumericalFunctor << ", " << MaxAngle << " )";
+ << theObject << ", " << aNumericalFunctor << ", " << TVar( MaxAngle ) << " )";
return isDone;
}
TPythonDump() << "isDone = " << this << "."
<< (IsParametric ? "SmoothParametric( " : "Smooth( ")
<< IDsOfElements << ", " << IDsOfFixedNodes << ", "
- << MaxNbOfIterations << ", " << MaxAspectRatio << ", "
+ << TVar( MaxNbOfIterations ) << ", " << TVar( MaxAspectRatio ) << ", "
<< "SMESH.SMESH_MeshEditor."
<< ( Method == SMESH::SMESH_MeshEditor::CENTROIDAL_SMOOTH ?
"CENTROIDAL_SMOOTH )" : "LAPLACIAN_SMOOTH )");
aTPythonDump << "isDone = " << this << "."
<< (IsParametric ? "SmoothParametricObject( " : "SmoothObject( ")
<< theObject << ", " << IDsOfFixedNodes << ", "
- << MaxNbOfIterations << ", " << MaxAspectRatio << ", "
+ << TVar( MaxNbOfIterations ) << ", " << TVar( MaxAspectRatio ) << ", "
<< "SMESH.SMESH_MeshEditor."
<< ( Method == SMESH::SMESH_MeshEditor::CENTROIDAL_SMOOTH ?
"CENTROIDAL_SMOOTH )" : "LAPLACIAN_SMOOTH )");
{
if ( !myPreviewMode ) {
TPythonDump() << this << ".RotationSweep( "
- << theIDsOfElements << ", "
- << theAxis << ", "
- << theAngleInRadians << ", "
- << theNbOfSteps << ", "
- << theTolerance << " )";
+ << theIDsOfElements << ", "
+ << theAxis << ", "
+ << TVar( theAngleInRadians ) << ", "
+ << TVar( theNbOfSteps ) << ", "
+ << TVar( theTolerance ) << " )";
}
rotationSweep(theIDsOfElements,
theAxis,
if (!myPreviewMode) {
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".RotationSweepMakeGroups( "
- << theIDsOfElements << ", "
- << theAxis << ", "
- << theAngleInRadians << ", "
- << theNbOfSteps << ", "
- << theTolerance << " )";
+ << theIDsOfElements << ", "
+ << theAxis << ", "
+ << TVar( theAngleInRadians ) << ", "
+ << TVar( theNbOfSteps ) << ", "
+ << TVar( theTolerance ) << " )";
}
return aGroups;
}
{
if ( !myPreviewMode ) {
TPythonDump() << this << ".RotationSweepObject1D( "
- << theObject << ", "
- << theAxis << ", "
- << theAngleInRadians << ", "
- << theNbOfSteps << ", "
- << theTolerance << " )";
+ << theObject << ", "
+ << theAxis << ", "
+ << TVar( theAngleInRadians ) << ", "
+ << TVar( theNbOfSteps ) << ", "
+ << TVar( theTolerance ) << " )";
}
SMESH::long_array_var anElementsId = theObject->GetIDs();
rotationSweep(anElementsId,
{
if ( !myPreviewMode ) {
TPythonDump() << this << ".RotationSweepObject2D( "
- << theObject << ", "
- << theAxis << ", "
- << theAngleInRadians << ", "
- << theNbOfSteps << ", "
- << theTolerance << " )";
+ << theObject << ", "
+ << theAxis << ", "
+ << TVar( theAngleInRadians ) << ", "
+ << TVar( theNbOfSteps ) << ", "
+ << TVar( theTolerance ) << " )";
}
SMESH::long_array_var anElementsId = theObject->GetIDs();
rotationSweep(anElementsId,
if (!myPreviewMode) {
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".RotationSweepObject1DMakeGroups( "
- << theObject << ", "
- << theAxis << ", "
- << theAngleInRadians << ", "
- << theNbOfSteps << ", "
- << theTolerance << " )";
+ << theObject << ", "
+ << theAxis << ", "
+ << TVar( theAngleInRadians ) << ", "
+ << TVar( theNbOfSteps ) << ", "
+ << TVar( theTolerance ) << " )";
}
return aGroups;
}
if (!myPreviewMode) {
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".RotationSweepObject2DMakeGroups( "
- << theObject << ", "
- << theAxis << ", "
- << theAngleInRadians << ", "
- << theNbOfSteps << ", "
- << theTolerance << " )";
+ << theObject << ", "
+ << theAxis << ", "
+ << TVar( theAngleInRadians ) << ", "
+ << TVar( theNbOfSteps ) << ", "
+ << TVar( theTolerance ) << " )";
}
return aGroups;
}
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();
extrusionSweep (theIDsOfElements, theStepVector, theNbOfSteps, false );
if (!myPreviewMode) {
TPythonDump() << this << ".ExtrusionSweep( "
- << theIDsOfElements << ", " << theStepVector <<", " << theNbOfSteps << " )";
+ << theIDsOfElements << ", " << theStepVector <<", " << TVar(theNbOfSteps) << " )";
}
}
+//=======================================================================
+//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 <<", " << TVar(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 << ", " << TVar( theNbOfSteps ) << " )";
+ }
+}
+
//=======================================================================
//function : ExtrusionSweepObject1D
//purpose :
extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false, SMDSAbs_Edge );
if ( !myPreviewMode ) {
TPythonDump() << this << ".ExtrusionSweepObject1D( "
- << theObject << ", " << theStepVector << ", " << theNbOfSteps << " )";
+ << theObject << ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
}
}
extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false, SMDSAbs_Face );
if ( !myPreviewMode ) {
TPythonDump() << this << ".ExtrusionSweepObject2D( "
- << theObject << ", " << theStepVector << ", " << theNbOfSteps << " )";
+ << theObject << ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
}
}
if (!myPreviewMode) {
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".ExtrusionSweepMakeGroups( " << theIDsOfElements
- << ", " << theStepVector <<", " << theNbOfSteps << " )";
+ << ", " << theStepVector <<", " << TVar( theNbOfSteps ) << " )";
+ }
+ return aGroups;
+}
+
+//=======================================================================
+//function : ExtrusionSweepMakeGroups0D
+//purpose :
+//=======================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::ExtrusionSweepMakeGroups0D(const SMESH::long_array& theIDsOfElements,
+ const SMESH::DirStruct& theStepVector,
+ CORBA::Long theNbOfSteps)
+{
+ 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 <<", " << TVar( theNbOfSteps ) << " )";
}
return aGroups;
}
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 << ", " << TVar( theNbOfSteps ) << " )";
+ }
+ return aGroups;
+}
+
//=======================================================================
//function : ExtrusionSweepObject1DMakeGroups
//purpose :
if (!myPreviewMode) {
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".ExtrusionSweepObject1DMakeGroups( " << theObject
- << ", " << theStepVector << ", " << theNbOfSteps << " )";
+ << ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
}
return aGroups;
}
if (!myPreviewMode) {
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".ExtrusionSweepObject2DMakeGroups( " << theObject
- << ", " << theStepVector << ", " << theNbOfSteps << " )";
+ << ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
}
return aGroups;
}
aPythonDump << "error";
aPythonDump << " = " << this << ".ExtrusionAlongPathObjX( "
- << Object << ", "
- << Path << ", "
- << NodeStart << ", "
- << HasAngles << ", "
- << Angles << ", "
+ << Object << ", "
+ << Path << ", "
+ << NodeStart << ", "
+ << HasAngles << ", "
+ << TVar( Angles ) << ", "
<< LinearVariation << ", "
- << HasRefPoint << ", "
+ << HasRefPoint << ", "
<< "SMESH.PointStruct( "
- << ( HasRefPoint ? RefPoint.x : 0 ) << ", "
- << ( HasRefPoint ? RefPoint.y : 0 ) << ", "
- << ( HasRefPoint ? RefPoint.z : 0 ) << " ), "
+ << TVar( HasRefPoint ? RefPoint.x : 0 ) << ", "
+ << TVar( HasRefPoint ? RefPoint.y : 0 ) << ", "
+ << TVar( HasRefPoint ? RefPoint.z : 0 ) << " ), "
<< MakeGroups << ", "
<< ElemType << " )";
}
aPythonDump <<"error";
aPythonDump << " = " << this << ".ExtrusionAlongPathX( "
- << IDsOfElements << ", "
- << Path << ", "
- << NodeStart << ", "
- << HasAngles << ", "
- << Angles << ", "
+ << IDsOfElements << ", "
+ << Path << ", "
+ << NodeStart << ", "
+ << HasAngles << ", "
+ << TVar( Angles ) << ", "
<< LinearVariation << ", "
- << HasRefPoint << ", "
+ << HasRefPoint << ", "
<< "SMESH.PointStruct( "
- << ( HasRefPoint ? RefPoint.x : 0 ) << ", "
- << ( HasRefPoint ? RefPoint.y : 0 ) << ", "
- << ( HasRefPoint ? RefPoint.z : 0 ) << " ), "
+ << TVar( HasRefPoint ? RefPoint.x : 0 ) << ", "
+ << TVar( HasRefPoint ? RefPoint.y : 0 ) << ", "
+ << TVar( HasRefPoint ? RefPoint.z : 0 ) << " ), "
<< MakeGroups << ", "
<< ElemType << " )";
}
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 ( !myPreviewMode ) {
TPythonDump() << this << ".Mirror( "
- << theIDsOfElements << ", "
- << theAxis << ", "
+ << theIDsOfElements << ", "
+ << theAxis << ", "
<< mirrorTypeName(theMirrorType) << ", "
- << theCopy << " )";
+ << theCopy << " )";
}
if ( theIDsOfElements.length() > 0 )
{
{
if ( !myPreviewMode ) {
TPythonDump() << this << ".MirrorObject( "
- << theObject << ", "
- << theAxis << ", "
+ << theObject << ", "
+ << theAxis << ", "
<< mirrorTypeName(theMirrorType) << ", "
- << theCopy << " )";
+ << theCopy << " )";
}
TIDSortedElemSet elements;
if (!myPreviewMode) {
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".MirrorMakeGroups( "
- << theIDsOfElements << ", "
- << theMirror << ", "
+ << theIDsOfElements << ", "
+ << theMirror << ", "
<< mirrorTypeName(theMirrorType) << " )";
}
return aGroups;
{
DumpGroupsList(aPythonDump,aGroups);
aPythonDump << this << ".MirrorObjectMakeGroups( "
- << theObject << ", "
- << theMirror << ", "
+ << theObject << ", "
+ << theMirror << ", "
<< mirrorTypeName(theMirrorType) << " )";
}
return aGroups;
if (!myPreviewMode) {
pydump << mesh << " = " << this << ".MirrorMakeMesh( "
- << theIDsOfElements << ", "
- << theMirror << ", "
+ << theIDsOfElements << ", "
+ << theMirror << ", "
<< mirrorTypeName(theMirrorType) << ", "
- << theCopyGroups << ", '"
- << theMeshName << "' )";
+ << theCopyGroups << ", '"
+ << theMeshName << "' )";
}
}
}
if (!myPreviewMode) {
pydump << mesh << " = " << this << ".MirrorObjectMakeMesh( "
- << theObject << ", "
- << theMirror << ", "
+ << theObject << ", "
+ << theMirror << ", "
<< mirrorTypeName(theMirrorType) << ", "
- << theCopyGroups << ", '"
- << theMeshName << "' )";
+ << theCopyGroups << ", '"
+ << theMeshName << "' )";
}
}
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 (!myPreviewMode) {
TPythonDump() << this << ".Translate( "
<< theIDsOfElements << ", "
- << theVector << ", "
- << theCopy << " )";
+ << theVector << ", "
+ << theCopy << " )";
}
if (theIDsOfElements.length()) {
TIDSortedElemSet elements;
TPythonDump() << this << ".TranslateObject( "
<< theObject << ", "
<< theVector << ", "
- << theCopy << " )";
+ << theCopy << " )";
}
TIDSortedElemSet elements;
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".TranslateMakeGroups( "
<< theIDsOfElements << ", "
- << theVector << " )";
+ << theVector << " )";
}
return aGroups;
}
if ( !myPreviewMode ) {
pydump << mesh << " = " << this << ".TranslateMakeMesh( "
<< theIDsOfElements << ", "
- << theVector << ", "
- << theCopyGroups << ", '"
- << theMeshName << "' )";
+ << theVector << ", "
+ << theCopyGroups << ", '"
+ << theMeshName << "' )";
}
}
}
if ( !myPreviewMode ) {
pydump << mesh << " = " << this << ".TranslateObjectMakeMesh( "
- << theObject << ", "
- << theVector << ", "
+ << theObject << ", "
+ << theVector << ", "
<< theCopyGroups << ", '"
- << theMeshName << "' )";
+ << theMeshName << "' )";
}
}
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 (!myPreviewMode) {
TPythonDump() << this << ".Rotate( "
<< theIDsOfElements << ", "
- << theAxis << ", "
- << theAngle << ", "
- << theCopy << " )";
+ << theAxis << ", "
+ << TVar( theAngle ) << ", "
+ << theCopy << " )";
}
if (theIDsOfElements.length() > 0)
{
{
if ( !myPreviewMode ) {
TPythonDump() << this << ".RotateObject( "
- << theObject << ", "
- << theAxis << ", "
- << theAngle << ", "
- << theCopy << " )";
+ << theObject << ", "
+ << theAxis << ", "
+ << TVar( theAngle ) << ", "
+ << theCopy << " )";
}
TIDSortedElemSet elements;
bool emptyIfIsMesh = myPreviewMode ? false : true;
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".RotateMakeGroups( "
<< theIDsOfElements << ", "
- << theAxis << ", "
- << theAngle << " )";
+ << theAxis << ", "
+ << TVar( theAngle ) << " )";
}
return aGroups;
}
if (!myPreviewMode) {
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".RotateObjectMakeGroups( "
- << theObject << ", "
- << theAxis << ", "
- << theAngle << " )";
+ << theObject << ", "
+ << theAxis << ", "
+ << TVar( theAngle ) << " )";
}
return aGroups;
}
}
if ( !myPreviewMode ) {
pydump << mesh << " = " << this << ".RotateMakeMesh( "
- << theIDsOfElements << ", "
- << theAxis << ", "
- << theAngleInRadians << ", "
- << theCopyGroups << ", '"
- << theMeshName << "' )";
+ << theIDsOfElements << ", "
+ << theAxis << ", "
+ << TVar( theAngleInRadians ) << ", "
+ << theCopyGroups << ", '"
+ << theMeshName << "' )";
}
}
}
if ( !myPreviewMode ) {
pydump << mesh << " = " << this << ".RotateObjectMakeMesh( "
- << theObject << ", "
- << theAxis << ", "
- << theAngleInRadians << ", "
- << theCopyGroups << ", '"
- << theMeshName << "' )";
+ << theObject << ", "
+ << theAxis << ", "
+ << TVar( theAngleInRadians ) << ", "
+ << theCopyGroups << ", '"
+ << theMeshName << "' )";
}
}
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 ( !myPreviewMode ) {
TPythonDump() << this << ".Scale( "
- << theObject << ", "
- << "SMESH.PointStruct( " << thePoint.x << ", "
- << thePoint.y << ", " << thePoint.z << " ) ,"
- << theScaleFact << ", "
- << theCopy << " )";
+ << theObject << ", "
+ << thePoint << ", "
+ << TVar( theScaleFact ) << ", "
+ << theCopy << " )";
}
scale(theObject, thePoint, theScaleFact, theCopy, false);
}
if (!myPreviewMode) {
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".Scale("
- << theObject << ","
- << "SMESH.PointStruct(" <<thePoint.x << ","
- << thePoint.y << "," << thePoint.z << "),"
- << theScaleFact << ",True,True)";
+ << theObject << ","
+ << thePoint << ","
+ << TVar( theScaleFact ) << ",True,True)";
}
return aGroups;
}
}
if ( !myPreviewMode )
pydump << mesh << " = " << this << ".ScaleMakeMesh( "
- << theObject << ", "
- << "SMESH.PointStruct( " << thePoint.x << ", "
- << thePoint.y << ", " << thePoint.z << " ) ,"
- << theScaleFact << ", "
- << theCopyGroups << ", '"
- << theMeshName << "' )";
+ << theObject << ", "
+ << thePoint << ", "
+ << TVar( theScaleFact ) << ", "
+ << theCopyGroups << ", '"
+ << theMeshName << "' )";
}
// dump "GetGroups"
::SMESH_MeshEditor anEditor( myMesh );
anEditor.MergeEqualElements();
+ myMesh->GetMeshDS()->Modified();
+
TPythonDump() << this << ".MergeEqualElements()";
}
{
// Update Python script
TPythonDump() << "isDone = " << this << ".MoveNode( "
- << NodeID << ", " << x << ", " << y << ", " << z << " )";
+ << NodeID << ", " << TVar(x) << ", " << TVar(y) << ", " << TVar(z) << " )";
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
}
res[i] = foundElems[i]->GetID();
if ( !myPreviewMode ) // call from tui
- TPythonDump() << res << " = " << this << ".FindElementsByPoint( "
+ TPythonDump() << "res = " << this << ".FindElementsByPoint( "
<< x << ", "
<< y << ", "
<< z << ", "
return res._retn();
}
+//=======================================================================
+//function : FindAmongElementsByPoint
+//purpose : Searching among the given elements, return elements of given type
+// where the given point is IN or ON.
+// 'ALL' type means elements of any type excluding nodes
+//=======================================================================
+
+SMESH::long_array*
+SMESH_MeshEditor_i::FindAmongElementsByPoint(SMESH::SMESH_IDSource_ptr elementIDs,
+ CORBA::Double x,
+ CORBA::Double y,
+ CORBA::Double z,
+ SMESH::ElementType type)
+{
+ SMESH::long_array_var res = new SMESH::long_array;
+
+ SMESH::array_of_ElementType_var types = elementIDs->GetTypes();
+ if ( types->length() == 1 && // a part contains only nodes or 0D elements
+ ( types[0] == SMESH::NODE || types[0] == SMESH::ELEM0D ) &&
+ type != types[0] ) // but search of elements of dim > 0
+ return res._retn();
+
+ if ( SMESH::DownCast<SMESH_Mesh_i*>( elementIDs )) // elementIDs is the whole mesh
+ return FindElementsByPoint( x,y,z, type );
+
+ string partIOR = SMESH_Gen_i::GetORB()->object_to_string( elementIDs );
+ if ( SMESH_Group_i* group_i = SMESH::DownCast<SMESH_Group_i*>( elementIDs ))
+ // take into account passible group modification
+ partIOR += SMESH_Comment( ((SMESHDS_Group*)group_i->GetGroupDS())->SMDSGroup().Tic() );
+ partIOR += SMESH_Comment( type );
+
+ TIDSortedElemSet elements; // elems should live until FindElementsByPoint() finishes
+
+ theSearchersDeleter.Set( myMesh, partIOR );
+ if ( !theElementSearcher )
+ {
+ // create a searcher from elementIDs
+ SMESH::SMESH_Mesh_var mesh = elementIDs->GetMesh();
+ SMESHDS_Mesh* meshDS = SMESH::DownCast<SMESH_Mesh_i*>( mesh )->GetImpl().GetMeshDS();
+
+ if ( !idSourceToSet( elementIDs, meshDS, elements,
+ SMDSAbs_ElementType(type), /*emptyIfIsMesh=*/true))
+ return res._retn();
+
+ typedef SMDS_SetIterator<const SMDS_MeshElement*, TIDSortedElemSet::const_iterator > TIter;
+ SMDS_ElemIteratorPtr elemsIt( new TIter( elements.begin(), elements.end() ));
+
+ ::SMESH_MeshEditor anEditor( myMesh );
+ theElementSearcher = anEditor.GetElementSearcher(elemsIt);
+ }
+
+ vector< const SMDS_MeshElement* > foundElems;
+
+ theElementSearcher->FindElementsByPoint( gp_Pnt( x,y,z ),
+ SMDSAbs_ElementType( type ),
+ foundElems);
+ res->length( foundElems.size() );
+ for ( int i = 0; i < foundElems.size(); ++i )
+ res[i] = foundElems[i]->GetID();
+
+ if ( !myPreviewMode ) // call from tui
+ TPythonDump() << "res = " << this << ".FindAmongElementsByPoint( "
+ << elementIDs << ", "
+ << x << ", "
+ << y << ", "
+ << z << ", "
+ << type << " )";
+
+ return res._retn();
+
+}
//=======================================================================
//function : GetPointState
//purpose : Return point state in a closed 2D mesh in terms of TopAbs_State enumeration.
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;
