23305: [EDF 10301] Extrusion with scaling

This commit is contained in:
eap 2016-08-01 15:42:08 +03:00
parent 1cea009185
commit 5504d02a22
12 changed files with 556 additions and 114 deletions

Binary file not shown.

Before

Width:  |  Height:  |  Size: 36 KiB

After

Width:  |  Height:  |  Size: 44 KiB

View File

@ -128,6 +128,25 @@ The following dialog will appear:
</ul> </ul>
<li>Specify the <b>Number of steps</b>.</li> <li>Specify the <b>Number of steps</b>.</li>
<li>Optionally specify <b>Scale Factors</b>. Each scale factor in
the list is applied to nodes of a corresponding extrusion step
unless <b>Linear Variation of Scale Factors</b> is checked, is
which case the scale factors are spread over all extrusion steps.</li>
<ul>
<li><b>Scaling Center</b> can be defined either using spin boxes
or by picking a node in the Viewer or by picking a geometrical
vertex in the Object Browser.</li>
<li>\b Add button adds a scale factor to the list.
\image html add.png
<center><em>"Add" button</em></center>
</li>
<li>\b Remove button removes selected scale factors from the list.
\image html remove.png
<center><em>"Remove" button</em></center>
</li>
</ul>
<li>If you activate <b>Generate Groups</b> check-box, the <em>result elements</em> <li>If you activate <b>Generate Groups</b> check-box, the <em>result elements</em>
created from <em>selected elements</em> contained in groups will be created from <em>selected elements</em> contained in groups will be
included into new groups named by pattern "<old group included into new groups named by pattern "<old group

View File

@ -487,6 +487,9 @@ module SMESH
in ListOfIDSources faces, in ListOfIDSources faces,
in DirStruct stepVector, in DirStruct stepVector,
in long nbOfSteps, in long nbOfSteps,
in double_array scaleFactors,
in boolean linearVariation,
in double_array basePoint,
in boolean toMakeGroups) in boolean toMakeGroups)
raises (SALOME::SALOME_Exception); raises (SALOME::SALOME_Exception);

View File

