X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSMESH_I%2FSMESH_MeshEditor_i.cxx;h=f4e1d4420f4826a251f782476403eaa46240a8db;hb=00ee13aec2a8c5cb48335d7a62ff3699e542c103;hp=428aacbc94226da6a95b418ae3270d0fb4d239d8;hpb=4592fecfcf7f19fbb7650f63c49947e0ac9b108b;p=modules%2Fsmesh.git diff --git a/src/SMESH_I/SMESH_MeshEditor_i.cxx b/src/SMESH_I/SMESH_MeshEditor_i.cxx index 428aacbc9..f4e1d4420 100644 --- a/src/SMESH_I/SMESH_MeshEditor_i.cxx +++ b/src/SMESH_I/SMESH_MeshEditor_i.cxx @@ -149,24 +149,26 @@ namespace { } };// struct TPreviewMesh - static SMESH_NodeSearcher * myNodeSearcher = 0; + static SMESH_NodeSearcher * theNodeSearcher = 0; + static SMESH_ElementSearcher * theElementSearcher = 0; //============================================================================= /*! - * \brief Deleter of myNodeSearcher at any compute event occured + * \brief Deleter of theNodeSearcher at any compute event occured */ //============================================================================= - struct TNodeSearcherDeleter : public SMESH_subMeshEventListener + struct TSearchersDeleter : public SMESH_subMeshEventListener { SMESH_Mesh* myMesh; //!< Constructor - TNodeSearcherDeleter(): SMESH_subMeshEventListener( false ), // won't be deleted by submesh - myMesh(0) {} - //!< Delete myNodeSearcher + TSearchersDeleter(): SMESH_subMeshEventListener( false ), // won't be deleted by submesh + myMesh(0) {} + //!< Delete theNodeSearcher static void Delete() { - if ( myNodeSearcher ) { delete myNodeSearcher; myNodeSearcher = 0; } + if ( theNodeSearcher ) delete theNodeSearcher; theNodeSearcher = 0; + if ( theElementSearcher ) delete theElementSearcher; theElementSearcher = 0; } typedef map < int, SMESH_subMesh * > TDependsOnMap; //!< The meshod called by submesh: do my main job @@ -178,19 +180,22 @@ namespace { Unset( sm->GetFather() ); } } - //!< set self on all submeshes and delete myNodeSearcher if other mesh is set + //!< set self on all submeshes and delete theNodeSearcher if other mesh is set void Set(SMESH_Mesh* mesh) { - if ( myMesh && myMesh != mesh ) { - Delete(); - Unset( myMesh ); - } - myMesh = mesh; - if ( SMESH_subMesh* myMainSubMesh = mesh->GetSubMeshContaining(1) ) { - const TDependsOnMap & subMeshes = myMainSubMesh->DependsOn(); - TDependsOnMap::const_iterator sm; - for (sm = subMeshes.begin(); sm != subMeshes.end(); sm++) - sm->second->SetEventListener( this, 0, sm->second ); + if ( myMesh != mesh ) + { + if ( myMesh ) { + Delete(); + Unset( myMesh ); + } + myMesh = mesh; + if ( SMESH_subMesh* myMainSubMesh = mesh->GetSubMeshContaining(1) ) { + const TDependsOnMap & subMeshes = myMainSubMesh->DependsOn(); + TDependsOnMap::const_iterator sm; + for (sm = subMeshes.begin(); sm != subMeshes.end(); sm++) + sm->second->SetEventListener( this, 0, sm->second ); + } } } //!< delete self from all submeshes @@ -204,7 +209,8 @@ namespace { } myMesh = 0; } - }; + + } theSearchersDeleter; TCollection_AsciiString mirrorTypeName( SMESH::SMESH_MeshEditor::MirrorType theMirrorType ) { @@ -252,7 +258,7 @@ SMESH_MeshEditor_i::~SMESH_MeshEditor_i() */ //================================================================================ -void SMESH_MeshEditor_i::initData() +void SMESH_MeshEditor_i::initData(bool deleteSearchers) { if ( myPreviewMode ) { myPreviewData = new SMESH::MeshPreviewStruct(); @@ -260,7 +266,8 @@ void SMESH_MeshEditor_i::initData() else { myLastCreatedElems = new SMESH::long_array(); myLastCreatedNodes = new SMESH::long_array(); - TNodeSearcherDeleter::Delete(); + if ( deleteSearchers ) + TSearchersDeleter::Delete(); } } @@ -271,7 +278,7 @@ void SMESH_MeshEditor_i::initData() //============================================================================= CORBA::Boolean - SMESH_MeshEditor_i::RemoveElements(const SMESH::long_array & IDsOfElements) +SMESH_MeshEditor_i::RemoveElements(const SMESH::long_array & IDsOfElements) { initData(); @@ -430,6 +437,9 @@ CORBA::Long SMESH_MeshEditor_i::AddFace(const SMESH::long_array & IDsOfNodes) elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5], nodes[6], nodes[7]); } + else if (NbNodes > 2) { + elem = GetMeshDS()->AddPolygonalFace(nodes); + } // Update Python script TPythonDump() << "faceID = " << this << ".AddFace( " << IDsOfNodes << " )"; @@ -445,8 +455,7 @@ CORBA::Long SMESH_MeshEditor_i::AddFace(const SMESH::long_array & IDsOfNodes) * AddPolygonalFace */ //============================================================================= -CORBA::Long SMESH_MeshEditor_i::AddPolygonalFace - (const SMESH::long_array & IDsOfNodes) +CORBA::Long SMESH_MeshEditor_i::AddPolygonalFace (const SMESH::long_array & IDsOfNodes) { initData(); @@ -456,7 +465,7 @@ CORBA::Long SMESH_MeshEditor_i::AddPolygonalFace nodes[i] = GetMeshDS()->FindNode(IDsOfNodes[i]); const SMDS_MeshElement* elem = GetMeshDS()->AddPolygonalFace(nodes); - + // Update Python script TPythonDump() <<"faceID = "<SetMeshElementOnShape( elem, ShapeID ); } - -//============================================================================= -/*! - * - */ -//============================================================================= - -CORBA::Boolean SMESH_MeshEditor_i::MoveNode(CORBA::Long NodeID, - CORBA::Double x, - CORBA::Double y, - CORBA::Double z) -{ - initData(); - - const SMDS_MeshNode * node = GetMeshDS()->FindNode( NodeID ); - if ( !node ) - return false; - - GetMeshDS()->MoveNode(node, x, y, z); - - // Update Python script - TPythonDump() << "isDone = " << this << ".MoveNode( " - << NodeID << ", " << x << ", " << y << ", " << z << " )"; - - return true; -} - //============================================================================= /*! * @@ -903,10 +883,10 @@ namespace //================================================================================ /*! * \brief function for conversion long_array to TIDSortedElemSet - * \param IDs - array of IDs - * \param aMesh - mesh - * \param aMap - collection to fill - * \param aType - element type + * \param IDs - array of IDs + * \param aMesh - mesh + * \param aMap - collection to fill + * \param aType - element type */ //================================================================================ @@ -917,7 +897,9 @@ namespace { for (int i=0; iFindElement(ind); + const SMDS_MeshElement * elem = + (aType == SMDSAbs_Node ? aMesh->FindNode(ind) + : aMesh->FindElement(ind)); if ( elem && ( aType == SMDSAbs_All || elem->GetType() == aType )) aMap.insert( elem ); } @@ -1163,14 +1145,14 @@ CORBA::Long SMESH_MeshEditor_i::BestSplit (CORBA::Long IDOfQuad, //======================================================================= CORBA::Boolean - SMESH_MeshEditor_i::Smooth(const SMESH::long_array & IDsOfElements, - const SMESH::long_array & IDsOfFixedNodes, - CORBA::Long MaxNbOfIterations, - CORBA::Double MaxAspectRatio, - SMESH::SMESH_MeshEditor::Smooth_Method Method) +SMESH_MeshEditor_i::Smooth(const SMESH::long_array & IDsOfElements, + const SMESH::long_array & IDsOfFixedNodes, + CORBA::Long MaxNbOfIterations, + CORBA::Double MaxAspectRatio, + SMESH::SMESH_MeshEditor::Smooth_Method Method) { return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations, - MaxAspectRatio, Method, false ); + MaxAspectRatio, Method, false ); } @@ -1180,14 +1162,14 @@ CORBA::Boolean //======================================================================= CORBA::Boolean - SMESH_MeshEditor_i::SmoothParametric(const SMESH::long_array & IDsOfElements, - const SMESH::long_array & IDsOfFixedNodes, - CORBA::Long MaxNbOfIterations, - CORBA::Double MaxAspectRatio, - SMESH::SMESH_MeshEditor::Smooth_Method Method) +SMESH_MeshEditor_i::SmoothParametric(const SMESH::long_array & IDsOfElements, + const SMESH::long_array & IDsOfFixedNodes, + CORBA::Long MaxNbOfIterations, + CORBA::Double MaxAspectRatio, + SMESH::SMESH_MeshEditor::Smooth_Method Method) { return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations, - MaxAspectRatio, Method, true ); + MaxAspectRatio, Method, true ); } @@ -1197,11 +1179,11 @@ CORBA::Boolean //======================================================================= CORBA::Boolean - SMESH_MeshEditor_i::SmoothObject(SMESH::SMESH_IDSource_ptr theObject, - const SMESH::long_array & IDsOfFixedNodes, - CORBA::Long MaxNbOfIterations, - CORBA::Double MaxAspectRatio, - SMESH::SMESH_MeshEditor::Smooth_Method Method) +SMESH_MeshEditor_i::SmoothObject(SMESH::SMESH_IDSource_ptr theObject, + const SMESH::long_array & IDsOfFixedNodes, + CORBA::Long MaxNbOfIterations, + CORBA::Double MaxAspectRatio, + SMESH::SMESH_MeshEditor::Smooth_Method Method) { return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations, MaxAspectRatio, Method, false); @@ -1214,11 +1196,11 @@ CORBA::Boolean //======================================================================= CORBA::Boolean - SMESH_MeshEditor_i::SmoothParametricObject(SMESH::SMESH_IDSource_ptr theObject, - const SMESH::long_array & IDsOfFixedNodes, - CORBA::Long MaxNbOfIterations, - CORBA::Double MaxAspectRatio, - SMESH::SMESH_MeshEditor::Smooth_Method Method) +SMESH_MeshEditor_i::SmoothParametricObject(SMESH::SMESH_IDSource_ptr theObject, + const SMESH::long_array & IDsOfFixedNodes, + CORBA::Long MaxNbOfIterations, + CORBA::Double MaxAspectRatio, + SMESH::SMESH_MeshEditor::Smooth_Method Method) { return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations, MaxAspectRatio, Method, true); @@ -1232,12 +1214,12 @@ CORBA::Boolean //============================================================================= CORBA::Boolean - SMESH_MeshEditor_i::smooth(const SMESH::long_array & IDsOfElements, - const SMESH::long_array & IDsOfFixedNodes, - CORBA::Long MaxNbOfIterations, - CORBA::Double MaxAspectRatio, - SMESH::SMESH_MeshEditor::Smooth_Method Method, - bool IsParametric) +SMESH_MeshEditor_i::smooth(const SMESH::long_array & IDsOfElements, + const SMESH::long_array & IDsOfFixedNodes, + CORBA::Long MaxNbOfIterations, + CORBA::Double MaxAspectRatio, + SMESH::SMESH_MeshEditor::Smooth_Method Method, + bool IsParametric) { initData(); @@ -1352,9 +1334,9 @@ void SMESH_MeshEditor_i::RenumberElements() } //======================================================================= - /*! - * \brief Return groups by their IDs - */ +/*! + * \brief Return groups by their IDs + */ //======================================================================= SMESH::ListOfGroups* SMESH_MeshEditor_i::getGroups(const std::list* groupIDs) @@ -1377,7 +1359,7 @@ SMESH_MeshEditor_i::rotationSweep(const SMESH::long_array & theIDsOfElements, CORBA::Long theNbOfSteps, CORBA::Double theTolerance, const bool theMakeGroups, - const SMDSAbs_ElementType theElementType) + const SMDSAbs_ElementType theElementType) { initData(); @@ -1406,8 +1388,8 @@ SMESH_MeshEditor_i::rotationSweep(const SMESH::long_array & theIDsOfElements, ::SMESH_MeshEditor anEditor( mesh ); ::SMESH_MeshEditor::PGroupIDs groupIds = - anEditor.RotationSweep (*workElements, Ax1, theAngleInRadians, - theNbOfSteps, theTolerance, theMakeGroups, makeWalls); + anEditor.RotationSweep (*workElements, Ax1, theAngleInRadians, + theNbOfSteps, theTolerance, theMakeGroups, makeWalls); storeResult(anEditor); return theMakeGroups ? getGroups(groupIds.get()) : 0; @@ -1477,10 +1459,10 @@ SMESH_MeshEditor_i::RotationSweepMakeGroups(const SMESH::long_array& theIDsOfEle //======================================================================= void SMESH_MeshEditor_i::RotationSweepObject(SMESH::SMESH_IDSource_ptr theObject, - const SMESH::AxisStruct & theAxis, - CORBA::Double theAngleInRadians, - CORBA::Long theNbOfSteps, - CORBA::Double theTolerance) + const SMESH::AxisStruct & theAxis, + CORBA::Double theAngleInRadians, + CORBA::Long theNbOfSteps, + CORBA::Double theTolerance) { if ( !myPreviewMode ) { TPythonDump() << this << ".RotationSweepObject( " @@ -1505,10 +1487,10 @@ void SMESH_MeshEditor_i::RotationSweepObject(SMESH::SMESH_IDSource_ptr theObject //======================================================================= void SMESH_MeshEditor_i::RotationSweepObject1D(SMESH::SMESH_IDSource_ptr theObject, - const SMESH::AxisStruct & theAxis, - CORBA::Double theAngleInRadians, - CORBA::Long theNbOfSteps, - CORBA::Double theTolerance) + const SMESH::AxisStruct & theAxis, + CORBA::Double theAngleInRadians, + CORBA::Long theNbOfSteps, + CORBA::Double theTolerance) { if ( !myPreviewMode ) { TPythonDump() << this << ".RotationSweepObject1D( " @@ -1525,7 +1507,7 @@ void SMESH_MeshEditor_i::RotationSweepObject1D(SMESH::SMESH_IDSource_ptr theObje theNbOfSteps, theTolerance, false, - SMDSAbs_Edge); + SMDSAbs_Edge); } //======================================================================= @@ -1534,10 +1516,10 @@ void SMESH_MeshEditor_i::RotationSweepObject1D(SMESH::SMESH_IDSource_ptr theObje //======================================================================= void SMESH_MeshEditor_i::RotationSweepObject2D(SMESH::SMESH_IDSource_ptr theObject, - const SMESH::AxisStruct & theAxis, - CORBA::Double theAngleInRadians, - CORBA::Long theNbOfSteps, - CORBA::Double theTolerance) + const SMESH::AxisStruct & theAxis, + CORBA::Double theAngleInRadians, + CORBA::Long theNbOfSteps, + CORBA::Double theTolerance) { if ( !myPreviewMode ) { TPythonDump() << this << ".RotationSweepObject2D( " @@ -1554,7 +1536,7 @@ void SMESH_MeshEditor_i::RotationSweepObject2D(SMESH::SMESH_IDSource_ptr theObje theNbOfSteps, theTolerance, false, - SMDSAbs_Face); + SMDSAbs_Face); } //======================================================================= @@ -1581,7 +1563,7 @@ SMESH_MeshEditor_i::RotationSweepObjectMakeGroups(SMESH::SMESH_IDSource_ptr theO DumpGroupsList(aPythonDump,aGroups); aPythonDump<< this << ".RotationSweepObjectMakeGroups( " << theObject << ", " - << theAxis << ", " + << theAxis << ", " << theAngleInRadians << ", " << theNbOfSteps << ", " << theTolerance << " )"; @@ -1596,10 +1578,10 @@ SMESH_MeshEditor_i::RotationSweepObjectMakeGroups(SMESH::SMESH_IDSource_ptr theO SMESH::ListOfGroups* SMESH_MeshEditor_i::RotationSweepObject1DMakeGroups(SMESH::SMESH_IDSource_ptr theObject, - const SMESH::AxisStruct& theAxis, - CORBA::Double theAngleInRadians, - CORBA::Long theNbOfSteps, - CORBA::Double theTolerance) + const SMESH::AxisStruct& theAxis, + CORBA::Double theAngleInRadians, + CORBA::Long theNbOfSteps, + CORBA::Double theTolerance) { SMESH::long_array_var anElementsId = theObject->GetIDs(); SMESH::ListOfGroups *aGroups = rotationSweep(anElementsId, @@ -1608,13 +1590,13 @@ SMESH_MeshEditor_i::RotationSweepObject1DMakeGroups(SMESH::SMESH_IDSource_ptr th theNbOfSteps, theTolerance, true, - SMDSAbs_Edge); + SMDSAbs_Edge); if ( !myPreviewMode ) { TPythonDump aPythonDump; DumpGroupsList(aPythonDump,aGroups); aPythonDump<< this << ".RotationSweepObject1DMakeGroups( " << theObject << ", " - << theAxis << ", " + << theAxis << ", " << theAngleInRadians << ", " << theNbOfSteps << ", " << theTolerance << " )"; @@ -1629,10 +1611,10 @@ SMESH_MeshEditor_i::RotationSweepObject1DMakeGroups(SMESH::SMESH_IDSource_ptr th SMESH::ListOfGroups* SMESH_MeshEditor_i::RotationSweepObject2DMakeGroups(SMESH::SMESH_IDSource_ptr theObject, - const SMESH::AxisStruct& theAxis, - CORBA::Double theAngleInRadians, - CORBA::Long theNbOfSteps, - CORBA::Double theTolerance) + const SMESH::AxisStruct& theAxis, + CORBA::Double theAngleInRadians, + CORBA::Long theNbOfSteps, + CORBA::Double theTolerance) { SMESH::long_array_var anElementsId = theObject->GetIDs(); SMESH::ListOfGroups *aGroups = rotationSweep(anElementsId, @@ -1641,13 +1623,13 @@ SMESH_MeshEditor_i::RotationSweepObject2DMakeGroups(SMESH::SMESH_IDSource_ptr th theNbOfSteps, theTolerance, true, - SMDSAbs_Face); + SMDSAbs_Face); if ( !myPreviewMode ) { TPythonDump aPythonDump; DumpGroupsList(aPythonDump,aGroups); aPythonDump<< this << ".RotationSweepObject2DMakeGroups( " << theObject << ", " - << theAxis << ", " + << theAxis << ", " << theAngleInRadians << ", " << theNbOfSteps << ", " << theTolerance << " )"; @@ -1719,8 +1701,8 @@ void SMESH_MeshEditor_i::ExtrusionSweep(const SMESH::long_array & theIDsOfElemen //======================================================================= void SMESH_MeshEditor_i::ExtrusionSweepObject(SMESH::SMESH_IDSource_ptr theObject, - const SMESH::DirStruct & theStepVector, - CORBA::Long theNbOfSteps) + const SMESH::DirStruct & theStepVector, + CORBA::Long theNbOfSteps) { SMESH::long_array_var anElementsId = theObject->GetIDs(); extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false ); @@ -1775,7 +1757,7 @@ SMESH_MeshEditor_i::ExtrusionSweepMakeGroups(const SMESH::long_array& theIDsOfEl CORBA::Long theNbOfSteps) { SMESH::ListOfGroups* aGroups = extrusionSweep (theIDsOfElements, theStepVector, theNbOfSteps, true ); - + if ( !myPreviewMode ) { TPythonDump aPythonDump; DumpGroupsList(aPythonDump,aGroups); @@ -1796,7 +1778,7 @@ SMESH_MeshEditor_i::ExtrusionSweepObjectMakeGroups(SMESH::SMESH_IDSource_ptr the { SMESH::long_array_var anElementsId = theObject->GetIDs(); SMESH::ListOfGroups * aGroups = extrusionSweep (anElementsId, theStepVector, theNbOfSteps, true ); - + if ( !myPreviewMode ) { TPythonDump aPythonDump; DumpGroupsList(aPythonDump,aGroups); @@ -1822,7 +1804,7 @@ SMESH_MeshEditor_i::ExtrusionSweepObject1DMakeGroups(SMESH::SMESH_IDSource_ptr t TPythonDump aPythonDump; DumpGroupsList(aPythonDump,aGroups); aPythonDump << this << ".ExtrusionSweepObject1DMakeGroups( " - << theObject << ", " << theStepVector << ", " << theNbOfSteps << " )"; + << theObject << ", " << theStepVector << ", " << theNbOfSteps << " )"; } return aGroups; } @@ -1843,7 +1825,7 @@ SMESH_MeshEditor_i::ExtrusionSweepObject2DMakeGroups(SMESH::SMESH_IDSource_ptr t TPythonDump aPythonDump; DumpGroupsList(aPythonDump,aGroups); aPythonDump << this << ".ExtrusionSweepObject2DMakeGroups( " - << theObject << ", " << theStepVector << ", " << theNbOfSteps << " )"; + << theObject << ", " << theStepVector << ", " << theNbOfSteps << " )"; } return aGroups; } @@ -1886,10 +1868,10 @@ SMESH_MeshEditor_i::advancedExtrusion(const SMESH::long_array & theIDsOfElements //======================================================================= void SMESH_MeshEditor_i::AdvancedExtrusion(const SMESH::long_array & theIDsOfElements, - const SMESH::DirStruct & theStepVector, - CORBA::Long theNbOfSteps, - CORBA::Long theExtrFlags, - CORBA::Double theSewTolerance) + const SMESH::DirStruct & theStepVector, + CORBA::Long theNbOfSteps, + CORBA::Long theExtrFlags, + CORBA::Double theSewTolerance) { if ( !myPreviewMode ) { TPythonDump() << "stepVector = " << theStepVector; @@ -1921,12 +1903,12 @@ SMESH_MeshEditor_i::AdvancedExtrusionMakeGroups(const SMESH::long_array& theIDsO CORBA::Double theSewTolerance) { SMESH::ListOfGroups * aGroups = advancedExtrusion( theIDsOfElements, - theStepVector, - theNbOfSteps, - theExtrFlags, - theSewTolerance, - true); - + theStepVector, + theNbOfSteps, + theExtrFlags, + theSewTolerance, + true); + if ( !myPreviewMode ) { TPythonDump() << "stepVector = " << theStepVector; TPythonDump aPythonDump; @@ -1953,13 +1935,13 @@ SMESH_MeshEditor_i::AdvancedExtrusionMakeGroups(const SMESH::long_array& theIDsO static SMESH::SMESH_MeshEditor::Extrusion_Error convExtrError( const::SMESH_MeshEditor::Extrusion_Error e ) { switch ( e ) { - RETCASE( EXTR_OK ); - RETCASE( EXTR_NO_ELEMENTS ); - RETCASE( EXTR_PATH_NOT_EDGE ); - RETCASE( EXTR_BAD_PATH_SHAPE ); - RETCASE( EXTR_BAD_STARTING_NODE ); - RETCASE( EXTR_BAD_ANGLES_NUMBER ); - RETCASE( EXTR_CANT_GET_TANGENT ); + RETCASE( EXTR_OK ); + RETCASE( EXTR_NO_ELEMENTS ); + RETCASE( EXTR_PATH_NOT_EDGE ); + RETCASE( EXTR_BAD_PATH_SHAPE ); + RETCASE( EXTR_BAD_STARTING_NODE ); + RETCASE( EXTR_BAD_ANGLES_NUMBER ); + RETCASE( EXTR_CANT_GET_TANGENT ); } return SMESH::SMESH_MeshEditor::EXTR_OK; } @@ -1981,7 +1963,7 @@ SMESH_MeshEditor_i::extrusionAlongPath(const SMESH::long_array & theIDsOfEleme const SMESH::PointStruct & theRefPoint, const bool theMakeGroups, SMESH::SMESH_MeshEditor::Extrusion_Error & theError, - const SMDSAbs_ElementType theElementType) + const SMDSAbs_ElementType theElementType) { initData(); @@ -2043,16 +2025,16 @@ SMESH_MeshEditor_i::extrusionAlongPath(const SMESH::long_array & theIDsOfEleme SMESH::ListOfGroups* SMESH_MeshEditor_i::extrusionAlongPathX(const SMESH::long_array & IDsOfElements, - SMESH::SMESH_IDSource_ptr Path, - CORBA::Long NodeStart, - CORBA::Boolean HasAngles, - const SMESH::double_array& Angles, - CORBA::Boolean LinearVariation, - CORBA::Boolean HasRefPoint, - const SMESH::PointStruct& RefPoint, - const bool MakeGroups, - const SMDSAbs_ElementType ElementType, - SMESH::SMESH_MeshEditor::Extrusion_Error & Error) + SMESH::SMESH_IDSource_ptr Path, + CORBA::Long NodeStart, + CORBA::Boolean HasAngles, + const SMESH::double_array& Angles, + CORBA::Boolean LinearVariation, + CORBA::Boolean HasRefPoint, + const SMESH::PointStruct& RefPoint, + const bool MakeGroups, + const SMDSAbs_ElementType ElementType, + SMESH::SMESH_MeshEditor::Extrusion_Error & Error) { SMESH::ListOfGroups* EmptyGr = new SMESH::ListOfGroups; @@ -2086,8 +2068,8 @@ SMESH_MeshEditor_i::extrusionAlongPathX(const SMESH::long_array & IDsOfElements return EmptyGr; } error = anEditor.ExtrusionAlongTrack( elements, &(aMeshImp->GetImpl()), aNodeStart, - HasAngles, angles, LinearVariation, - HasRefPoint, refPnt, MakeGroups ); + HasAngles, angles, LinearVariation, + HasRefPoint, refPnt, MakeGroups ); } else { SMESH_subMesh_i* aSubMeshImp = SMESH::DownCast( Path ); @@ -2096,26 +2078,26 @@ SMESH_MeshEditor_i::extrusionAlongPathX(const SMESH::long_array & IDsOfElements SMESH::SMESH_Mesh_ptr aPathMesh = aSubMeshImp->GetFather(); aMeshImp = SMESH::DownCast( aPathMesh ); SMDS_MeshNode* aNodeStart = - (SMDS_MeshNode*)aMeshImp->GetImpl().GetMeshDS()->FindNode(NodeStart); + (SMDS_MeshNode*)aMeshImp->GetImpl().GetMeshDS()->FindNode(NodeStart); if ( !aNodeStart ) { - Error = SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE; - return EmptyGr; + Error = SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE; + return EmptyGr; } SMESH_subMesh* aSubMesh = - aMeshImp->GetImpl().GetSubMeshContaining(aSubMeshImp->GetId()); + aMeshImp->GetImpl().GetSubMeshContaining(aSubMeshImp->GetId()); error = anEditor.ExtrusionAlongTrack( elements, aSubMesh, aNodeStart, - HasAngles, angles, LinearVariation, - HasRefPoint, refPnt, MakeGroups ); + HasAngles, angles, LinearVariation, + HasRefPoint, refPnt, MakeGroups ); } else { SMESH_Group_i* aGroupImp = SMESH::DownCast( Path ); if(aGroupImp) { - // path as group of 1D elements + // path as group of 1D elements } else { - // invalid path - Error = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE; - return EmptyGr; + // invalid path + Error = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE; + return EmptyGr; } } } @@ -2140,14 +2122,14 @@ SMESH_MeshEditor_i::extrusionAlongPathX(const SMESH::long_array & IDsOfElements //======================================================================= SMESH::SMESH_MeshEditor::Extrusion_Error - SMESH_MeshEditor_i::ExtrusionAlongPath(const SMESH::long_array & theIDsOfElements, - SMESH::SMESH_Mesh_ptr thePathMesh, - GEOM::GEOM_Object_ptr thePathShape, - CORBA::Long theNodeStart, - CORBA::Boolean theHasAngles, - const SMESH::double_array & theAngles, - CORBA::Boolean theHasRefPoint, - const SMESH::PointStruct & theRefPoint) +SMESH_MeshEditor_i::ExtrusionAlongPath(const SMESH::long_array & theIDsOfElements, + SMESH::SMESH_Mesh_ptr thePathMesh, + GEOM::GEOM_Object_ptr thePathShape, + CORBA::Long theNodeStart, + CORBA::Boolean theHasAngles, + const SMESH::double_array & theAngles, + CORBA::Boolean theHasRefPoint, + const SMESH::PointStruct & theRefPoint) { if ( !myPreviewMode ) { TPythonDump() << "error = " << this << ".ExtrusionAlongPath( " @@ -2228,13 +2210,13 @@ SMESH_MeshEditor_i::ExtrusionAlongPathObject(SMESH::SMESH_IDSource_ptr theObje SMESH::SMESH_MeshEditor::Extrusion_Error SMESH_MeshEditor_i::ExtrusionAlongPathObject1D(SMESH::SMESH_IDSource_ptr theObject, - SMESH::SMESH_Mesh_ptr thePathMesh, - GEOM::GEOM_Object_ptr thePathShape, - CORBA::Long theNodeStart, - CORBA::Boolean theHasAngles, - const SMESH::double_array & theAngles, - CORBA::Boolean theHasRefPoint, - const SMESH::PointStruct & theRefPoint) + SMESH::SMESH_Mesh_ptr thePathMesh, + GEOM::GEOM_Object_ptr thePathShape, + CORBA::Long theNodeStart, + CORBA::Boolean theHasAngles, + const SMESH::double_array & theAngles, + CORBA::Boolean theHasRefPoint, + const SMESH::PointStruct & theRefPoint) { if ( !myPreviewMode ) { TPythonDump() << "error = " << this << ".ExtrusionAlongPathObject1D( " @@ -2262,7 +2244,7 @@ SMESH_MeshEditor_i::ExtrusionAlongPathObject1D(SMESH::SMESH_IDSource_ptr theOb theRefPoint, false, anError, - SMDSAbs_Edge); + SMDSAbs_Edge); return anError; } @@ -2273,13 +2255,13 @@ SMESH_MeshEditor_i::ExtrusionAlongPathObject1D(SMESH::SMESH_IDSource_ptr theOb SMESH::SMESH_MeshEditor::Extrusion_Error SMESH_MeshEditor_i::ExtrusionAlongPathObject2D(SMESH::SMESH_IDSource_ptr theObject, - SMESH::SMESH_Mesh_ptr thePathMesh, - GEOM::GEOM_Object_ptr thePathShape, - CORBA::Long theNodeStart, - CORBA::Boolean theHasAngles, - const SMESH::double_array & theAngles, - CORBA::Boolean theHasRefPoint, - const SMESH::PointStruct & theRefPoint) + SMESH::SMESH_Mesh_ptr thePathMesh, + GEOM::GEOM_Object_ptr thePathShape, + CORBA::Long theNodeStart, + CORBA::Boolean theHasAngles, + const SMESH::double_array & theAngles, + CORBA::Boolean theHasRefPoint, + const SMESH::PointStruct & theRefPoint) { if ( !myPreviewMode ) { TPythonDump() << "error = " << this << ".ExtrusionAlongPathObject2D( " @@ -2307,7 +2289,7 @@ SMESH_MeshEditor_i::ExtrusionAlongPathObject2D(SMESH::SMESH_IDSource_ptr theOb theRefPoint, false, anError, - SMDSAbs_Face); + SMDSAbs_Face); return anError; } @@ -2328,16 +2310,16 @@ SMESH_MeshEditor_i::ExtrusionAlongPathMakeGroups(const SMESH::long_array& theI const SMESH::PointStruct& theRefPoint, SMESH::SMESH_MeshEditor::Extrusion_Error& Error) { - SMESH::ListOfGroups * aGroups = extrusionAlongPath( theIDsOfElements, - thePathMesh, - thePathShape, - theNodeStart, - theHasAngles, - theAngles, - theHasRefPoint, - theRefPoint, - true, - Error); + SMESH::ListOfGroups * aGroups = extrusionAlongPath( theIDsOfElements, + thePathMesh, + thePathShape, + theNodeStart, + theHasAngles, + theAngles, + theHasRefPoint, + theRefPoint, + true, + Error); if ( !myPreviewMode ) { bool isDumpGroups = aGroups && aGroups->length() > 0; TPythonDump aPythonDump; @@ -2348,7 +2330,7 @@ SMESH_MeshEditor_i::ExtrusionAlongPathMakeGroups(const SMESH::long_array& theI aPythonDump << ", error)"; else aPythonDump <<"error"; - + aPythonDump<<" = "<< this << ".ExtrusionAlongPathMakeGroups( " << theIDsOfElements << ", " << thePathMesh << ", " @@ -2392,7 +2374,7 @@ ExtrusionAlongPathObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject, theRefPoint, true, Error); - + if ( !myPreviewMode ) { bool isDumpGroups = aGroups && aGroups->length() > 0; TPythonDump aPythonDump; @@ -2411,11 +2393,11 @@ ExtrusionAlongPathObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject, << theNodeStart << ", " << theHasAngles << ", " << theAngles << ", " - << theHasRefPoint << ", " - << "SMESH.PointStruct( " - << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", " - << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", " - << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )"; + << theHasRefPoint << ", " + << "SMESH.PointStruct( " + << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", " + << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", " + << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )"; } return aGroups; } @@ -2427,14 +2409,14 @@ ExtrusionAlongPathObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject, SMESH::ListOfGroups* SMESH_MeshEditor_i:: ExtrusionAlongPathObject1DMakeGroups(SMESH::SMESH_IDSource_ptr theObject, - SMESH::SMESH_Mesh_ptr thePathMesh, - GEOM::GEOM_Object_ptr thePathShape, - CORBA::Long theNodeStart, - CORBA::Boolean theHasAngles, - const SMESH::double_array& theAngles, - CORBA::Boolean theHasRefPoint, - const SMESH::PointStruct& theRefPoint, - SMESH::SMESH_MeshEditor::Extrusion_Error& Error) + SMESH::SMESH_Mesh_ptr thePathMesh, + GEOM::GEOM_Object_ptr thePathShape, + CORBA::Long theNodeStart, + CORBA::Boolean theHasAngles, + const SMESH::double_array& theAngles, + CORBA::Boolean theHasRefPoint, + const SMESH::PointStruct& theRefPoint, + SMESH::SMESH_MeshEditor::Extrusion_Error& Error) { SMESH::long_array_var anElementsId = theObject->GetIDs(); SMESH::ListOfGroups * aGroups = extrusionAlongPath( anElementsId, @@ -2447,8 +2429,8 @@ ExtrusionAlongPathObject1DMakeGroups(SMESH::SMESH_IDSource_ptr theObject, theRefPoint, true, Error, - SMDSAbs_Edge); - + SMDSAbs_Edge); + if ( !myPreviewMode ) { bool isDumpGroups = aGroups && aGroups->length() > 0; TPythonDump aPythonDump; @@ -2467,11 +2449,11 @@ ExtrusionAlongPathObject1DMakeGroups(SMESH::SMESH_IDSource_ptr theObject, << theNodeStart << ", " << theHasAngles << ", " << theAngles << ", " - << theHasRefPoint << ", " - << "SMESH.PointStruct( " - << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", " - << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", " - << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )"; + << theHasRefPoint << ", " + << "SMESH.PointStruct( " + << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", " + << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", " + << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )"; } return aGroups; } @@ -2483,14 +2465,14 @@ ExtrusionAlongPathObject1DMakeGroups(SMESH::SMESH_IDSource_ptr theObject, SMESH::ListOfGroups* SMESH_MeshEditor_i:: ExtrusionAlongPathObject2DMakeGroups(SMESH::SMESH_IDSource_ptr theObject, - SMESH::SMESH_Mesh_ptr thePathMesh, - GEOM::GEOM_Object_ptr thePathShape, - CORBA::Long theNodeStart, - CORBA::Boolean theHasAngles, - const SMESH::double_array& theAngles, - CORBA::Boolean theHasRefPoint, - const SMESH::PointStruct& theRefPoint, - SMESH::SMESH_MeshEditor::Extrusion_Error& Error) + SMESH::SMESH_Mesh_ptr thePathMesh, + GEOM::GEOM_Object_ptr thePathShape, + CORBA::Long theNodeStart, + CORBA::Boolean theHasAngles, + const SMESH::double_array& theAngles, + CORBA::Boolean theHasRefPoint, + const SMESH::PointStruct& theRefPoint, + SMESH::SMESH_MeshEditor::Extrusion_Error& Error) { SMESH::long_array_var anElementsId = theObject->GetIDs(); SMESH::ListOfGroups * aGroups = extrusionAlongPath( anElementsId, @@ -2503,8 +2485,8 @@ ExtrusionAlongPathObject2DMakeGroups(SMESH::SMESH_IDSource_ptr theObject, theRefPoint, true, Error, - SMDSAbs_Face); - + SMDSAbs_Face); + if ( !myPreviewMode ) { bool isDumpGroups = aGroups && aGroups->length() > 0; TPythonDump aPythonDump; @@ -2523,11 +2505,11 @@ ExtrusionAlongPathObject2DMakeGroups(SMESH::SMESH_IDSource_ptr theObject, << theNodeStart << ", " << theHasAngles << ", " << theAngles << ", " - << theHasRefPoint << ", " - << "SMESH.PointStruct( " - << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", " - << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", " - << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )"; + << theHasRefPoint << ", " + << "SMESH.PointStruct( " + << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", " + << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", " + << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )"; } return aGroups; } @@ -2539,30 +2521,30 @@ ExtrusionAlongPathObject2DMakeGroups(SMESH::SMESH_IDSource_ptr theObject, //======================================================================= SMESH::ListOfGroups* SMESH_MeshEditor_i:: ExtrusionAlongPathObjX(SMESH::SMESH_IDSource_ptr Object, - SMESH::SMESH_IDSource_ptr Path, - CORBA::Long NodeStart, - CORBA::Boolean HasAngles, - const SMESH::double_array& Angles, - CORBA::Boolean LinearVariation, - CORBA::Boolean HasRefPoint, - const SMESH::PointStruct& RefPoint, - CORBA::Boolean MakeGroups, - SMESH::ElementType ElemType, - SMESH::SMESH_MeshEditor::Extrusion_Error& Error) + SMESH::SMESH_IDSource_ptr Path, + CORBA::Long NodeStart, + CORBA::Boolean HasAngles, + const SMESH::double_array& Angles, + CORBA::Boolean LinearVariation, + CORBA::Boolean HasRefPoint, + const SMESH::PointStruct& RefPoint, + CORBA::Boolean MakeGroups, + SMESH::ElementType ElemType, + SMESH::SMESH_MeshEditor::Extrusion_Error& Error) { SMESH::long_array_var anElementsId = Object->GetIDs(); SMESH::ListOfGroups * aGroups = extrusionAlongPathX(anElementsId, - Path, - NodeStart, - HasAngles, - Angles, - LinearVariation, - HasRefPoint, - RefPoint, - MakeGroups, - (SMDSAbs_ElementType)ElemType, - Error); - + Path, + NodeStart, + HasAngles, + Angles, + LinearVariation, + HasRefPoint, + RefPoint, + MakeGroups, + (SMDSAbs_ElementType)ElemType, + Error); + if ( !myPreviewMode ) { bool isDumpGroups = aGroups && aGroups->length() > 0; TPythonDump aPythonDump; @@ -2580,13 +2562,13 @@ ExtrusionAlongPathObjX(SMESH::SMESH_IDSource_ptr Object, << NodeStart << ", " << HasAngles << ", " << Angles << ", " - << LinearVariation << ", " - << HasRefPoint << ", " - << "SMESH.PointStruct( " - << ( HasRefPoint ? RefPoint.x : 0 ) << ", " - << ( HasRefPoint ? RefPoint.y : 0 ) << ", " - << ( HasRefPoint ? RefPoint.z : 0 ) << " ), " - << ElemType << " )"; + << LinearVariation << ", " + << HasRefPoint << ", " + << "SMESH.PointStruct( " + << ( HasRefPoint ? RefPoint.x : 0 ) << ", " + << ( HasRefPoint ? RefPoint.y : 0 ) << ", " + << ( HasRefPoint ? RefPoint.z : 0 ) << " ), " + << ElemType << " )"; } return aGroups; } @@ -2598,29 +2580,29 @@ ExtrusionAlongPathObjX(SMESH::SMESH_IDSource_ptr Object, //======================================================================= SMESH::ListOfGroups* SMESH_MeshEditor_i:: ExtrusionAlongPathX(const SMESH::long_array& IDsOfElements, - SMESH::SMESH_IDSource_ptr Path, - CORBA::Long NodeStart, - CORBA::Boolean HasAngles, - const SMESH::double_array& Angles, - CORBA::Boolean LinearVariation, - CORBA::Boolean HasRefPoint, - const SMESH::PointStruct& RefPoint, - CORBA::Boolean MakeGroups, - SMESH::ElementType ElemType, - SMESH::SMESH_MeshEditor::Extrusion_Error& Error) + SMESH::SMESH_IDSource_ptr Path, + CORBA::Long NodeStart, + CORBA::Boolean HasAngles, + const SMESH::double_array& Angles, + CORBA::Boolean LinearVariation, + CORBA::Boolean HasRefPoint, + const SMESH::PointStruct& RefPoint, + CORBA::Boolean MakeGroups, + SMESH::ElementType ElemType, + SMESH::SMESH_MeshEditor::Extrusion_Error& Error) { SMESH::ListOfGroups * aGroups = extrusionAlongPathX(IDsOfElements, - Path, - NodeStart, - HasAngles, - Angles, - LinearVariation, - HasRefPoint, - RefPoint, - MakeGroups, - (SMDSAbs_ElementType)ElemType, - Error); - + Path, + NodeStart, + HasAngles, + Angles, + LinearVariation, + HasRefPoint, + RefPoint, + MakeGroups, + (SMDSAbs_ElementType)ElemType, + Error); + if ( !myPreviewMode ) { bool isDumpGroups = aGroups && aGroups->length() > 0; TPythonDump aPythonDump; @@ -2638,13 +2620,13 @@ ExtrusionAlongPathX(const SMESH::long_array& IDsOfElements, << NodeStart << ", " << HasAngles << ", " << Angles << ", " - << LinearVariation << ", " - << HasRefPoint << ", " - << "SMESH.PointStruct( " - << ( HasRefPoint ? RefPoint.x : 0 ) << ", " - << ( HasRefPoint ? RefPoint.y : 0 ) << ", " - << ( HasRefPoint ? RefPoint.z : 0 ) << " ), " - << ElemType << " )"; + << LinearVariation << ", " + << HasRefPoint << ", " + << "SMESH.PointStruct( " + << ( HasRefPoint ? RefPoint.x : 0 ) << ", " + << ( HasRefPoint ? RefPoint.y : 0 ) << ", " + << ( HasRefPoint ? RefPoint.z : 0 ) << " ), " + << ElemType << " )"; } return aGroups; } @@ -2654,10 +2636,10 @@ ExtrusionAlongPathX(const SMESH::long_array& IDsOfElements, /*! * \brief Compute rotation angles for ExtrusionAlongPath as linear variation * of given angles along path steps - * \param PathMesh mesh containing a 1D sub-mesh on the edge, along - * which proceeds the extrusion - * \param PathShape is shape(edge); as the mesh can be complex, the edge - * is used to define the sub-mesh for the path + * \param PathMesh mesh containing a 1D sub-mesh on the edge, along + * which proceeds the extrusion + * \param PathShape is shape(edge); as the mesh can be complex, the edge + * is used to define the sub-mesh for the path */ //================================================================================ @@ -2697,7 +2679,7 @@ SMESH_MeshEditor_i::LinearAnglesVariation(SMESH::SMESH_Mesh_ptr thePathMes int iP = int( angPrevFloor ); double angPrevCeil = ceil(angPrev); angle = ( angPrevCeil - angPrev ) * theAngles[ iP ]; - + int iC = int( angCurFloor ); if ( iC < nbAngles ) angle += ( angCur - angCurFloor ) * theAngles[ iC ]; @@ -2792,9 +2774,9 @@ void SMESH_MeshEditor_i::Mirror(const SMESH::long_array & theIDsOfElem //======================================================================= void SMESH_MeshEditor_i::MirrorObject(SMESH::SMESH_IDSource_ptr theObject, - const SMESH::AxisStruct & theAxis, - SMESH::SMESH_MeshEditor::MirrorType theMirrorType, - CORBA::Boolean theCopy) + const SMESH::AxisStruct & theAxis, + SMESH::SMESH_MeshEditor::MirrorType theMirrorType, + CORBA::Boolean theCopy) { if ( !myPreviewMode ) { TPythonDump() << this << ".MirrorObject( " @@ -2868,7 +2850,7 @@ SMESH_MeshEditor_i::MirrorMakeMesh(const SMESH::long_array& theIDsOfE SMESH::SMESH_Mesh_var mesh; { // open new scope to dump "MakeMesh" command // and then "GetGroups" using SMESH_Mesh::GetGroups() - + TPythonDump pydump; // to prevent dump at mesh creation mesh = makeMesh( theMeshName ); @@ -2878,7 +2860,7 @@ SMESH_MeshEditor_i::MirrorMakeMesh(const SMESH::long_array& theIDsOfE false, theCopyGroups, & mesh_i->GetImpl()); mesh_i->CreateGroupServants(); } - + if ( !myPreviewMode ) { pydump << mesh << " = " << this << ".MirrorMakeMesh( " << theIDsOfElements << ", " @@ -2892,7 +2874,7 @@ SMESH_MeshEditor_i::MirrorMakeMesh(const SMESH::long_array& theIDsOfE //dump "GetGroups" if(!myPreviewMode && mesh_i) mesh_i->GetGroups(); - + return mesh._retn(); } @@ -2912,7 +2894,7 @@ SMESH_MeshEditor_i::MirrorObjectMakeMesh(SMESH::SMESH_IDSource_ptr the SMESH::SMESH_Mesh_var mesh; { // open new scope to dump "MakeMesh" command // and then "GetGroups" using SMESH_Mesh::GetGroups() - + TPythonDump pydump; // to prevent dump at mesh creation mesh = makeMesh( theMeshName ); @@ -2937,7 +2919,7 @@ SMESH_MeshEditor_i::MirrorObjectMakeMesh(SMESH::SMESH_IDSource_ptr the //dump "GetGroups" if(!myPreviewMode && mesh_i) mesh_i->GetGroups(); - + return mesh._retn(); } @@ -2999,8 +2981,8 @@ void SMESH_MeshEditor_i::Translate(const SMESH::long_array & theIDsOfElements, //======================================================================= void SMESH_MeshEditor_i::TranslateObject(SMESH::SMESH_IDSource_ptr theObject, - const SMESH::DirStruct & theVector, - CORBA::Boolean theCopy) + const SMESH::DirStruct & theVector, + CORBA::Boolean theCopy) { if ( !myPreviewMode ) { TPythonDump() << this << ".TranslateObject( " @@ -3046,7 +3028,7 @@ SMESH_MeshEditor_i::TranslateObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObjec { SMESH::long_array_var anElementsId = theObject->GetIDs(); SMESH::ListOfGroups * aGroups = translate(anElementsId, theVector, true, true); - + if ( !myPreviewMode ) { TPythonDump aPythonDump; @@ -3071,21 +3053,21 @@ SMESH_MeshEditor_i::TranslateMakeMesh(const SMESH::long_array& theIDsOfElements, { SMESH_Mesh_i* mesh_i; SMESH::SMESH_Mesh_var mesh; - + { // open new scope to dump "MakeMesh" command // and then "GetGroups" using SMESH_Mesh::GetGroups() TPythonDump pydump; // to prevent dump at mesh creation - + mesh = makeMesh( theMeshName ); mesh_i = SMESH::DownCast( mesh ); - + if ( mesh_i ) { translate(theIDsOfElements, theVector, false, theCopyGroups, & mesh_i->GetImpl()); mesh_i->CreateGroupServants(); } - + if ( !myPreviewMode ) { pydump << mesh << " = " << this << ".TranslateMakeMesh( " << theIDsOfElements << ", " @@ -3094,11 +3076,11 @@ SMESH_MeshEditor_i::TranslateMakeMesh(const SMESH::long_array& theIDsOfElements, << theMeshName << "' )"; } } - + //dump "GetGroups" if(!myPreviewMode && mesh_i) mesh_i->GetGroups(); - + return mesh._retn(); } @@ -3117,11 +3099,11 @@ SMESH_MeshEditor_i::TranslateObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject, SMESH::SMESH_Mesh_var mesh; { // open new scope to dump "MakeMesh" command // and then "GetGroups" using SMESH_Mesh::GetGroups() - + TPythonDump pydump; // to prevent dump at mesh creation mesh = makeMesh( theMeshName ); mesh_i = SMESH::DownCast( mesh ); - + if ( mesh_i ) { SMESH::long_array_var anElementsId = theObject->GetIDs(); translate(anElementsId, theVector, @@ -3136,11 +3118,11 @@ SMESH_MeshEditor_i::TranslateObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject, << theMeshName << "' )"; } } - + //dump "GetGroups" if(!myPreviewMode && mesh_i) mesh_i->GetGroups(); - + return mesh._retn(); } @@ -3208,9 +3190,9 @@ void SMESH_MeshEditor_i::Rotate(const SMESH::long_array & theIDsOfElements, //======================================================================= void SMESH_MeshEditor_i::RotateObject(SMESH::SMESH_IDSource_ptr theObject, - const SMESH::AxisStruct & theAxis, - CORBA::Double theAngle, - CORBA::Boolean theCopy) + const SMESH::AxisStruct & theAxis, + CORBA::Double theAngle, + CORBA::Boolean theCopy) { if ( !myPreviewMode ) { TPythonDump() << this << ".RotateObject( " @@ -3243,7 +3225,7 @@ SMESH_MeshEditor_i::RotateMakeGroups(const SMESH::long_array& theIDsOfElements, DumpGroupsList(aPythonDump,aGroups); aPythonDump << this << ".RotateMakeGroups( " << theIDsOfElements << ", " - << theAxis << ", " + << theAxis << ", " << theAngle << " )"; } return aGroups; @@ -3261,14 +3243,14 @@ SMESH_MeshEditor_i::RotateObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject, { SMESH::long_array_var anElementsId = theObject->GetIDs(); SMESH::ListOfGroups * aGroups = rotate(anElementsId,theAxis,theAngle,true,true); - + if ( !myPreviewMode ) { TPythonDump aPythonDump; DumpGroupsList(aPythonDump,aGroups); aPythonDump << this << ".RotateObjectMakeGroups( " - << theObject << ", " - << theAxis << ", " - << theAngle << " )"; + << theObject << ", " + << theAxis << ", " + << theAngle << " )"; } return aGroups; } @@ -3290,12 +3272,12 @@ SMESH_MeshEditor_i::RotateMakeMesh(const SMESH::long_array& theIDsOfElements, { // open new scope to dump "MakeMesh" command // and then "GetGroups" using SMESH_Mesh::GetGroups() - + TPythonDump pydump; // to prevent dump at mesh creation mesh = makeMesh( theMeshName ); mesh_i = SMESH::DownCast( mesh ); - + if ( mesh_i ) { rotate(theIDsOfElements, theAxis, theAngleInRadians, false, theCopyGroups, & mesh_i->GetImpl()); @@ -3310,11 +3292,11 @@ SMESH_MeshEditor_i::RotateMakeMesh(const SMESH::long_array& theIDsOfElements, << theMeshName << "' )"; } } - + //dump "GetGroups" if(!myPreviewMode && mesh_i) mesh_i->GetGroups(); - + return mesh._retn(); } @@ -3332,14 +3314,14 @@ SMESH_MeshEditor_i::RotateObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject, { SMESH::SMESH_Mesh_var mesh; SMESH_Mesh_i* mesh_i; - + {// open new scope to dump "MakeMesh" command // and then "GetGroups" using SMESH_Mesh::GetGroups() - + TPythonDump pydump; // to prevent dump at mesh creation mesh = makeMesh( theMeshName ); mesh_i = SMESH::DownCast( mesh ); - + if (mesh_i ) { SMESH::long_array_var anElementsId = theObject->GetIDs(); rotate(anElementsId, theAxis, theAngleInRadians, @@ -3355,11 +3337,11 @@ SMESH_MeshEditor_i::RotateObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject, << theMeshName << "' )"; } } - + //dump "GetGroups" if(!myPreviewMode && mesh_i) mesh_i->GetGroups(); - + return mesh._retn(); } @@ -3408,7 +3390,7 @@ void SMESH_MeshEditor_i::FindCoincidentNodesOnPart(SMESH::SMESH_IDSource_ptr set nodes; if ( !CORBA::is_nil(SMESH::SMESH_GroupBase::_narrow(theObject)) && - SMESH::SMESH_GroupBase::_narrow(theObject)->GetType() == SMESH::NODE) { + SMESH::SMESH_GroupBase::_narrow(theObject)->GetType() == SMESH::NODE) { for(int i = 0; i < aElementsId->length(); i++) { CORBA::Long ind = aElementsId[i]; const SMDS_MeshNode * elem = aMesh->FindNode(ind); @@ -3427,13 +3409,13 @@ void SMESH_MeshEditor_i::FindCoincidentNodesOnPart(SMESH::SMESH_IDSource_ptr } } } - - + + ::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes; ::SMESH_MeshEditor anEditor( myMesh ); if(!nodes.empty()) anEditor.FindCoincidentNodes( nodes, Tolerance, aListOfListOfNodes ); - + GroupsOfNodes = new SMESH::array_of_long_array; GroupsOfNodes->length( aListOfListOfNodes.size() ); ::SMESH_MeshEditor::TListOfListOfNodes::iterator llIt = aListOfListOfNodes.begin(); @@ -3493,11 +3475,11 @@ void SMESH_MeshEditor_i::MergeNodes (const SMESH::array_of_long_array& GroupsOfN //purpose : //======================================================================= void SMESH_MeshEditor_i::FindEqualElements(SMESH::SMESH_IDSource_ptr theObject, - SMESH::array_of_long_array_out GroupsOfElementsID) + SMESH::array_of_long_array_out GroupsOfElementsID) { initData(); if ( !(!CORBA::is_nil(SMESH::SMESH_GroupBase::_narrow(theObject)) && - SMESH::SMESH_GroupBase::_narrow(theObject)->GetType() == SMESH::NODE) ) { + SMESH::SMESH_GroupBase::_narrow(theObject)->GetType() == SMESH::NODE) ) { typedef list TListOfIDs; set elems; SMESH::long_array_var aElementsId = theObject->GetIDs(); @@ -3507,7 +3489,7 @@ void SMESH_MeshEditor_i::FindEqualElements(SMESH::SMESH_IDSource_ptr theObj CORBA::Long anID = aElementsId[i]; const SMDS_MeshElement * elem = aMesh->FindElement(anID); if (elem) { - elems.insert(elem); + elems.insert(elem); } } @@ -3525,12 +3507,12 @@ void SMESH_MeshEditor_i::FindEqualElements(SMESH::SMESH_IDSource_ptr theObj aGroup.length( listOfIDs.size() ); TListOfIDs::iterator idIt = listOfIDs.begin(); for (int k = 0; idIt != listOfIDs.end(); ++idIt, ++k ) { - aGroup[ k ] = *idIt; + aGroup[ k ] = *idIt; } } - TPythonDump() << "equal_elements = " << this << ".FindEqualElements( " - <FindNode( NodeID ); + if ( !node ) + return false; + + if ( theNodeSearcher ) + theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other + + if ( theNodeSearcher ) // move node and update theNodeSearcher data accordingly + theNodeSearcher->MoveNode(node, gp_Pnt( x,y,z )); + else + GetMeshDS()->MoveNode(node, x, y, z); + + // Update Python script + TPythonDump() << "isDone = " << this << ".MoveNode( " + << NodeID << ", " << x << ", " << y << ", " << z << " )"; + + return true; +} + +//================================================================================ +/*! + * \brief Return ID of node closest to a given point + */ +//================================================================================ + +CORBA::Long SMESH_MeshEditor_i::FindNodeClosestTo(CORBA::Double x, + CORBA::Double y, + CORBA::Double z) +{ + theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other + + if ( !theNodeSearcher ) { + ::SMESH_MeshEditor anEditor( myMesh ); + theNodeSearcher = anEditor.GetNodeSearcher(); + } + gp_Pnt p( x,y,z ); + if ( const SMDS_MeshNode* node = theNodeSearcher->FindClosestTo( p )) + return node->GetID(); + + return 0; +} + //================================================================================ /*! * \brief If the given ID is a valid node ID (nodeID > 0), just move this node, else @@ -3595,24 +3632,24 @@ CORBA::Long SMESH_MeshEditor_i::MoveClosestNodeToPoint(CORBA::Double x, CORBA::Double z, CORBA::Long theNodeID) { - // We keep myNodeSearcher until any mesh modification: - // 1) initData() deletes myNodeSearcher at any edition, - // 2) TNodeSearcherDeleter - at any mesh compute event and mesh change + // We keep theNodeSearcher until any mesh modification: + // 1) initData() deletes theNodeSearcher at any edition, + // 2) TSearchersDeleter - at any mesh compute event and mesh change - initData(); + initData(/*deleteSearchers=*/false); + + theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other int nodeID = theNodeID; const SMDS_MeshNode* node = GetMeshDS()->FindNode( nodeID ); - if ( !node ) + if ( !node ) // preview moving node { - static TNodeSearcherDeleter deleter; - deleter.Set( myMesh ); - if ( !myNodeSearcher ) { + if ( !theNodeSearcher ) { ::SMESH_MeshEditor anEditor( myMesh ); - myNodeSearcher = anEditor.GetNodeSearcher(); + theNodeSearcher = anEditor.GetNodeSearcher(); } gp_Pnt p( x,y,z ); - node = myNodeSearcher->FindClosestTo( p ); + node = theNodeSearcher->FindClosestTo( p ); } if ( node ) { nodeID = node->GetID(); @@ -3636,6 +3673,10 @@ CORBA::Long SMESH_MeshEditor_i::MoveClosestNodeToPoint(CORBA::Double x, ::SMESH_MeshEditor anEditor( & tmpMesh ); storeResult( anEditor ); } + else if ( theNodeSearcher ) // move node and update theNodeSearcher data accordingly + { + theNodeSearcher->MoveNode(node, gp_Pnt( x,y,z )); + } else { GetMeshDS()->MoveNode(node, x, y, z); @@ -3651,6 +3692,44 @@ CORBA::Long SMESH_MeshEditor_i::MoveClosestNodeToPoint(CORBA::Double x, return nodeID; } +//======================================================================= +/*! + * Return elements of given type where the given point is IN or ON. + * + * 'ALL' type means elements of any type excluding nodes + */ +//======================================================================= + +SMESH::long_array* SMESH_MeshEditor_i::FindElementsByPoint(CORBA::Double x, + CORBA::Double y, + CORBA::Double z, + SMESH::ElementType type) +{ + SMESH::long_array_var res = new SMESH::long_array; + vector< const SMDS_MeshElement* > foundElems; + + theSearchersDeleter.Set( myMesh ); + if ( !theElementSearcher ) { + ::SMESH_MeshEditor anEditor( myMesh ); + theElementSearcher = anEditor.GetElementSearcher(); + } + 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 << ".FindElementsByPoint( " + << x << ", " + << y << ", " + << z << ", " + << type << " )"; + + return res._retn(); +} + //======================================================================= //function : convError //purpose : @@ -3661,16 +3740,16 @@ CORBA::Long SMESH_MeshEditor_i::MoveClosestNodeToPoint(CORBA::Double x, static SMESH::SMESH_MeshEditor::Sew_Error convError( const::SMESH_MeshEditor::Sew_Error e ) { switch ( e ) { - RETCASE( SEW_OK ); - RETCASE( SEW_BORDER1_NOT_FOUND ); - RETCASE( SEW_BORDER2_NOT_FOUND ); - RETCASE( SEW_BOTH_BORDERS_NOT_FOUND ); - RETCASE( SEW_BAD_SIDE_NODES ); - RETCASE( SEW_VOLUMES_TO_SPLIT ); - RETCASE( SEW_DIFF_NB_OF_ELEMENTS ); - RETCASE( SEW_TOPO_DIFF_SETS_OF_ELEMENTS ); - RETCASE( SEW_BAD_SIDE1_NODES ); - RETCASE( SEW_BAD_SIDE2_NODES ); + RETCASE( SEW_OK ); + RETCASE( SEW_BORDER1_NOT_FOUND ); + RETCASE( SEW_BORDER2_NOT_FOUND ); + RETCASE( SEW_BOTH_BORDERS_NOT_FOUND ); + RETCASE( SEW_BAD_SIDE_NODES ); + RETCASE( SEW_VOLUMES_TO_SPLIT ); + RETCASE( SEW_DIFF_NB_OF_ELEMENTS ); + RETCASE( SEW_TOPO_DIFF_SETS_OF_ELEMENTS ); + RETCASE( SEW_BAD_SIDE1_NODES ); + RETCASE( SEW_BAD_SIDE2_NODES ); } return SMESH::SMESH_MeshEditor::SEW_OK; } @@ -3681,14 +3760,14 @@ static SMESH::SMESH_MeshEditor::Sew_Error convError( const::SMESH_MeshEditor::Se //======================================================================= 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) +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) { initData(); @@ -3910,9 +3989,9 @@ SMESH_MeshEditor_i::SewSideElements(const SMESH::long_array& IDsOfSide1Elements, //================================================================================ /*! * \brief Set new nodes for given element - * \param ide - element id - * \param newIDs - new node ids - * \retval CORBA::Boolean - true if result is OK + * \param ide - element id + * \param newIDs - new node ids + * \retval CORBA::Boolean - true if result is OK */ //================================================================================ @@ -3943,11 +4022,11 @@ CORBA::Boolean SMESH_MeshEditor_i::ChangeElemNodes(CORBA::Long ide, return GetMeshDS()->ChangeElementNodes( elem, & aNodes[0], nbn1+1 ); } - + //================================================================================ /*! * \brief Update myLastCreated* or myPreviewData - * \param anEditor - it contains last modification results + * \param anEditor - it contains last modification results */ //================================================================================ @@ -4005,8 +4084,8 @@ void SMESH_MeshEditor_i::storeResult(::SMESH_MeshEditor& anEditor) /*if (aMeshElem->GetType() == SMDSAbs_Volume) { aType = SMDSAbs_Node; isPoly = false; - } - else*/ { + } + else*/ { aType = aMeshElem->GetType(); isPoly = aMeshElem->IsPoly(); } @@ -4024,7 +4103,7 @@ void SMESH_MeshEditor_i::storeResult(::SMESH_MeshEditor& anEditor) myPreviewData->elementConnectivities.length(aNodesConnectivity.size()); for( int i = 0; aConnIter != aNodesConnectivity.end(); aConnIter++, i++ ) myPreviewData->elementConnectivities[i] = *aConnIter; - + return; } @@ -4058,7 +4137,7 @@ SMESH::MeshPreviewStruct* SMESH_MeshEditor_i::GetPreviewData() //================================================================================ /*! * \brief Returns list of it's IDs of created nodes - * \retval SMESH::long_array* - list of node ID + * \retval SMESH::long_array* - list of node ID */ //================================================================================ @@ -4070,7 +4149,7 @@ SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedNodes() //================================================================================ /*! * \brief Returns list of it's IDs of created elements - * \retval SMESH::long_array* - list of elements' ID + * \retval SMESH::long_array* - list of elements' ID */ //================================================================================ @@ -4137,135 +4216,286 @@ void SMESH_MeshEditor_i::DumpGroupsList(TPythonDump & theDumpPytho //================================================================================ /*! \brief Creates a hole in a mesh by doubling the nodes of some particular elements - \param theNodes - identifiers of nodes to be doubled - \param theModifiedElems - identifiers of elements to be updated by the new (doubled) - nodes. If list of element identifiers is empty then nodes are doubled but - they not assigned to elements + \param theElems - the list of elements (edges or faces) to be replicated + The nodes for duplication could be found from these elements + \param theNodesNot - list of nodes to NOT replicate + \param theAffectedElems - the list of elements (cells and edges) to which the + replicated nodes should be associated to. \return TRUE if operation has been completed successfully, FALSE otherwise - \sa DoubleNode(), DoubleNodeGroup(), DoubleNodeGroups() + \sa DoubleNodeGroup(), DoubleNodeGroups() */ //================================================================================ -CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theNodes, - const SMESH::long_array& theModifiedElems ) +CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theElems, + const SMESH::long_array& theNodesNot, + const SMESH::long_array& theAffectedElems ) + { initData(); ::SMESH_MeshEditor aMeshEditor( myMesh ); - list< int > aListOfNodes; - int i, n; - for ( i = 0, n = theNodes.length(); i < n; i++ ) - aListOfNodes.push_back( theNodes[ i ] ); - list< int > aListOfElems; - for ( i = 0, n = theModifiedElems.length(); i < n; i++ ) - aListOfElems.push_back( theModifiedElems[ i ] ); + SMESHDS_Mesh* aMeshDS = GetMeshDS(); + TIDSortedElemSet anElems, aNodes, anAffected; + arrayToSet(theElems, aMeshDS, anElems, SMDSAbs_All); + arrayToSet(theNodesNot, aMeshDS, aNodes, SMDSAbs_Node); + arrayToSet(theAffectedElems, aMeshDS, anAffected, SMDSAbs_All); - bool aResult = aMeshEditor.DoubleNodes( aListOfNodes, aListOfElems ); + bool aResult = aMeshEditor.DoubleNodes( anElems, aNodes, anAffected ); storeResult( aMeshEditor) ; + // Update Python script + TPythonDump() << "isDone = " << this << ".DoubleNodes( " << theElems << ", " + << theNodesNot << ", " << theAffectedElems << " )"; return aResult; } //================================================================================ /*! \brief Creates a hole in a mesh by doubling the nodes of some particular elements - This method provided for convenience works as DoubleNodes() described above. - \param theNodeId - identifier of node to be doubled. - \param theModifiedElems - identifiers of elements to be updated. + \param theElems - the list of elements (edges or faces) to be replicated + The nodes for duplication could be found from these elements + \param theNodesNot - list of nodes to NOT replicate + \param theShape - shape to detect affected elements (element which geometric center + located on or inside shape). + The replicated nodes should be associated to affected elements. \return TRUE if operation has been completed successfully, FALSE otherwise - \sa DoubleNodes(), DoubleNodeGroup(), DoubleNodeGroups() + \sa DoubleNodeGroupInRegion(), DoubleNodeGroupsInRegion() */ //================================================================================ -CORBA::Boolean SMESH_MeshEditor_i::DoubleNode( CORBA::Long theNodeId, - const SMESH::long_array& theModifiedElems ) +CORBA::Boolean SMESH_MeshEditor_i::DoubleNodesInRegion +( const SMESH::long_array& theElems, + const SMESH::long_array& theNodesNot, + GEOM::GEOM_Object_ptr theShape ) + { - SMESH::long_array_var aNodes = new SMESH::long_array; - aNodes->length( 1 ); - aNodes[ 0 ] = theNodeId; - return DoubleNodes( aNodes, theModifiedElems ); + initData(); + + ::SMESH_MeshEditor aMeshEditor( myMesh ); + + SMESHDS_Mesh* aMeshDS = GetMeshDS(); + TIDSortedElemSet anElems, aNodes; + arrayToSet(theElems, aMeshDS, anElems, SMDSAbs_All); + arrayToSet(theNodesNot, aMeshDS, aNodes, SMDSAbs_Node); + + TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape ); + bool aResult = aMeshEditor.DoubleNodesInRegion( anElems, aNodes, aShape ); + + storeResult( aMeshEditor) ; + + // Update Python script + TPythonDump() << "isDone = " << this << ".DoubleNodesInRegion( " << theElems << ", " + << theNodesNot << ", " << theShape << " )"; + return aResult; } //================================================================================ /*! \brief Creates a hole in a mesh by doubling the nodes of some particular elements - This method provided for convenience works as DoubleNodes() described above. - \param theNodes - group of nodes to be doubled. - \param theModifiedElems - group of elements to be updated. + \param theElems - group of of elements (edges or faces) to be replicated + \param theNodesNot - group of nodes not to replicated + \param theAffectedElems - group of elements to which the replicated nodes + should be associated to. \return TRUE if operation has been completed successfully, FALSE otherwise - \sa DoubleNode(), DoubleNodes(), DoubleNodeGroups() + \sa DoubleNodes(), DoubleNodeGroups() */ //================================================================================ +static void groupToSet(SMESH::SMESH_GroupBase_ptr theGrp, + SMESHDS_Mesh* theMeshDS, + TIDSortedElemSet& theElemSet, + const SMDSAbs_ElementType theType) + +{ + if ( CORBA::is_nil( theGrp ) ) + return; + SMESH::long_array_var anIDs = theGrp->GetIDs(); + arrayToSet( anIDs, theMeshDS, theElemSet, theType); +} + CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroup( - SMESH::SMESH_GroupBase_ptr theNodes, - SMESH::SMESH_GroupBase_ptr theModifiedElems ) + SMESH::SMESH_GroupBase_ptr theElems, + SMESH::SMESH_GroupBase_ptr theNodesNot, + SMESH::SMESH_GroupBase_ptr theAffectedElems ) + { - if ( CORBA::is_nil( theNodes ) && theNodes->GetType() != SMESH::NODE ) + if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE ) return false; - SMESH::long_array_var aNodes = theNodes->GetListOfID(); - SMESH::long_array_var aModifiedElems; - if ( !CORBA::is_nil( theModifiedElems ) ) - aModifiedElems = theModifiedElems->GetListOfID(); - else - { - aModifiedElems = new SMESH::long_array; - aModifiedElems->length( 0 ); - } + initData(); - return DoubleNodes( aNodes, aModifiedElems ); + ::SMESH_MeshEditor aMeshEditor( myMesh ); + + SMESHDS_Mesh* aMeshDS = GetMeshDS(); + TIDSortedElemSet anElems, aNodes, anAffected; + groupToSet( theElems, aMeshDS, anElems, SMDSAbs_All ); + groupToSet( theNodesNot, aMeshDS, aNodes, SMDSAbs_Node ); + groupToSet( theAffectedElems, aMeshDS, anAffected, SMDSAbs_All ); + + bool aResult = aMeshEditor.DoubleNodes( anElems, aNodes, anAffected ); + + storeResult( aMeshEditor) ; + + // Update Python script + TPythonDump() << "isDone = " << this << ".DoubleNodeGroup( " << theElems << ", " + << theNodesNot << ", " << theAffectedElems << " )"; + return aResult; } //================================================================================ /*! \brief Creates a hole in a mesh by doubling the nodes of some particular elements - This method provided for convenience works as DoubleNodes() described above. - \param theNodes - list of groups of nodes to be doubled - \param theModifiedElems - list of groups of elements to be updated. + \param theElems - group of of elements (edges or faces) to be replicated + \param theNodesNot - group of nodes not to replicated + \param theShape - shape to detect affected elements (element which geometric center + located on or inside shape). + The replicated nodes should be associated to affected elements. \return TRUE if operation has been completed successfully, FALSE otherwise - \sa DoubleNode(), DoubleNodeGroup(), DoubleNodes() + \sa DoubleNodesInRegion(), DoubleNodeGroupsInRegion() */ //================================================================================ -CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups( - const SMESH::ListOfGroups& theNodes, - const SMESH::ListOfGroups& theModifiedElems ) +CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroupInRegion( + SMESH::SMESH_GroupBase_ptr theElems, + SMESH::SMESH_GroupBase_ptr theNodesNot, + GEOM::GEOM_Object_ptr theShape ) + { + if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE ) + return false; + initData(); ::SMESH_MeshEditor aMeshEditor( myMesh ); - std::list< int > aNodes; - int i, n, j, m; - for ( i = 0, n = theNodes.length(); i < n; i++ ) - { - SMESH::SMESH_GroupBase_var aGrp = theNodes[ i ]; - if ( !CORBA::is_nil( aGrp ) && aGrp->GetType() == SMESH::NODE ) - { - SMESH::long_array_var aCurr = aGrp->GetListOfID(); - for ( j = 0, m = aCurr->length(); j < m; j++ ) - aNodes.push_back( aCurr[ j ] ); - } - } + SMESHDS_Mesh* aMeshDS = GetMeshDS(); + TIDSortedElemSet anElems, aNodes, anAffected; + groupToSet( theElems, aMeshDS, anElems, SMDSAbs_All ); + groupToSet( theNodesNot, aMeshDS, aNodes, SMDSAbs_Node ); - std::list< int > anElems; - for ( i = 0, n = theModifiedElems.length(); i < n; i++ ) + TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape ); + bool aResult = aMeshEditor.DoubleNodesInRegion( anElems, aNodes, aShape ); + + storeResult( aMeshEditor) ; + + // Update Python script + TPythonDump() << "isDone = " << this << ".DoubleNodeGroupInRegion( " << theElems << ", " + << theNodesNot << ", " << theShape << " )"; + return aResult; +} + +//================================================================================ +/*! + \brief Creates a hole in a mesh by doubling the nodes of some particular elements + This method provided for convenience works as DoubleNodes() described above. + \param theElems - list of groups of elements (edges or faces) to be replicated + \param theNodesNot - list of groups of nodes not to replicated + \param theAffectedElems - group of elements to which the replicated nodes + should be associated to. + \return TRUE if operation has been completed successfully, FALSE otherwise + \sa DoubleNodeGroup(), DoubleNodes() +*/ +//================================================================================ + +static void listOfGroupToSet(const SMESH::ListOfGroups& theGrpList, + SMESHDS_Mesh* theMeshDS, + TIDSortedElemSet& theElemSet, + const bool theIsNodeGrp) +{ + for ( int i = 0, n = theGrpList.length(); i < n; i++ ) { - SMESH::SMESH_GroupBase_var aGrp = theModifiedElems[ i ]; - if ( !CORBA::is_nil( aGrp ) && aGrp->GetType() != SMESH::NODE ) + SMESH::SMESH_GroupBase_var aGrp = theGrpList[ i ]; + if ( !CORBA::is_nil( aGrp ) && (theIsNodeGrp ? aGrp->GetType() == SMESH::NODE + : aGrp->GetType() != SMESH::NODE ) ) { - SMESH::long_array_var aCurr = aGrp->GetListOfID(); - for ( j = 0, m = aCurr->length(); j < m; j++ ) - anElems.push_back( aCurr[ j ] ); + SMESH::long_array_var anIDs = aGrp->GetIDs(); + arrayToSet( anIDs, theMeshDS, theElemSet, theIsNodeGrp ? SMDSAbs_Node : SMDSAbs_All ); } } +} + +CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups( + const SMESH::ListOfGroups& theElems, + const SMESH::ListOfGroups& theNodesNot, + const SMESH::ListOfGroups& theAffectedElems ) +{ + initData(); + + ::SMESH_MeshEditor aMeshEditor( myMesh ); + + SMESHDS_Mesh* aMeshDS = GetMeshDS(); + TIDSortedElemSet anElems, aNodes, anAffected; + listOfGroupToSet(theElems, aMeshDS, anElems, false ); + listOfGroupToSet(theNodesNot, aMeshDS, aNodes, true ); + listOfGroupToSet(theAffectedElems, aMeshDS, anAffected, false ); + + bool aResult = aMeshEditor.DoubleNodes( anElems, aNodes, anAffected ); + + storeResult( aMeshEditor) ; + + // Update Python script + TPythonDump() << "isDone = " << this << ".DoubleNodeGroups( " << &theElems << ", " + << &theNodesNot << ", " << &theAffectedElems << " )"; + return aResult; +} + +//================================================================================ +/*! + \brief Creates a hole in a mesh by doubling the nodes of some particular elements + This method provided for convenience works as DoubleNodes() described above. + \param theElems - list of groups of elements (edges or faces) to be replicated + \param theNodesNot - list of groups of nodes not to replicated + \param theShape - shape to detect affected elements (element which geometric center + located on or inside shape). + The replicated nodes should be associated to affected elements. + \return TRUE if operation has been completed successfully, FALSE otherwise + \sa DoubleNodeGroupInRegion(), DoubleNodesInRegion() +*/ +//================================================================================ + +CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroupsInRegion( + const SMESH::ListOfGroups& theElems, + const SMESH::ListOfGroups& theNodesNot, + GEOM::GEOM_Object_ptr theShape ) +{ + initData(); + + ::SMESH_MeshEditor aMeshEditor( myMesh ); - bool aResult = aMeshEditor.DoubleNodes( aNodes, anElems ); + SMESHDS_Mesh* aMeshDS = GetMeshDS(); + TIDSortedElemSet anElems, aNodes; + listOfGroupToSet(theElems, aMeshDS, anElems,false ); + listOfGroupToSet(theNodesNot, aMeshDS, aNodes, true ); + + TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape ); + bool aResult = aMeshEditor.DoubleNodesInRegion( anElems, aNodes, aShape ); storeResult( aMeshEditor) ; + // Update Python script + TPythonDump() << "isDone = " << this << ".DoubleNodeGroupsInRegion( " << &theElems << ", " + << &theNodesNot << ", " << theShape << " )"; + return aResult; +} + +//================================================================================ +/*! + \brief Generated skin mesh (containing 2D cells) from 3D mesh + The created 2D mesh elements based on nodes of free faces of boundary volumes + \return TRUE if operation has been completed successfully, FALSE otherwise +*/ +//================================================================================ + +CORBA::Boolean SMESH_MeshEditor_i::Make2DMeshFrom3D() +{ + initData(); + + ::SMESH_MeshEditor aMeshEditor( myMesh ); + bool aResult = aMeshEditor.Make2DMeshFrom3D(); + storeResult( aMeshEditor) ; + + TPythonDump() << "isDone = " << this << ".Make2DMeshFrom3D()"; return aResult; }