@ -5482,9 +5482,12 @@ SMESH_MeshEditor::RotationSweep(TIDSortedElemSet theElemSets[2],
SMESH_MeshEditor::ExtrusParam::ExtrusParam( const gp_Vec& theStep, SMESH_MeshEditor::ExtrusParam::ExtrusParam( const gp_Vec& theStep,
const int theNbSteps, const int theNbSteps,
const std::list<double>& theScales,
const gp_XYZ* theBasePoint,
const int theFlags, const int theFlags,
const double theTolerance): const double theTolerance):
myDir( theStep ), myDir( theStep ),
myBaseP( Precision::Infinite(), 0, 0 ),
myFlags( theFlags ), myFlags( theFlags ),
myTolerance( theTolerance ), myTolerance( theTolerance ),
myElemsToUse( NULL ) myElemsToUse( NULL )
@ -5494,6 +5497,37 @@ SMESH_MeshEditor::ExtrusParam::ExtrusParam( const gp_Vec& theStep,
for (int i=1; i<=theNbSteps; i++ ) for (int i=1; i<=theNbSteps; i++ )
mySteps->Append( stepSize ); mySteps->Append( stepSize );
int nbScales = theScales.size();
if ( nbScales > 0 )
{
if ( IsLinearVariation() && nbScales < theNbSteps )
{
myScales.reserve( theNbSteps );
std::list<double>::const_iterator scale = theScales.begin();
double prevScale = 1.0;
for ( int iSc = 1; scale != theScales.end(); ++scale, ++iSc )
{
int iStep = int( iSc / double( nbScales ) * theNbSteps + 0.5 );
int stDelta = Max( 1, iStep - myScales.size());
double scDelta = ( *scale - prevScale ) / stDelta;
for ( int iStep = 0; iStep < stDelta; ++iStep )
{
myScales.push_back( prevScale + scDelta );
prevScale = myScales.back();
}
prevScale = *scale;
}
}
else
{
myScales.assign( theScales.begin(), theScales.end() );
}
}
if ( theBasePoint )
{
myBaseP = *theBasePoint;
}
if (( theFlags & EXTRUSION_FLAG_SEW ) && if (( theFlags & EXTRUSION_FLAG_SEW ) &&
( theTolerance > 0 )) ( theTolerance > 0 ))
{ {
@ -5562,12 +5596,38 @@ SMESH_MeshEditor::ExtrusParam::ExtrusParam( const double theStepSize,
//======================================================================= //=======================================================================
//function : ExtrusParam::SetElementsToUse //function : ExtrusParam::SetElementsToUse
//purpose : stores elements to use for extrusion by normal, depending on //purpose : stores elements to use for extrusion by normal, depending on
// state of EXTRUSION_FLAG_USE_INPUT_ELEMS_ONLY flag // state of EXTRUSION_FLAG_USE_INPUT_ELEMS_ONLY flag;
// define myBaseP for scaling
//======================================================================= //=======================================================================
void SMESH_MeshEditor::ExtrusParam::SetElementsToUse( const TIDSortedElemSet& elems ) void SMESH_MeshEditor::ExtrusParam::SetElementsToUse( const TIDSortedElemSet& elems,
const TIDSortedElemSet& nodes )
{ {
myElemsToUse = ToUseInpElemsOnly() ? & elems : 0; myElemsToUse = ToUseInpElemsOnly() ? & elems : 0;
if ( Precision::IsInfinite( myBaseP.X() )) // myBaseP not defined
{
myBaseP.SetCoord( 0.,0.,0. );
TIDSortedElemSet newNodes;
const TIDSortedElemSet* elemSets[] = { &elems, &nodes };
for ( int is2ndSet = 0; is2ndSet < 2; ++is2ndSet )
{
const TIDSortedElemSet& elements = *( elemSets[ is2ndSet ]);
TIDSortedElemSet::const_iterator itElem = elements.begin();
for ( ; itElem != elements.end(); itElem++ )
{
const SMDS_MeshElement* elem = *itElem;
SMDS_ElemIteratorPtr itN = elem->nodesIterator();
while ( itN->more() ) {
const SMDS_MeshElement* node = itN->next();
if ( newNodes.insert( node ).second )
myBaseP += SMESH_TNodeXYZ( node );
}
}
}
myBaseP /= newNodes.size();
}
} }
//======================================================================= //=======================================================================
@ -5637,6 +5697,41 @@ makeNodesByDir( SMESHDS_Mesh* mesh,
const SMDS_MeshNode * newNode = mesh->AddNode( p.X(), p.Y(), p.Z() ); const SMDS_MeshNode * newNode = mesh->AddNode( p.X(), p.Y(), p.Z() );
newNodes.push_back( newNode ); newNodes.push_back( newNode );
} }
if ( !myScales.empty() )
{
if ( makeMediumNodes && myMediumScales.empty() )
{
myMediumScales.resize( myScales.size() );
double prevFactor = 1.;
for ( size_t i = 0; i < myScales.size(); ++i )
{
myMediumScales[i] = 0.5 * ( prevFactor + myScales[i] );
prevFactor = myScales[i];
}
}
typedef std::vector<double>::iterator ScaleIt;
ScaleIt scales[] = { myScales.begin(), myMediumScales.begin() };
size_t iSc = 0, nbScales = myScales.size() + myMediumScales.size();
gp_XYZ center = myBaseP;
std::list<const SMDS_MeshNode*>::iterator nIt = newNodes.begin();
size_t iN = 0;
for ( beginStepIter( makeMediumNodes ); moreSteps() && ( iN < nbScales ); ++nIt, ++iN )
{
center += myDir.XYZ() * nextStep();
iSc += int( makeMediumNodes );
ScaleIt& scale = scales[ iSc % 2 ];
gp_XYZ xyz = SMESH_TNodeXYZ( *nIt );
xyz = ( *scale * ( xyz - center )) + center;
mesh->MoveNode( *nIt, xyz.X(), xyz.Y(), xyz.Z() );
++scale;
}
}
return nbNodes; return nbNodes;
} }
@ -5811,7 +5906,7 @@ SMESH_MeshEditor::ExtrusionSweep (TIDSortedElemSet theElems[2],
const int theFlags, const int theFlags,
const double theTolerance) const double theTolerance)
{ {
ExtrusParam aParams( theStep, theNbSteps, theFlags, theTolerance ); ExtrusParam aParams( theStep, theNbSteps, std::list<double>(), 0, theFlags, theTolerance );
return ExtrusionSweep( theElems, aParams, newElemsMap ); return ExtrusionSweep( theElems, aParams, newElemsMap );
} }
@ -5832,16 +5927,12 @@ SMESH_MeshEditor::ExtrusionSweep (TIDSortedElemSet theElemSets[2],
// source elements for each generated one // source elements for each generated one
SMESH_SequenceOfElemPtr srcElems, srcNodes; SMESH_SequenceOfElemPtr srcElems, srcNodes;
//SMESHDS_Mesh* aMesh = GetMeshDS();
setElemsFirst( theElemSets ); setElemsFirst( theElemSets );
const int nbSteps = theParams.NbSteps(); const int nbSteps = theParams.NbSteps();
theParams.SetElementsToUse( theElemSets[0] ); theParams.SetElementsToUse( theElemSets[0], theElemSets[1] );
TNodeOfNodeListMap mapNewNodes; TNodeOfNodeListMap mapNewNodes;
//TNodeOfNodeVecMap mapNewNodes;
TElemOfVecOfNnlmiMap mapElemNewNodes; TElemOfVecOfNnlmiMap mapElemNewNodes;
//TElemOfVecOfMapNodesMap mapElemNewNodes;
const bool isQuadraticMesh = bool( myMesh->NbEdges(ORDER_QUADRATIC) + const bool isQuadraticMesh = bool( myMesh->NbEdges(ORDER_QUADRATIC) +
myMesh->NbFaces(ORDER_QUADRATIC) + myMesh->NbFaces(ORDER_QUADRATIC) +
@ -6656,24 +6747,23 @@ SMESH_MeshEditor::MakeExtrElements(TIDSortedElemSet theElemSets
//======================================================================= //=======================================================================
//function : LinearAngleVariation //function : LinearAngleVariation
//purpose : auxilary for ExtrusionAlongTrack //purpose : spread values over nbSteps
//======================================================================= //=======================================================================
void SMESH_MeshEditor::LinearAngleVariation(const int nbSteps, void SMESH_MeshEditor::LinearAngleVariation(const int nbSteps,
list<double>& Angles) list<double>& Angles)
{ {
int nbAngles = Angles.size(); int nbAngles = Angles.size();
if( nbSteps > nbAngles ) { if( nbSteps > nbAngles && nbAngles > 0 )
{
vector<double> theAngles(nbAngles); vector<double> theAngles(nbAngles);
list<double>::iterator it = Angles.begin(); theAngles.assign( Angles.begin(), Angles.end() );
int i = -1;
for(; it!=Angles.end(); it++) {
i++;
theAngles[i] = (*it);
}
list<double> res; list<double> res;
double rAn2St = double( nbAngles ) / double( nbSteps ); double rAn2St = double( nbAngles ) / double( nbSteps );
double angPrev = 0, angle; double angPrev = 0, angle;
for ( int iSt = 0; iSt < nbSteps; ++iSt ) { for ( int iSt = 0; iSt < nbSteps; ++iSt )
{
double angCur = rAn2St * ( iSt+1 ); double angCur = rAn2St * ( iSt+1 );
double angCurFloor = floor( angCur ); double angCurFloor = floor( angCur );
double angPrevFloor = floor( angPrev ); double angPrevFloor = floor( angPrev );
@ -6695,10 +6785,7 @@ void SMESH_MeshEditor::LinearAngleVariation(const int nbSteps,
res.push_back(angle); res.push_back(angle);
angPrev = angCur; angPrev = angCur;
} }
Angles.clear(); Angles.swap( res );
it = res.begin();
for(; it!=res.end(); it++)
Angles.push_back( *it );
} }
} }

View File

@ -293,21 +293,26 @@ public:
* else step size is measured along average normal of any element * else step size is measured along average normal of any element
* USE_INPUT_ELEMS_ONLY: to use only input elements to compute extrusion direction * USE_INPUT_ELEMS_ONLY: to use only input elements to compute extrusion direction
* for ExtrusionByNormal() * for ExtrusionByNormal()
* SCALE_LINEAR_VARIATION: to make linear variation of scale factors
*/ */
enum ExtrusionFlags { enum ExtrusionFlags {
EXTRUSION_FLAG_BOUNDARY = 0x01, EXTRUSION_FLAG_BOUNDARY = 0x01,
EXTRUSION_FLAG_SEW = 0x02, EXTRUSION_FLAG_SEW = 0x02,
EXTRUSION_FLAG_GROUPS = 0x04, EXTRUSION_FLAG_GROUPS = 0x04,
EXTRUSION_FLAG_BY_AVG_NORMAL = 0x08, EXTRUSION_FLAG_BY_AVG_NORMAL = 0x08,
EXTRUSION_FLAG_USE_INPUT_ELEMS_ONLY = 0x10 EXTRUSION_FLAG_USE_INPUT_ELEMS_ONLY = 0x10,
EXTRUSION_FLAG_SCALE_LINEAR_VARIATION = 0x20
}; };
/*! /*!
* Generator of nodes for extrusion functionality * Generator of nodes for extrusion functionality
*/ */
class SMESH_EXPORT ExtrusParam { class SMESH_EXPORT ExtrusParam
{
gp_Dir myDir; // direction of extrusion gp_Dir myDir; // direction of extrusion
Handle(TColStd_HSequenceOfReal) mySteps; // magnitudes for each step Handle(TColStd_HSequenceOfReal) mySteps; // magnitudes for each step
std::vector<double> myScales, myMediumScales;// scale factors
gp_XYZ myBaseP; // scaling center
SMESH_SequenceOfNode myNodes; // nodes for using in sewing SMESH_SequenceOfNode myNodes; // nodes for using in sewing
int myFlags; // see ExtrusionFlags int myFlags; // see ExtrusionFlags
double myTolerance; // tolerance for sewing nodes double myTolerance; // tolerance for sewing nodes
@ -321,6 +326,8 @@ public:
public: public:
ExtrusParam( const gp_Vec& theStep, ExtrusParam( const gp_Vec& theStep,
const int theNbSteps, const int theNbSteps,
const std::list<double>& theScales,
const gp_XYZ* theBaseP,
const int theFlags = 0, const int theFlags = 0,
const double theTolerance = 1e-6); const double theTolerance = 1e-6);
ExtrusParam( const gp_Dir& theDir, ExtrusParam( const gp_Dir& theDir,
@ -337,11 +344,13 @@ public:
bool ToMakeBoundary() const { return myFlags & EXTRUSION_FLAG_BOUNDARY; } bool ToMakeBoundary() const { return myFlags & EXTRUSION_FLAG_BOUNDARY; }
bool ToMakeGroups() const { return myFlags & EXTRUSION_FLAG_GROUPS; } bool ToMakeGroups() const { return myFlags & EXTRUSION_FLAG_GROUPS; }
bool ToUseInpElemsOnly() const { return myFlags & EXTRUSION_FLAG_USE_INPUT_ELEMS_ONLY; } bool ToUseInpElemsOnly() const { return myFlags & EXTRUSION_FLAG_USE_INPUT_ELEMS_ONLY; }
bool IsLinearVariation() const { return myFlags & EXTRUSION_FLAG_SCALE_LINEAR_VARIATION; }
int NbSteps() const { return mySteps->Length(); } int NbSteps() const { return mySteps->Length(); }
// stores elements to use for extrusion by normal, depending on // stores elements to use for extrusion by normal, depending on
// state of EXTRUSION_FLAG_USE_INPUT_ELEMS_ONLY flag // state of EXTRUSION_FLAG_USE_INPUT_ELEMS_ONLY flag;
void SetElementsToUse( const TIDSortedElemSet& elems ); // define myBaseP for scaling
void SetElementsToUse( const TIDSortedElemSet& elems, const TIDSortedElemSet& nodes );
// creates nodes and returns number of nodes added in \a newNodes // creates nodes and returns number of nodes added in \a newNodes
int MakeNodes( SMESHDS_Mesh* mesh, int MakeNodes( SMESHDS_Mesh* mesh,
@ -784,7 +793,7 @@ public:
const bool theHasRefPoint, const bool theHasRefPoint,
const gp_Pnt& theRefPoint, const gp_Pnt& theRefPoint,
const bool theMakeGroups); const bool theMakeGroups);
void LinearAngleVariation(const int NbSteps, static void LinearAngleVariation(const int NbSteps,
std::list<double>& theAngles); std::list<double>& theAngles);
bool doubleNodes( SMESHDS_Mesh* theMeshDS, bool doubleNodes( SMESHDS_Mesh* theMeshDS,

View File

@ -28,58 +28,59 @@
#include "SMESHGUI_ExtrusionDlg.h" #include "SMESHGUI_ExtrusionDlg.h"
#include "SMESHGUI.h" #include "SMESHGUI.h"
#include "SMESHGUI_Utils.h" #include "SMESHGUI_FilterDlg.h"
#include "SMESHGUI_VTKUtils.h" #include "SMESHGUI_IdValidator.h"
#include "SMESHGUI_MeshEditPreview.h"
#include "SMESHGUI_MeshUtils.h" #include "SMESHGUI_MeshUtils.h"
#include "SMESHGUI_SpinBox.h" #include "SMESHGUI_SpinBox.h"
#include "SMESHGUI_IdValidator.h" #include "SMESHGUI_Utils.h"
#include "SMESHGUI_FilterDlg.h" #include "SMESHGUI_VTKUtils.h"
#include "SMESHGUI_MeshEditPreview.h" #include <GEOMBase.h>
#include <SMESH_Actor.h>
#include <SMESH_TypeFilter.hxx>
#include <SMESH_LogicalFilter.hxx>
#include <SMDS_Mesh.hxx> #include <SMDS_Mesh.hxx>
#include <SMESH_Actor.h>
#include <SMESH_LogicalFilter.hxx>
#include <SMESH_TypeFilter.hxx>
// SALOME GUI includes // SALOME GUI includes
#include <SUIT_ResourceMgr.h>
#include <SUIT_Desktop.h>
#include <SUIT_MessageBox.h>
#include <SUIT_Session.h>
#include <SUIT_OverrideCursor.h>
#include <LightApp_Application.h> #include <LightApp_Application.h>
#include <LightApp_SelectionMgr.h> #include <LightApp_SelectionMgr.h>
#include <SUIT_Desktop.h>
#include <SUIT_MessageBox.h>
#include <SUIT_OverrideCursor.h>
#include <SUIT_ResourceMgr.h>
#include <SUIT_Session.h>
#include <SVTK_ViewModel.h> #include <SVTK_ViewModel.h>
#include <SVTK_ViewWindow.h> #include <SVTK_ViewWindow.h>
#include <SalomeApp_IntSpinBox.h> #include <SalomeApp_IntSpinBox.h>
// OCCT includes // OCCT includes
#include <TColStd_MapOfInteger.hxx> #include <BRep_Tool.hxx>
#include <TColStd_IndexedMapOfInteger.hxx> #include <TColStd_IndexedMapOfInteger.hxx>
#include <TColStd_MapOfInteger.hxx>
#include <TopoDS_Vertex.hxx>
#include <gp_XYZ.hxx> #include <gp_XYZ.hxx>
// Qt includes // Qt includes
#include <QApplication> #include <QApplication>
#include <QButtonGroup> #include <QButtonGroup>
#include <QCheckBox>
#include <QGridLayout>
#include <QGroupBox> #include <QGroupBox>
#include <QHBoxLayout>
#include <QKeyEvent>
#include <QLabel> #include <QLabel>
#include <QLineEdit> #include <QLineEdit>
#include <QListWidget>
#include <QPushButton> #include <QPushButton>
#include <QRadioButton> #include <QRadioButton>
#include <QCheckBox> #include <QToolButton>
#include <QHBoxLayout>
#include <QVBoxLayout> #include <QVBoxLayout>
#include <QGridLayout>
#include <QKeyEvent>
// IDL includes // IDL includes
#include <SALOMEconfig.h> #include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_Group) #include CORBA_SERVER_HEADER(SMESH_Group)
#include CORBA_SERVER_HEADER(SMESH_MeshEditor) #include CORBA_SERVER_HEADER(SMESH_MeshEditor)
#include <SMESH_NumberFilter.hxx>
#define SPACING 6 #define SPACING 6
#define MARGIN 11 #define MARGIN 11
@ -595,7 +596,10 @@ SMESHGUI_ExtrusionDlg::SMESHGUI_ExtrusionDlg (SMESHGUI* theModule)
: SMESHGUI_PreviewDlg( theModule ), : SMESHGUI_PreviewDlg( theModule ),
mySelectionMgr( SMESH::GetSelectionMgr( theModule ) ) mySelectionMgr( SMESH::GetSelectionMgr( theModule ) )
{ {
QPixmap image (SMESH::GetResourceMgr( mySMESHGUI )->loadPixmap("SMESH", tr("ICON_SELECT"))); SUIT_ResourceMgr* mgr = SMESH::GetResourceMgr( mySMESHGUI );
QPixmap selectImage ( mgr->loadPixmap("SMESH", tr("ICON_SELECT")));
QPixmap addImage ( mgr->loadPixmap("SMESH", tr("ICON_APPEND")));
QPixmap removeImage ( mgr->loadPixmap("SMESH", tr("ICON_REMOVE")));
setModal( false ); setModal( false );
setAttribute( Qt::WA_DeleteOnClose, true ); setAttribute( Qt::WA_DeleteOnClose, true );
@ -638,8 +642,8 @@ SMESHGUI_ExtrusionDlg::SMESHGUI_ExtrusionDlg (SMESHGUI* theModule)
TextLabelVector = new QLabel(tr("SMESH_VECTOR"), GroupArguments); TextLabelVector = new QLabel(tr("SMESH_VECTOR"), GroupArguments);
SelectVectorButton = new QPushButton(GroupArguments); SelectVectorButton = new QPushButton( GroupArguments );
SelectVectorButton->setIcon(image); SelectVectorButton->setIcon( selectImage );
SelectVectorButton->setCheckable( true ); SelectVectorButton->setCheckable( true );
SelectorWdg->GetButtonGroup()->addButton( SelectVectorButton ); SelectorWdg->GetButtonGroup()->addButton( SelectVectorButton );
@ -671,6 +675,66 @@ SMESHGUI_ExtrusionDlg::SMESHGUI_ExtrusionDlg (SMESHGUI* theModule)
//Preview check box //Preview check box
myPreviewCheckBox = new QCheckBox(tr("PREVIEW"), GroupArguments); myPreviewCheckBox = new QCheckBox(tr("PREVIEW"), GroupArguments);
// Base point
BasePointGrp = new QGroupBox(tr("BASE_POINT"), GroupArguments);
BasePointGrp->setCheckable(true);
BasePointGrp->setChecked(false);
QHBoxLayout* BasePointGrpLayout = new QHBoxLayout(BasePointGrp);
BasePointGrpLayout->setSpacing(SPACING); BasePointGrpLayout->setMargin(MARGIN);
SelectBasePointButton = new QPushButton(BasePointGrp);
SelectBasePointButton->setIcon(selectImage);
SelectBasePointButton->setCheckable(true);
SelectorWdg->GetButtonGroup()->addButton( SelectBasePointButton );
QLabel* XLab = new QLabel(tr("SMESH_X"), BasePointGrp);
BasePoint_XSpin = new SMESHGUI_SpinBox(BasePointGrp);
BasePoint_XSpin->SetValue(0.);
QLabel* YLab = new QLabel(tr("SMESH_Y"), BasePointGrp);
BasePoint_YSpin = new SMESHGUI_SpinBox(BasePointGrp);
BasePoint_YSpin->SetValue(0.);
QLabel* ZLab = new QLabel(tr("SMESH_Z"), BasePointGrp);
BasePoint_ZSpin = new SMESHGUI_SpinBox(BasePointGrp);
BasePoint_ZSpin->SetValue(0.);
BasePointGrpLayout->addWidget(SelectBasePointButton);
BasePointGrpLayout->addWidget(XLab);
BasePointGrpLayout->addWidget(BasePoint_XSpin, 1);
BasePointGrpLayout->addWidget(YLab);
BasePointGrpLayout->addWidget(BasePoint_YSpin, 1);
BasePointGrpLayout->addWidget(ZLab);
BasePointGrpLayout->addWidget(BasePoint_ZSpin, 1);
// Scales
ScalesGrp = new QGroupBox(tr("SMESH_SCALES"), GroupArguments);
QGridLayout* ScalesGrpLayout = new QGridLayout( ScalesGrp );
ScalesGrpLayout->setSpacing(SPACING); ScalesGrpLayout->setMargin(MARGIN);
ScalesList = new QListWidget( ScalesGrp );
ScalesList->setSelectionMode(QListWidget::ExtendedSelection);
AddScaleButton = new QToolButton( ScalesGrp );
AddScaleButton->setIcon( addImage );
RemoveScaleButton = new QToolButton( ScalesGrp );
RemoveScaleButton->setIcon( removeImage );
ScaleSpin = new SMESHGUI_SpinBox( ScalesGrp );
ScaleSpin->SetValue(2);
LinearScalesCheck = new QCheckBox(tr("LINEAR_SCALES"), ScalesGrp );
ScalesGrpLayout->addWidget(ScalesList, 0, 0, 4, 1);
ScalesGrpLayout->addWidget(AddScaleButton, 0, 1);
ScalesGrpLayout->addWidget(RemoveScaleButton, 2, 1);
ScalesGrpLayout->addWidget(ScaleSpin, 0, 2);
ScalesGrpLayout->addWidget(LinearScalesCheck, 4, 0);
ScalesGrpLayout->setRowMinimumHeight(1, 10);
ScalesGrpLayout->setRowStretch(3, 10);
// layouting
GroupArgumentsLayout->addWidget(SelectorWdg, 0, 0, 1, 9); GroupArgumentsLayout->addWidget(SelectorWdg, 0, 0, 1, 9);
GroupArgumentsLayout->addWidget(ExtrMethod_RBut0, 1, 0, 1, 3); GroupArgumentsLayout->addWidget(ExtrMethod_RBut0, 1, 0, 1, 3);
GroupArgumentsLayout->addWidget(ExtrMethod_RBut1, 1, 3, 1, 3); GroupArgumentsLayout->addWidget(ExtrMethod_RBut1, 1, 3, 1, 3);
@ -696,8 +760,10 @@ SMESHGUI_ExtrusionDlg::SMESHGUI_ExtrusionDlg (SMESHGUI* theModule)
GroupArgumentsLayout->addWidget(SpinBox_NbSteps, 5, 3); GroupArgumentsLayout->addWidget(SpinBox_NbSteps, 5, 3);
GroupArgumentsLayout->addWidget(ByAverageNormalCheck, 6, 0, 1, 4); GroupArgumentsLayout->addWidget(ByAverageNormalCheck, 6, 0, 1, 4);
GroupArgumentsLayout->addWidget(UseInputElemsOnlyCheck, 6, 4, 1, 4); GroupArgumentsLayout->addWidget(UseInputElemsOnlyCheck, 6, 4, 1, 4);
GroupArgumentsLayout->addWidget(myPreviewCheckBox, 7, 0, 1, 8); GroupArgumentsLayout->addWidget(BasePointGrp, 7, 0, 1, 9);
GroupArgumentsLayout->addWidget(MakeGroupsCheck, 8, 0, 1, 8); GroupArgumentsLayout->addWidget(ScalesGrp, 8, 0, 1, 9);
GroupArgumentsLayout->addWidget(myPreviewCheckBox, 9, 0, 1, 8);
GroupArgumentsLayout->addWidget(MakeGroupsCheck, 10,0, 1, 8);
GroupArgumentsLayout->addItem(new QSpacerItem(0, 0, QSizePolicy::Minimum, QSizePolicy::Expanding), 10, 0); GroupArgumentsLayout->addItem(new QSpacerItem(0, 0, QSizePolicy::Minimum, QSizePolicy::Expanding), 10, 0);
/***************************************************************/ /***************************************************************/
@ -740,6 +806,11 @@ SMESHGUI_ExtrusionDlg::SMESHGUI_ExtrusionDlg (SMESHGUI* theModule)
SpinBox_NbSteps->setRange(1, 999999); SpinBox_NbSteps->setRange(1, 999999);
SpinBox_VDist->RangeStepAndValidator(COORD_MIN, COORD_MAX, 10.0, "length_precision"); SpinBox_VDist->RangeStepAndValidator(COORD_MIN, COORD_MAX, 10.0, "length_precision");
BasePoint_XSpin->RangeStepAndValidator(COORD_MIN, COORD_MAX, 10.0, "length_precision");
BasePoint_YSpin->RangeStepAndValidator(COORD_MIN, COORD_MAX, 10.0, "length_precision");
BasePoint_ZSpin->RangeStepAndValidator(COORD_MIN, COORD_MAX, 10.0, "length_precision");
ScaleSpin->RangeStepAndValidator (COORD_MIN, COORD_MAX, 1.0, "length_precision");
ExtrMethod_RBut0->setChecked(true); ExtrMethod_RBut0->setChecked(true);
UseInputElemsOnlyCheck->setChecked(true); UseInputElemsOnlyCheck->setChecked(true);
MakeGroupsCheck->setChecked(true); MakeGroupsCheck->setChecked(true);
@ -771,7 +842,13 @@ SMESHGUI_ExtrusionDlg::SMESHGUI_ExtrusionDlg (SMESHGUI* theModule)
connect(SpinBox_Dy, SIGNAL(valueChanged(double)), SLOT(CheckIsEnable())); connect(SpinBox_Dy, SIGNAL(valueChanged(double)), SLOT(CheckIsEnable()));
connect(SpinBox_Dz, SIGNAL(valueChanged(double)), SLOT(CheckIsEnable())); connect(SpinBox_Dz, SIGNAL(valueChanged(double)), SLOT(CheckIsEnable()));
connect(AddScaleButton, SIGNAL(clicked()), this, SLOT(OnScaleAdded()));
connect(RemoveScaleButton, SIGNAL(clicked()), this, SLOT(OnScaleRemoved()));
connect(SelectVectorButton, SIGNAL(clicked()), this, SLOT(SetEditCurrentArgument())); connect(SelectVectorButton, SIGNAL(clicked()), this, SLOT(SetEditCurrentArgument()));
connect(SelectBasePointButton,SIGNAL(clicked()), this, SLOT(SetEditCurrentArgument()));
connect(BasePointGrp, SIGNAL(toggled(bool)), this, SLOT(SetEditCurrentArgument()));
connect(BasePointGrp, SIGNAL(toggled(bool)), SelectBasePointButton, SLOT(click()));
connect(mySMESHGUI, SIGNAL(SignalDeactivateActiveDialog()), SLOT(DeactivateActiveDialog())); connect(mySMESHGUI, SIGNAL(SignalDeactivateActiveDialog()), SLOT(DeactivateActiveDialog()));
connect(mySelectionMgr, SIGNAL(currentSelectionChanged()), SLOT(toDisplaySimulation())); connect(mySelectionMgr, SIGNAL(currentSelectionChanged()), SLOT(toDisplaySimulation()));
connect(SelectorWdg, SIGNAL(selectionChanged()), this, SLOT(toDisplaySimulation())); connect(SelectorWdg, SIGNAL(selectionChanged()), this, SLOT(toDisplaySimulation()));
@ -791,6 +868,13 @@ SMESHGUI_ExtrusionDlg::SMESHGUI_ExtrusionDlg (SMESHGUI* theModule)
connect(SpinBox_NbSteps, SIGNAL(valueChanged(int)), this, SLOT(toDisplaySimulation())); connect(SpinBox_NbSteps, SIGNAL(valueChanged(int)), this, SLOT(toDisplaySimulation()));
connect(ByAverageNormalCheck, SIGNAL(toggled(bool)), this, SLOT(toDisplaySimulation())); connect(ByAverageNormalCheck, SIGNAL(toggled(bool)), this, SLOT(toDisplaySimulation()));
connect(UseInputElemsOnlyCheck, SIGNAL(toggled(bool)), this, SLOT(toDisplaySimulation())); connect(UseInputElemsOnlyCheck, SIGNAL(toggled(bool)), this, SLOT(toDisplaySimulation()));
connect(AddScaleButton, SIGNAL(clicked()), this, SLOT(toDisplaySimulation()));
connect(RemoveScaleButton, SIGNAL(clicked()), this, SLOT(toDisplaySimulation()));
connect(LinearScalesCheck, SIGNAL(toggled(bool)), this, SLOT(toDisplaySimulation()));
connect(BasePointGrp, SIGNAL(toggled(bool)), this, SLOT(toDisplaySimulation()));
connect(BasePoint_XSpin, SIGNAL(valueChanged(double)), this, SLOT(toDisplaySimulation()));
connect(BasePoint_YSpin, SIGNAL(valueChanged(double)), this, SLOT(toDisplaySimulation()));
connect(BasePoint_ZSpin, SIGNAL(valueChanged(double)), this, SLOT(toDisplaySimulation()));
//To Connect preview check box //To Connect preview check box
connectPreviewControl(); connectPreviewControl();
@ -875,6 +959,31 @@ bool SMESHGUI_ExtrusionDlg::isValuesValid()
return aModule > 1.0E-38; return aModule > 1.0E-38;
} }
//=======================================================================
//function : getScaleParams
//purpose : return 3 scaling parameters
//=======================================================================
bool SMESHGUI_ExtrusionDlg::getScaleParams( SMESH::double_array*& scales,
SMESH::double_array*& basePoint )
{
scales = new SMESH::double_array;
scales->length( myScalesList.count() );
for ( int i = 0; i < myScalesList.count(); ++i )
(*scales)[i] = myScalesList[i];
basePoint = new SMESH::double_array;
if ( BasePointGrp->isChecked() )
{
basePoint->length( 3 );
(*basePoint)[0] = BasePoint_XSpin->GetValue();
(*basePoint)[1] = BasePoint_YSpin->GetValue();
(*basePoint)[2] = BasePoint_ZSpin->GetValue();
}
return ( scales->length() > 0 && LinearScalesCheck->isChecked() );
}
//================================================================================= //=================================================================================
// function : ClickOnRadio() // function : ClickOnRadio()
// purpose : Radio button management // purpose : Radio button management
@ -1011,14 +1120,22 @@ bool SMESHGUI_ExtrusionDlg::ClickOnApply()
} }
long aNbSteps = (long)SpinBox_NbSteps->value(); long aNbSteps = (long)SpinBox_NbSteps->value();
aParameters << SpinBox_NbSteps->text(); aParameters << SpinBox_NbSteps->text();
SMESH::double_array_var scales = new SMESH::double_array;
scales->length( myScalesList.count() );
for (int i = 0; i < myScalesList.count(); i++)
{
scales[i] = myScalesList[i];
aParameters << ScalesList->item(i)->text();
}
bool meshHadNewTypeBefore = true; bool meshHadNewTypeBefore = true;
int maxSelType = 0; int maxSelType = 0;
const bool makeGroups = ( MakeGroupsCheck->isEnabled() && MakeGroupsCheck->isChecked() ); const bool makeGroups = ( MakeGroupsCheck->isEnabled() && MakeGroupsCheck->isChecked() );
try { try
{
SUIT_OverrideCursor aWaitCursor; SUIT_OverrideCursor aWaitCursor;
SMESH::SMESH_Mesh_var mesh = SelectorWdg->GetMesh(); SMESH::SMESH_Mesh_var mesh = SelectorWdg->GetMesh();
@ -1054,8 +1171,12 @@ bool SMESHGUI_ExtrusionDlg::ClickOnApply()
} }
else else
{ {
SMESH::double_array_var scales, basePoint;
bool linVariation = getScaleParams( scales.out(), basePoint.out() );
groups = meshEditor->ExtrusionSweepObjects( nodes, edges, faces, groups = meshEditor->ExtrusionSweepObjects( nodes, edges, faces,
aVector, aNbSteps, makeGroups ); aVector, aNbSteps,
scales, linVariation, basePoint,
makeGroups );
} }
} catch (...) { } catch (...) {
@ -1180,13 +1301,13 @@ void SMESHGUI_ExtrusionDlg::SelectionIntoArgument()
if (!GroupButtons->isEnabled()) if (!GroupButtons->isEnabled())
return; return;
if ( SelectVectorButton->isChecked() )
{
SALOME_ListIO aList; SALOME_ListIO aList;
mySelectionMgr->selectedObjects(aList); mySelectionMgr->selectedObjects(aList);
if ( aList.IsEmpty() || aList.Extent() > 1 ) if ( aList.IsEmpty() || aList.Extent() > 1 )
return; return;
if ( SelectVectorButton->isChecked() )
{
Handle(SALOME_InteractiveObject) IO = aList.First(); Handle(SALOME_InteractiveObject) IO = aList.First();
TColStd_IndexedMapOfInteger aMapIndex; TColStd_IndexedMapOfInteger aMapIndex;
mySelector->GetIndex(IO,aMapIndex); mySelector->GetIndex(IO,aMapIndex);
@ -1207,6 +1328,56 @@ void SMESHGUI_ExtrusionDlg::SelectionIntoArgument()
SpinBox_Vy->SetValue(aNormale.Y()); SpinBox_Vy->SetValue(aNormale.Y());
SpinBox_Vz->SetValue(aNormale.Z()); SpinBox_Vz->SetValue(aNormale.Z());
} }
else if ( SelectBasePointButton->isChecked() )
{
if (!BasePointGrp->isChecked())
return;
// try to get shape from selection
Handle(SALOME_InteractiveObject) IO = aList.First();
// check if geom vertex is selected
GEOM::GEOM_Object_var aGeomObj = SMESH::IObjectToInterface<GEOM::GEOM_Object>(IO);
TopoDS_Vertex aVertex;
if (!aGeomObj->_is_nil()) {
if (aGeomObj->IsShape() && GEOMBase::GetShape(aGeomObj, aVertex) && !aVertex.IsNull()) {
gp_Pnt aPnt = BRep_Tool::Pnt(aVertex);
BasePoint_XSpin->SetValue(aPnt.X());
BasePoint_YSpin->SetValue(aPnt.Y());
BasePoint_ZSpin->SetValue(aPnt.Z());
}
}
if ( aVertex.IsNull() )
{
// check if smesh node is selected
SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(IO);
if (aMesh->_is_nil())
return;
QString aString;
int aNbUnits = SMESH::GetNameOfSelectedNodes(mySelector, IO, aString);
// return if more than one node is selected
if (aNbUnits != 1)
return;
SMESH_Actor* aMeshActor = SMESH::FindActorByObject(aMesh);
if (!aMeshActor)
return;
SMDS_Mesh* mesh = aMeshActor->GetObject()->GetMesh();
if (!mesh)
return;
const SMDS_MeshNode* n = mesh->FindNode(aString.toLong());
if (!n)
return;
BasePoint_XSpin->SetValue(n->X());
BasePoint_YSpin->SetValue(n->Y());
BasePoint_ZSpin->SetValue(n->Z());
}
}
onDisplaySimulation(true); onDisplaySimulation(true);
CheckIsEnable(); CheckIsEnable();
@ -1229,6 +1400,21 @@ void SMESHGUI_ExtrusionDlg::SetEditCurrentArgument()
if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI )) if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
aViewWindow->SetSelectionMode(FaceSelection); aViewWindow->SetSelectionMode(FaceSelection);
} }
else if ( send == SelectBasePointButton )
{
SMESH::SetPointRepresentation(true);
if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
aViewWindow->SetSelectionMode(NodeSelection);
SMESH_TypeFilter* aMeshOrSubMeshFilter = new SMESH_TypeFilter(SMESH::IDSOURCE);
SMESH_NumberFilter* aVertexFilter = new SMESH_NumberFilter ("GEOM", TopAbs_VERTEX,
1, TopAbs_VERTEX);
QList<SUIT_SelectionFilter*> aListOfFilters;
aListOfFilters << aMeshOrSubMeshFilter << aVertexFilter;
mySelectionMgr->installFilter(new SMESH_LogicalFilter
(aListOfFilters, SMESH_LogicalFilter::LO_OR, true));
}
connect(mySelectionMgr, SIGNAL(currentSelectionChanged()), this, SLOT(SelectionIntoArgument())); connect(mySelectionMgr, SIGNAL(currentSelectionChanged()), this, SLOT(SelectionIntoArgument()));
SelectionIntoArgument(); SelectionIntoArgument();
@ -1316,6 +1502,12 @@ bool SMESHGUI_ExtrusionDlg::isValid()
} }
ok = SpinBox_NbSteps->isValid( msg, true ) && ok; ok = SpinBox_NbSteps->isValid( msg, true ) && ok;
if ( BasePointGrp->isChecked()) {
ok = BasePoint_XSpin->isValid( msg, true ) && ok;
ok = BasePoint_YSpin->isValid( msg, true ) && ok;
ok = BasePoint_ZSpin->isValid( msg, true ) && ok;
}
if( !ok ) { if( !ok ) {
QString str( tr( "SMESH_INCORRECT_INPUT" ) ); QString str( tr( "SMESH_INCORRECT_INPUT" ) );
if ( !msg.isEmpty() ) if ( !msg.isEmpty() )
@ -1369,8 +1561,12 @@ void SMESHGUI_ExtrusionDlg::onDisplaySimulation( bool toDisplayPreview )
} }
else else
{ {
SMESH::double_array_var scales, basePoint;
bool linVariation = getScaleParams( scales.out(), basePoint.out() );
groups = meshEditor->ExtrusionSweepObjects( nodes, edges, faces, groups = meshEditor->ExtrusionSweepObjects( nodes, edges, faces,
aVector, aNbSteps, makeGroups ); aVector, aNbSteps,
scales, linVariation, basePoint,
makeGroups );
} }
SMESH::MeshPreviewStruct_var aMeshPreviewStruct = meshEditor->GetPreviewData(); SMESH::MeshPreviewStruct_var aMeshPreviewStruct = meshEditor->GetPreviewData();
mySimulation->SetData(aMeshPreviewStruct._retn()); mySimulation->SetData(aMeshPreviewStruct._retn());
@ -1411,3 +1607,38 @@ void SMESHGUI_ExtrusionDlg::getExtrusionVector(SMESH::DirStruct& aVector)
aVector.PS.z = aNormale.Z()*aVDist; aVector.PS.z = aNormale.Z()*aVDist;
} }
} }
//=======================================================================
// function : OnScaleAdded()
// purpose : Called when user adds Scale to the list
//=======================================================================
void SMESHGUI_ExtrusionDlg::OnScaleAdded()
{
QString msg;
if( !ScaleSpin->isValid( msg, true ) ) {
QString str( tr( "SMESH_INCORRECT_INPUT" ) );
if ( !msg.isEmpty() )
str += "\n" + msg;
SUIT_MessageBox::critical( this, tr( "SMESH_ERROR" ), str );
return;
}
ScalesList->addItem(ScaleSpin->text());
myScalesList.append(ScaleSpin->GetValue());
}
//=======================================================================
// function : OnScaleRemoved()
// purpose : Called when user removes Scale(s) from the list
//=======================================================================
void SMESHGUI_ExtrusionDlg::OnScaleRemoved()
{
QList<QListWidgetItem*> aList = ScalesList->selectedItems();
QListWidgetItem* anItem;
int row = 0;
foreach(anItem, aList) {
row = ScalesList->row(anItem);
myScalesList.removeAt(row);
delete anItem;
}
ScalesList->setCurrentRow( row, QItemSelectionModel::Select );
}

View File

@ -41,12 +41,14 @@
#include CORBA_SERVER_HEADER(SMESH_MeshEditor) #include CORBA_SERVER_HEADER(SMESH_MeshEditor)
class QButtonGroup; class QButtonGroup;
class QRadioButton; class QCheckBox;
class QGroupBox; class QGroupBox;
class QLabel; class QLabel;
class QLineEdit; class QLineEdit;
class QCheckBox; class QListWidget;
class QPushButton; class QPushButton;
class QRadioButton;
class QToolButton;
class SMESHGUI; class SMESHGUI;
class SMESH_Actor; class SMESH_Actor;
@ -59,7 +61,7 @@ class SUIT_SelectionFilter;
class SalomeApp_IntSpinBox; class SalomeApp_IntSpinBox;
//================================================================================= //=================================================================================
// class : SMESHGUI_ExtrusionDlg // class : SMESHGUI_3TypesSelector
// purpose : A widget used to select both nodes, edges and faces for // purpose : A widget used to select both nodes, edges and faces for
// Extrusion and Revolution operations // Extrusion and Revolution operations
//================================================================================= //=================================================================================
@ -143,12 +145,15 @@ private:
void getExtrusionVector(SMESH::DirStruct& aVector); void getExtrusionVector(SMESH::DirStruct& aVector);
void extrusionByNormal(SMESH::SMESH_MeshEditor_ptr meshEditor, void extrusionByNormal(SMESH::SMESH_MeshEditor_ptr meshEditor,
const bool makeGroups=false); const bool makeGroups=false);
bool getScaleParams( SMESH::double_array*& scales,
SMESH::double_array*& basePoint );
bool isValid(); bool isValid();
bool isValuesValid(); bool isValuesValid();
LightApp_SelectionMgr* mySelectionMgr; /* User shape selection */ LightApp_SelectionMgr* mySelectionMgr; /* User shape selection */
SVTK_Selector* mySelector; SVTK_Selector* mySelector;
QList<double> myScalesList;
// widgets // widgets
SMESHGUI_3TypesSelector* SelectorWdg; SMESHGUI_3TypesSelector* SelectorWdg;
@ -180,6 +185,18 @@ private:
QCheckBox* UseInputElemsOnlyCheck; QCheckBox* UseInputElemsOnlyCheck;
QCheckBox* MakeGroupsCheck; QCheckBox* MakeGroupsCheck;
QCheckBox* LinearScalesCheck;
QGroupBox* ScalesGrp;
QListWidget* ScalesList;
QToolButton* AddScaleButton;
QToolButton* RemoveScaleButton;
SMESHGUI_SpinBox* ScaleSpin;
QGroupBox* BasePointGrp;
QPushButton* SelectBasePointButton;
SMESHGUI_SpinBox* BasePoint_XSpin;
SMESHGUI_SpinBox* BasePoint_YSpin;
SMESHGUI_SpinBox* BasePoint_ZSpin;
QGroupBox* GroupButtons; QGroupBox* GroupButtons;
QPushButton* buttonOk; QPushButton* buttonOk;
QPushButton* buttonCancel; QPushButton* buttonCancel;
@ -205,6 +222,8 @@ private slots:
void ActivateThisDialog(); void ActivateThisDialog();
void onOpenView(); void onOpenView();
void onCloseView(); void onCloseView();
void OnScaleAdded();
void OnScaleRemoved();
}; };

View File

@ -5267,6 +5267,18 @@ Please select a group and try again</translation>
<source>USE_INPUT_ELEMS_ONLY</source> <source>USE_INPUT_ELEMS_ONLY</source>
<translation>Use only input elements</translation> <translation>Use only input elements</translation>
</message> </message>
<message>
<source>SMESH_SCALES</source>
<translation>Scale Factors</translation>
</message>
<message>
<source>LINEAR_SCALES</source>
<translation>Linear Variation of Scale Factors</translation>
</message>
<message>
<source>BASE_POINT</source>
<translation>Scaling Center</translation>
</message>
</context> </context>
<context> <context>
<name>SMESHGUI_FilterDlg</name> <name>SMESHGUI_FilterDlg</name>

View File

@ -2484,6 +2484,7 @@ namespace MeshEditor_I
bool myIsExtrusionByNormal; bool myIsExtrusionByNormal;
static int makeFlags( CORBA::Boolean MakeGroups, static int makeFlags( CORBA::Boolean MakeGroups,
CORBA::Boolean LinearVariation = false,
CORBA::Boolean ByAverageNormal = false, CORBA::Boolean ByAverageNormal = false,
CORBA::Boolean UseInputElemsOnly = false, CORBA::Boolean UseInputElemsOnly = false,
CORBA::Long Flags = 0, CORBA::Long Flags = 0,
@ -2492,18 +2493,24 @@ namespace MeshEditor_I
if ( MakeGroups ) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_GROUPS; if ( MakeGroups ) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_GROUPS;
if ( ByAverageNormal ) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_BY_AVG_NORMAL; if ( ByAverageNormal ) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_BY_AVG_NORMAL;
if ( UseInputElemsOnly) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_USE_INPUT_ELEMS_ONLY; if ( UseInputElemsOnly) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_USE_INPUT_ELEMS_ONLY;
if ( LinearVariation ) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_SCALE_LINEAR_VARIATION;
if ( MakeBoundary ) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_BOUNDARY; if ( MakeBoundary ) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_BOUNDARY;
return Flags; return Flags;
} }
// standard params // standard params
ExtrusionParams(const SMESH::DirStruct & theDir, ExtrusionParams(const SMESH::DirStruct & theDir,
CORBA::Long theNbOfSteps, CORBA::Long theNbOfSteps,
const SMESH::double_array & theScaleFactors,
CORBA::Boolean theLinearVariation,
const SMESH::double_array & theBasePoint,
CORBA::Boolean theMakeGroups): CORBA::Boolean theMakeGroups):
::SMESH_MeshEditor::ExtrusParam ( gp_Vec( theDir.PS.x, ::SMESH_MeshEditor::ExtrusParam ( gp_Vec( theDir.PS.x,
theDir.PS.y, theDir.PS.y,
theDir.PS.z ), theDir.PS.z ),
theNbOfSteps, theNbOfSteps,
makeFlags( theMakeGroups )), toList( theScaleFactors ),
TBasePoint( theBasePoint ),
makeFlags( theMakeGroups, theLinearVariation )),
myIsExtrusionByNormal( false ) myIsExtrusionByNormal( false )
{ {
} }
@ -2517,7 +2524,9 @@ namespace MeshEditor_I
theDir.PS.y, theDir.PS.y,
theDir.PS.z ), theDir.PS.z ),
theNbOfSteps, theNbOfSteps,
makeFlags( theMakeGroups, false, false, std::list<double>(),
0,
makeFlags( theMakeGroups, false, false, false,
theExtrFlags, false ), theExtrFlags, false ),
theSewTolerance ), theSewTolerance ),
myIsExtrusionByNormal( false ) myIsExtrusionByNormal( false )
@ -2532,7 +2541,7 @@ namespace MeshEditor_I
CORBA::Boolean theMakeGroups ): CORBA::Boolean theMakeGroups ):
::SMESH_MeshEditor::ExtrusParam ( theStepSize, ::SMESH_MeshEditor::ExtrusParam ( theStepSize,
theNbOfSteps, theNbOfSteps,
makeFlags( theMakeGroups, makeFlags( theMakeGroups, false,
theByAverageNormal, theUseInputElemsOnly ), theByAverageNormal, theUseInputElemsOnly ),
theDim), theDim),
myIsExtrusionByNormal( true ) myIsExtrusionByNormal( true )
@ -2543,6 +2552,32 @@ namespace MeshEditor_I
{ {
Flags() &= ~(::SMESH_MeshEditor::EXTRUSION_FLAG_GROUPS); Flags() &= ~(::SMESH_MeshEditor::EXTRUSION_FLAG_GROUPS);
} }
private:
static std::list<double> toList( const SMESH::double_array & theScaleFactors )
{
std::list<double> scales;
for ( CORBA::ULong i = 0; i < theScaleFactors.length(); ++i )
scales.push_back( theScaleFactors[i] );
return scales;
}
// structure used to convert SMESH::double_array to gp_XYZ*
struct TBasePoint
{
gp_XYZ *pp, p;
TBasePoint( const SMESH::double_array & theBasePoint )
{
pp = 0;
if ( theBasePoint.length() == 3 )
{
p.SetCoord( theBasePoint[0], theBasePoint[1], theBasePoint[2] );
pp = &p;
}
}
operator const gp_XYZ*() const { return pp; }
};
}; };
} }
@ -2566,13 +2601,17 @@ SMESH_MeshEditor_i::ExtrusionSweepObjects(const SMESH::ListOfIDSources & theNode
const SMESH::ListOfIDSources & theFaces, const SMESH::ListOfIDSources & theFaces,
const SMESH::DirStruct & theStepVector, const SMESH::DirStruct & theStepVector,
CORBA::Long theNbOfSteps, CORBA::Long theNbOfSteps,
const SMESH::double_array & theScaleFactors,
CORBA::Boolean theLinearVariation,
const SMESH::double_array & theBasePoint,
CORBA::Boolean theToMakeGroups) CORBA::Boolean theToMakeGroups)
throw (SALOME::SALOME_Exception) throw (SALOME::SALOME_Exception)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
ExtrusionParams params( theStepVector, theNbOfSteps, theToMakeGroups ); ExtrusionParams params( theStepVector, theNbOfSteps, theScaleFactors,
theLinearVariation, theBasePoint, theToMakeGroups );
TIDSortedElemSet elemsNodes[2]; TIDSortedElemSet elemsNodes[2];
for ( int i = 0, nb = theNodes.length(); i < nb; ++i ) { for ( int i = 0, nb = theNodes.length(); i < nb; ++i ) {
@ -2916,13 +2955,13 @@ SMESH_MeshEditor_i::ExtrusionAlongPathObjects(const SMESH::ListOfIDSources & the
<< thePathShape << ", " << thePathShape << ", "
<< theNodeStart << ", " << theNodeStart << ", "
<< theHasAngles << ", " << theHasAngles << ", "
<< theAngles << ", " << TVar( theAngles ) << ", "
<< theLinearVariation << ", " << theLinearVariation << ", "
<< theHasRefPoint << ", " << theHasRefPoint << ", "
<< "SMESH.PointStruct( " << "SMESH.PointStruct( "
<< ( theHasRefPoint ? theRefPoint.x : 0 ) << ", " << TVar( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
<< ( theHasRefPoint ? theRefPoint.y : 0 ) << ", " << TVar( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
<< ( theHasRefPoint ? theRefPoint.z : 0 ) << " ), " << TVar( theHasRefPoint ? theRefPoint.z : 0 ) << " ), "
<< theMakeGroups << " )"; << theMakeGroups << " )";
} }
else else

View File

@ -330,6 +330,9 @@ public:
const SMESH::ListOfIDSources & faces, const SMESH::ListOfIDSources & faces,
const SMESH::DirStruct & stepVector, const SMESH::DirStruct & stepVector,
CORBA::Long nbOfSteps, CORBA::Long nbOfSteps,
const SMESH::double_array & theScaleFactors,
CORBA::Boolean theLinearVariation,
const SMESH::double_array & theBasePoint,
CORBA::Boolean toMakeGroups) CORBA::Boolean toMakeGroups)
throw (SALOME::SALOME_Exception); throw (SALOME::SALOME_Exception);

View File

@ -3820,17 +3820,27 @@ class Mesh:
NbOfSteps, Tolerance, MakeGroups, TotalAngle) NbOfSteps, Tolerance, MakeGroups, TotalAngle)
## Generates new elements by extrusion of the given elements and nodes ## Generates new elements by extrusion of the given elements and nodes
# @param nodes - nodes to extrude: a list including ids, groups, sub-meshes or a mesh # @param nodes nodes to extrude: a list including ids, groups, sub-meshes or a mesh
# @param edges - edges to extrude: a list including ids, groups, sub-meshes or a mesh # @param edges edges to extrude: a list including ids, groups, sub-meshes or a mesh
# @param faces - faces to extrude: a list including ids, groups, sub-meshes or a mesh # @param faces faces to extrude: a list including ids, groups, sub-meshes or a mesh
# @param StepVector vector or DirStruct or 3 vector components, defining # @param StepVector vector or DirStruct or 3 vector components, defining
# the direction and value of extrusion for one step (the total extrusion # the direction and value of extrusion for one step (the total extrusion
# length will be NbOfSteps * ||StepVector||) # length will be NbOfSteps * ||StepVector||)
# @param NbOfSteps the number of steps # @param NbOfSteps the number of steps
# @param MakeGroups forces the generation of new groups from existing ones # @param MakeGroups forces the generation of new groups from existing ones
# @param scaleFactors optional scale factors to apply during extrusion
# @param linearVariation if @c True, scaleFactors are spread over all @a scaleFactors,
# else scaleFactors[i] is applied to nodes at the i-th extrusion step
# @param basePoint optional scaling center; if not provided, a gravity center of
# nodes and elements being extruded is used as the scaling center.
# It can be either
# - a list of tree components of the point or
# - a node ID or
# - a GEOM point
# @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise # @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
# @ingroup l2_modif_extrurev # @ingroup l2_modif_extrurev
def ExtrusionSweepObjects(self, nodes, edges, faces, StepVector, NbOfSteps, MakeGroups=False): def ExtrusionSweepObjects(self, nodes, edges, faces, StepVector, NbOfSteps, MakeGroups=False,
scaleFactors=[], linearVariation=False, basePoint=[] ):
unRegister = genObjUnRegister() unRegister = genObjUnRegister()
nodes = self._getIdSourceList( nodes, SMESH.NODE, unRegister ) nodes = self._getIdSourceList( nodes, SMESH.NODE, unRegister )
edges = self._getIdSourceList( edges, SMESH.EDGE, unRegister ) edges = self._getIdSourceList( edges, SMESH.EDGE, unRegister )
@ -3841,12 +3851,22 @@ class Mesh:
if isinstance( StepVector, list ): if isinstance( StepVector, list ):
StepVector = self.smeshpyD.MakeDirStruct(*StepVector) StepVector = self.smeshpyD.MakeDirStruct(*StepVector)
if isinstance( basePoint, int):
xyz = self.GetNodeXYZ( basePoint )
if not xyz:
raise RuntimeError, "Invalid node ID: %s" % basePoint
basePoint = xyz
if isinstance( basePoint, geomBuilder.GEOM._objref_GEOM_Object ):
basePoint = self.geompyD.PointCoordinates( basePoint )
NbOfSteps,Parameters,hasVars = ParseParameters(NbOfSteps) NbOfSteps,Parameters,hasVars = ParseParameters(NbOfSteps)
Parameters = StepVector.PS.parameters + var_separator + Parameters Parameters = StepVector.PS.parameters + var_separator + Parameters
self.mesh.SetParameters(Parameters) self.mesh.SetParameters(Parameters)
return self.editor.ExtrusionSweepObjects( nodes, edges, faces, return self.editor.ExtrusionSweepObjects( nodes, edges, faces,
StepVector, NbOfSteps, MakeGroups) StepVector, NbOfSteps,
scaleFactors, linearVariation, basePoint,
MakeGroups)
## Generates new elements by extrusion of the elements with given ids ## Generates new elements by extrusion of the elements with given ids

View File

@ -732,13 +732,13 @@ protected:
void StdMeshers_RadialQuadrangle_1D2D::SubmeshRestored(SMESH_subMesh* faceSubMesh) void StdMeshers_RadialQuadrangle_1D2D::SubmeshRestored(SMESH_subMesh* faceSubMesh)
{ {
// if ( !faceSubMesh->IsEmpty() ) if ( !faceSubMesh->IsEmpty() )
// { {
// for ( TopExp_Explorer e( faceSubMesh->GetSubShape(), TopAbs_EDGE ); e.More(); e.Next() ) for ( TopExp_Explorer e( faceSubMesh->GetSubShape(), TopAbs_EDGE ); e.More(); e.Next() )
// { {
// markEdgeAsComputedByMe( TopoDS::Edge( e.Current() ), faceSubMesh ); markEdgeAsComputedByMe( TopoDS::Edge( e.Current() ), faceSubMesh );
// } }
// } }
} }
//======================================================================= //=======================================================================
@ -762,12 +762,12 @@ bool StdMeshers_RadialQuadrangle_1D2D::Compute(SMESH_Mesh& aMesh,
"of edges is less or equal to 3 and one of them is an ellipse curve)"); "of edges is less or equal to 3 and one of them is an ellipse curve)");
// get not yet computed EDGEs // get not yet computed EDGEs
// list< TopoDS_Edge > emptyEdges; list< TopoDS_Edge > emptyEdges;
// for ( TopExp_Explorer e( aShape, TopAbs_EDGE ); e.More(); e.Next() ) for ( TopExp_Explorer e( aShape, TopAbs_EDGE ); e.More(); e.Next() )
// { {
// if ( aMesh.GetSubMesh( e.Current() )->IsEmpty() ) if ( aMesh.GetSubMesh( e.Current() )->IsEmpty() )
// emptyEdges.push_back( TopoDS::Edge( e.Current() )); emptyEdges.push_back( TopoDS::Edge( e.Current() ));
// } }
TNodeDistributor* algo1d = TNodeDistributor::GetDistributor(aMesh); TNodeDistributor* algo1d = TNodeDistributor::GetDistributor(aMesh);
@ -941,9 +941,9 @@ bool StdMeshers_RadialQuadrangle_1D2D::Compute(SMESH_Mesh& aMesh,
centerUV = nodes2.back().UV(); centerUV = nodes2.back().UV();
} }
// list< TopoDS_Edge >::iterator ee = emptyEdges.begin(); list< TopoDS_Edge >::iterator ee = emptyEdges.begin();
// for ( ; ee != emptyEdges.end(); ++ee ) for ( ; ee != emptyEdges.end(); ++ee )
// markEdgeAsComputedByMe( *ee, aMesh.GetSubMesh( F )); markEdgeAsComputedByMe( *ee, aMesh.GetSubMesh( F ));
circSide->GetUVPtStruct(); // let sides take into account just computed nodes circSide->GetUVPtStruct(); // let sides take into account just computed nodes
linSide1->GetUVPtStruct(); linSide1->GetUVPtStruct();