ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-12-24 16:30:34 +05:00
Code Issues Packages Projects Releases Wiki Activity

Remove last wrong commits.

Browse Source
This commit is contained in:
rnv 2014-07-16 17:43:58 +04:00
parent b5a71c53ed
commit a6c877f633
24 changed files with 127 additions and 1258 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
doc/salome/examples/defining_hypotheses_adaptive1d.py
View File

@ -19,14 +19,12 @@ shape = geompy.MakeCut( shape, tool, theName="shape" )
# Parameters of Adaptive hypothesis. minSize and maxSize are such that they do not limit # Parameters of Adaptive hypothesis. minSize and maxSize are such that they do not limit
# size of segments because size of geometrical features lies within [2.-100.] range, hence # size of segments because size of geometrical features lies within [2.-100.] range, hence
# size of segments is defined by deflection parameter and size of geometrical features only. # size of segments is defined by deflection parameter and size of geometrical features only.
# grading is defined how much size of adjacent elements can differ.
minSize = 0.1 minSize = 0.1
maxSize = 200 maxSize = 200
deflection = 0.05 deflection = 0.05
grading = 0.7
mesh = smesh.Mesh( shape ) mesh = smesh.Mesh( shape )
mesh.Segment().Adaptive( minSize, maxSize, deflection, grading ) mesh.Segment().Adaptive( minSize, maxSize, deflection )
mesh.Triangle().MaxElementArea( 300 ) mesh.Triangle().MaxElementArea( 300 )
mesh.Compute() mesh.Compute()

BIN
doc/salome/gui/SMESH/images/adaptive1d.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 14 KiB

After

Width:  |  Height:  |  Size: 16 KiB

4
doc/salome/gui/SMESH/input/1d_meshing_hypo.doc
View File

@ -31,8 +31,8 @@ creation of narrow 2D elements.
- <b>Min size</b> parameter limits the minimal segment size. - <b>Min size</b> parameter limits the minimal segment size.
- <b>Max size</b> parameter defines the length of segments on straight edges. - <b>Max size</b> parameter defines the length of segments on straight edges.
- <b>Deflection</b> parameter gives maximal distance of a segment from a curved edge. - \b Deflection parameter gives maximal distance of a segment from a curved edge.
- <b>Grading</b> parameter defines how much size of adjacent elements can differ.
\image html adaptive1d_sample_mesh.png "Adaptive hypothesis and Netgen 2D algorithm - the size of mesh segments reflects the size of geometrical features" \image html adaptive1d_sample_mesh.png "Adaptive hypothesis and Netgen 2D algorithm - the size of mesh segments reflects the size of geometrical features"
<b>See Also</b> a \ref tui_1d_adaptive "sample TUI Script" that uses Adaptive hypothesis. <b>See Also</b> a \ref tui_1d_adaptive "sample TUI Script" that uses Adaptive hypothesis.

7
idl/SMESH_BasicHypothesis.idl
View File

@ -433,13 +433,6 @@ module StdMeshers
*/ */
void SetDeflection(in double deflection) raises (SALOME::SALOME_Exception); void SetDeflection(in double deflection) raises (SALOME::SALOME_Exception);
double GetDeflection(); double GetDeflection();
/*!
* Sets <grading> parameter value,
* i.e. how much size of adjacent elements can differ
*/
void SetGrading(in double grading) raises (SALOME::SALOME_Exception);
double GetGrading();
}; };
/*! /*!

4
resources/StdMeshers.xml.in
View File

@ -236,7 +236,7 @@
<hypo>GeometricProgression=GeometricProgression(SetStartLength(),SetCommonRatio(),SetReversedEdges())</hypo> <hypo>GeometricProgression=GeometricProgression(SetStartLength(),SetCommonRatio(),SetReversedEdges())</hypo>
<hypo>StartEndLength=StartEndLength(SetStartLength(),SetEndLength(),SetReversedEdges())</hypo> <hypo>StartEndLength=StartEndLength(SetStartLength(),SetEndLength(),SetReversedEdges())</hypo>
<hypo>Deflection1D=Deflection1D(SetDeflection())</hypo> <hypo>Deflection1D=Deflection1D(SetDeflection())</hypo>
<hypo>Adaptive1D=Adaptive(SetMinSize(),SetMaxSize(),SetDeflection(),SetGrading())</hypo> <hypo>Adaptive1D=Adaptive(SetMinSize(),SetMaxSize(),SetDeflection())</hypo>
<hypo>AutomaticLength=AutomaticLength(SetFineness())</hypo> <hypo>AutomaticLength=AutomaticLength(SetFineness())</hypo>
<hypo>FixedPoints1D=FixedPoints1D(SetPoints(),SetNbSegments(),SetReversedEdges())</hypo> <hypo>FixedPoints1D=FixedPoints1D(SetPoints(),SetNbSegments(),SetReversedEdges())</hypo>
<hypo>Propagation=Propagation()</hypo> <hypo>Propagation=Propagation()</hypo>
@ -262,7 +262,7 @@
<hypo>GeometricProgression=GeometricProgression(SetStartLength(),SetCommonRatio(),SetReversedEdges())</hypo> <hypo>GeometricProgression=GeometricProgression(SetStartLength(),SetCommonRatio(),SetReversedEdges())</hypo>
<hypo>StartEndLength=StartEndLength(SetStartLength(),SetEndLength(),SetReversedEdges())</hypo> <hypo>StartEndLength=StartEndLength(SetStartLength(),SetEndLength(),SetReversedEdges())</hypo>
<hypo>Deflection1D=Deflection1D(SetDeflection())</hypo> <hypo>Deflection1D=Deflection1D(SetDeflection())</hypo>
<hypo>Adaptive1D=Adaptive(SetMinSize(),SetMaxSize(),SetDeflection(),SetGrading())</hypo> <hypo>Adaptive1D=Adaptive(SetMinSize(),SetMaxSize(),SetDeflection())</hypo>
<hypo>AutomaticLength=AutomaticLength(SetFineness())</hypo> <hypo>AutomaticLength=AutomaticLength(SetFineness())</hypo>
<hypo>FixedPoints1D=FixedPoints1D(SetPoints(),SetNbSegments(),SetReversedEdges())</hypo> <hypo>FixedPoints1D=FixedPoints1D(SetPoints(),SetNbSegments(),SetReversedEdges())</hypo>
<hypo>Propagation=Propagation()</hypo> <hypo>Propagation=Propagation()</hypo>

98
src/SMESHGUI/SMESHGUI_AddMeshElementDlg.cxx
View File

@ -413,26 +413,14 @@ SMESHGUI_AddMeshElementDlg::SMESHGUI_AddMeshElementDlg( SMESHGUI* theMo
Reverse = (myElementType == SMDSAbs_Face || myElementType == SMDSAbs_Volume ) ? new QCheckBox(tr("SMESH_REVERSE"), GroupC1) : 0; Reverse = (myElementType == SMDSAbs_Face || myElementType == SMDSAbs_Volume ) ? new QCheckBox(tr("SMESH_REVERSE"), GroupC1) : 0;
AutomaticPresentation = (myGeomType == SMDSEntity_Quadrangle || myGeomType == SMDSEntity_Polygon ||
myGeomType == SMDSEntity_Pyramid || myGeomType == SMDSEntity_Hexa ||
myGeomType == SMDSEntity_Penta || myGeomType == SMDSEntity_Hexagonal_Prism ) ? new QCheckBox(tr("SMESH_AUTOMATIC_PRESENTATION"), GroupC1) : 0;
if ( AutomaticPresentation ) {
GetNextPresentationButton = new QPushButton(tr("SMESH_BUT_GET_NEXT_SHAPE"), GroupC1);
GetNextPresentationButton->setAutoDefault(false);
}
DiameterSpinBox = ( myGeomType == SMDSEntity_Ball ) ? new SMESHGUI_SpinBox(GroupC1) : 0; DiameterSpinBox = ( myGeomType == SMDSEntity_Ball ) ? new SMESHGUI_SpinBox(GroupC1) : 0;
QLabel* diameterLabel = DiameterSpinBox ? new QLabel( tr("BALL_DIAMETER"),GroupC1) : 0; QLabel* diameterLabel = DiameterSpinBox ? new QLabel( tr("BALL_DIAMETER"),GroupC1) : 0;
GroupC1Layout->addWidget(TextLabelC1A1, 0, 0); GroupC1Layout->addWidget(TextLabelC1A1, 0, 0);
GroupC1Layout->addWidget(SelectButtonC1A1, 0, 1); GroupC1Layout->addWidget(SelectButtonC1A1, 0, 1);
GroupC1Layout->addWidget(LineEditC1A1, 0, 2); GroupC1Layout->addWidget(LineEditC1A1, 0, 2);
if ( AutomaticPresentation ) {
AutomaticPresentation->setChecked(true);
GroupC1Layout->addWidget(AutomaticPresentation, 1, 0, 1, 2);
GroupC1Layout->addWidget(GetNextPresentationButton, 1, 2, 1, 1);
}
if ( Reverse ) { if ( Reverse ) {
GroupC1Layout->addWidget(Reverse, 2, 0, 1, 3); GroupC1Layout->addWidget(Reverse, 1, 0, 1, 3);
} }
if ( DiameterSpinBox ) { if ( DiameterSpinBox ) {
GroupC1Layout->addWidget(diameterLabel, 1, 0); GroupC1Layout->addWidget(diameterLabel, 1, 0);
@ -518,25 +506,22 @@ void SMESHGUI_AddMeshElementDlg::Init()
myActor = 0; myActor = 0;
/* signals and slots connections */ /* signals and slots connections */
connect(buttonOk, SIGNAL(clicked()), SLOT(ClickOnOk())); connect(buttonOk, SIGNAL(clicked()), SLOT(ClickOnOk()));
connect(buttonCancel, SIGNAL(clicked()), SLOT(reject())); connect(buttonCancel, SIGNAL(clicked()), SLOT(reject()));
connect(buttonApply, SIGNAL(clicked()), SLOT(ClickOnApply())); connect(buttonApply, SIGNAL(clicked()), SLOT(ClickOnApply()));
connect(buttonHelp, SIGNAL(clicked()), SLOT(ClickOnHelp())); connect(buttonHelp, SIGNAL(clicked()), SLOT(ClickOnHelp()));
connect(SelectButtonC1A1, SIGNAL(clicked()), SLOT(SetEditCurrentArgument())); connect(SelectButtonC1A1,SIGNAL(clicked()), SLOT(SetEditCurrentArgument()));
connect(LineEditC1A1, SIGNAL(textChanged(const QString&)), SLOT(onTextChange(const QString&))); connect(LineEditC1A1, SIGNAL(textChanged(const QString&)), SLOT(onTextChange(const QString&)));
connect(mySMESHGUI, SIGNAL(SignalDeactivateActiveDialog()),SLOT(DeactivateActiveDialog())); connect(mySMESHGUI, SIGNAL(SignalDeactivateActiveDialog()),SLOT(DeactivateActiveDialog()));
connect(mySelectionMgr, SIGNAL(currentSelectionChanged()), SLOT(SelectionIntoArgument())); connect(mySelectionMgr, SIGNAL(currentSelectionChanged()), SLOT(SelectionIntoArgument()));
/* to close dialog if study frame change */ /* to close dialog if study frame change */
connect(mySMESHGUI, SIGNAL(SignalStudyFrameChanged()), SLOT(reject())); connect(mySMESHGUI, SIGNAL(SignalStudyFrameChanged()), SLOT(reject()));
connect(mySMESHGUI, SIGNAL(SignalCloseAllDialogs()), SLOT(reject())); connect(mySMESHGUI, SIGNAL(SignalCloseAllDialogs()), SLOT(reject()));
if (Reverse) if (Reverse)
connect(Reverse, SIGNAL(stateChanged(int)), SLOT(CheckBox(int))); connect(Reverse, SIGNAL(stateChanged(int)), SLOT(CheckBox(int)));
if (AutomaticPresentation) {
connect(AutomaticPresentation, SIGNAL(stateChanged(int)), SLOT(SelectionIntoArgument()));
connect(GetNextPresentationButton, SIGNAL(clicked()), SLOT(GetNextShapePresentation()));
}
// set selection mode // set selection mode
SMESH::SetPointRepresentation(true); SMESH::SetPointRepresentation(true);
@ -664,8 +649,6 @@ void SMESHGUI_AddMeshElementDlg::ClickOnApply()
buttonOk->setEnabled(false); buttonOk->setEnabled(false);
buttonApply->setEnabled(false); buttonApply->setEnabled(false);
if ( AutomaticPresentation )
GetNextPresentationButton->setEnabled(false);
myEditCurrentArgument->setText(""); myEditCurrentArgument->setText("");
@ -738,8 +721,6 @@ void SMESHGUI_AddMeshElementDlg::onTextChange (const QString& theNewText)
buttonOk->setEnabled(false); buttonOk->setEnabled(false);
buttonApply->setEnabled(false); buttonApply->setEnabled(false);
if ( AutomaticPresentation )
GetNextPresentationButton->setEnabled(false);
mySimulation->SetVisibility(false); mySimulation->SetVisibility(false);
@ -781,8 +762,6 @@ void SMESHGUI_AddMeshElementDlg::onTextChange (const QString& theNewText)
if(myNbOkNodes) { if(myNbOkNodes) {
buttonOk->setEnabled(true); buttonOk->setEnabled(true);
buttonApply->setEnabled(true); buttonApply->setEnabled(true);
if ( AutomaticPresentation && AutomaticPresentation->isChecked() )
GetNextPresentationButton->setEnabled(true);
displaySimulation(); displaySimulation();
} }
@ -802,7 +781,6 @@ void SMESHGUI_AddMeshElementDlg::SelectionIntoArgument()
myActor = 0; myActor = 0;
myBusy = true; myBusy = true;
QString anOldEditArgument = myEditCurrentArgument->text();
myEditCurrentArgument->setText(""); myEditCurrentArgument->setText("");
myBusy = false; myBusy = false;
@ -811,8 +789,6 @@ void SMESHGUI_AddMeshElementDlg::SelectionIntoArgument()
buttonOk->setEnabled(false); buttonOk->setEnabled(false);
buttonApply->setEnabled(false); buttonApply->setEnabled(false);
if ( AutomaticPresentation )
GetNextPresentationButton->setEnabled(false);
mySimulation->SetVisibility(false); mySimulation->SetVisibility(false);
// SMESH::SetPointRepresentation(true); // SMESH::SetPointRepresentation(true);
@ -856,34 +832,14 @@ void SMESHGUI_AddMeshElementDlg::SelectionIntoArgument()
// get selected nodes // get selected nodes
QString aString = ""; QString aString = "";
int nbNodes = 0; int nbNodes = SMESH::GetNameOfSelectedNodes(mySelector,myActor->getIO(),aString);
while ( aString == "" || anOldEditArgument == aString ) { myBusy = true;
if ( AutomaticPresentation && AutomaticPresentation->isChecked() ) { myEditCurrentArgument->setText(aString);
nbNodes = SMESH::GetNameOfSelectedSortedNodes( myGeomType , mySelector, myActor, myShift, aString ); myBusy = false;
} if (myIsPoly && myElementType == SMDSAbs_Face && nbNodes >= 3 ) {
else myNbNodes = nbNodes;
nbNodes = SMESH::GetNameOfSelectedNodes( mySelector, myActor->getIO(), aString ); } else if (myNbNodes != nbNodes && myNbNodes != 1) {
if ( aString!= "" && myNbNodes == nbNodes && anOldEditArgument == aString && AutomaticPresentation && AutomaticPresentation->isChecked()) { return;
myShift++;
if ( myShift > nbNodes ) {
myEditCurrentArgument->setText(aString);
myShift = 0;
break;
}
continue;
}
myBusy = true;
myEditCurrentArgument->setText(aString);
myBusy = false;
if (myIsPoly && myElementType == SMDSAbs_Face && nbNodes >= 3 )
myNbNodes = nbNodes;
else if (myNbNodes != nbNodes && myNbNodes != 1) {
myShift = 0;
return;
}
if ( !AutomaticPresentation || !AutomaticPresentation->isChecked() ||
( myIsPoly && nbNodes < 3 ) )
break;
} }
// OK // OK
@ -891,8 +847,6 @@ void SMESHGUI_AddMeshElementDlg::SelectionIntoArgument()
buttonOk->setEnabled(true); buttonOk->setEnabled(true);
buttonApply->setEnabled(true); buttonApply->setEnabled(true);
if ( AutomaticPresentation && AutomaticPresentation->isChecked() )
GetNextPresentationButton->setEnabled(true);
displaySimulation(); displaySimulation();
} }
@ -942,16 +896,6 @@ void SMESHGUI_AddMeshElementDlg::SetEditCurrentArgument()
SelectionIntoArgument(); SelectionIntoArgument();
} }
//=================================================================================
// function : GetNextShapePresentation()
// purpose :
//=================================================================================
void SMESHGUI_AddMeshElementDlg::GetNextShapePresentation()
{
myShift++;
SetEditCurrentArgument();
}
//================================================================================= //=================================================================================
// function : DeactivateActiveDialog() // function : DeactivateActiveDialog()
// purpose : // purpose :

4
src/SMESHGUI/SMESHGUI_AddMeshElementDlg.h
View File

@ -90,7 +90,6 @@ private:
int myElementType; int myElementType;
int myNbNodes; int myNbNodes;
bool myIsPoly; bool myIsPoly;
int myShift;
SMESH::SMESH_Mesh_var myMesh; SMESH::SMESH_Mesh_var myMesh;
SMESH_Actor* myActor; SMESH_Actor* myActor;
@ -111,10 +110,8 @@ private:
QGroupBox* GroupC1; QGroupBox* GroupC1;
QLabel* TextLabelC1A1; QLabel* TextLabelC1A1;
QPushButton* SelectButtonC1A1; QPushButton* SelectButtonC1A1;
QPushButton* GetNextPresentationButton;
QLineEdit* LineEditC1A1; QLineEdit* LineEditC1A1;
QCheckBox* Reverse; QCheckBox* Reverse;
QCheckBox* AutomaticPresentation;
SMESHGUI_SpinBox* DiameterSpinBox; SMESHGUI_SpinBox* DiameterSpinBox;
QString myHelpFileName; QString myHelpFileName;
@ -127,7 +124,6 @@ private slots:
void ClickOnOk(); void ClickOnOk();
void ClickOnApply(); void ClickOnApply();
void ClickOnHelp(); void ClickOnHelp();
void GetNextShapePresentation();
void SetEditCurrentArgument(); void SetEditCurrentArgument();
void SelectionIntoArgument(); void SelectionIntoArgument();
void DeactivateActiveDialog(); void DeactivateActiveDialog();

286
src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.cxx
View File

@ -36,7 +36,6 @@
#include <SMESH_Actor.h> #include <SMESH_Actor.h>
#include <SMESH_ActorUtils.h> #include <SMESH_ActorUtils.h>
#include <SMESH_DeviceActor.h>
#include <SMESH_FaceOrientationFilter.h> #include <SMESH_FaceOrientationFilter.h>
#include <SMDS_Mesh.hxx> #include <SMDS_Mesh.hxx>
@ -53,8 +52,6 @@
#include <SVTK_ViewWindow.h> #include <SVTK_ViewWindow.h>
#include <SALOME_ListIO.hxx> #include <SALOME_ListIO.hxx>
#include <SALOME_ListIteratorOfListIO.hxx>
#include <VTKViewer_PolyDataMapper.h>
#include <SalomeApp_Application.h> #include <SalomeApp_Application.h>
@ -68,14 +65,12 @@
#include <TColStd_MapOfInteger.hxx> #include <TColStd_MapOfInteger.hxx>
// VTK includes // VTK includes
#include <vtkCell.h>
#include <vtkIdList.h> #include <vtkIdList.h>
#include <vtkUnstructuredGrid.h> #include <vtkUnstructuredGrid.h>
#include <vtkDataSetMapper.h> #include <vtkDataSetMapper.h>
#include <vtkPolyDataMapper.h> #include <vtkPolyDataMapper.h>
#include <vtkProperty.h> #include <vtkProperty.h>
#include <vtkCellType.h> #include <vtkCellType.h>
#include <vtkCellData.h>
// Qt includes // Qt includes
#include <QComboBox> #include <QComboBox>
@ -126,14 +121,7 @@ namespace SMESH
SALOME_Actor* myPreviewActor; SALOME_Actor* myPreviewActor;
vtkDataSetMapper* myMapper; vtkDataSetMapper* myMapper;
vtkUnstructuredGrid* myGrid; vtkUnstructuredGrid* myGrid;
//vtkProperty* myBackProp, *myProp;
SALOME_Actor* myCornerActor;
VTKViewer_PolyDataMapper* myCornerMapper;
vtkPolyData* myCornerPolyData;
SALOME_Actor* mySelectCornerActor;
VTKViewer_PolyDataMapper* mySelectCornerMapper;
vtkPolyData* mySelectCornerPolyData;
//double myRGB[3], myBackRGB[3]; //double myRGB[3], myBackRGB[3];
@ -198,45 +186,6 @@ namespace SMESH
anOrientationProp->Delete(); anOrientationProp->Delete();
myVTKViewWindow->AddActor(myFaceOrientation); myVTKViewWindow->AddActor(myFaceOrientation);
// Create and display actor with corner nodes
myCornerPolyData = vtkPolyData::New();
myCornerPolyData->Allocate();
myCornerMapper = VTKViewer_PolyDataMapper::New();
myCornerMapper->SetInputData(myCornerPolyData);
myCornerMapper->SetMarkerEnabled(true);
myCornerActor = SALOME_Actor::New();
myCornerActor->PickableOff();
myCornerActor->VisibilityOff();
myCornerActor->SetMapper(myCornerMapper);
vtkProperty* myCornerProp = vtkProperty::New();
myCornerProp->SetColor( 50 / 255. , 100 / 255. , 0 / 255. );
myCornerActor->SetProperty( myCornerProp );
myCornerProp->Delete();
myVTKViewWindow->AddActor(myCornerActor);
// Create and display actor with selected corner nodes
mySelectCornerPolyData = vtkPolyData::New();
mySelectCornerPolyData->Allocate();
mySelectCornerMapper = VTKViewer_PolyDataMapper::New();
mySelectCornerMapper->SetInputData(mySelectCornerPolyData);
mySelectCornerMapper->SetMarkerEnabled(true);
mySelectCornerActor = SALOME_Actor::New();
mySelectCornerActor->PickableOff();
mySelectCornerActor->VisibilityOff();
mySelectCornerActor->SetMapper(mySelectCornerMapper);
vtkProperty* mySelectCornerProp = vtkProperty::New();
mySelectCornerProp->SetColor( ffc.red() / 255. , ffc.green() / 255. , ffc.blue() / 255. );
mySelectCornerActor->SetProperty( mySelectCornerProp );
mySelectCornerProp->Delete();
myVTKViewWindow->AddActor(mySelectCornerActor);
} }
typedef std::vector<vtkIdType> TVTKIds; typedef std::vector<vtkIdType> TVTKIds;
@ -269,76 +218,26 @@ namespace SMESH
myPreviewActor->GetMapper()->Update(); myPreviewActor->GetMapper()->Update();
myPreviewActor->SetRepresentation( theMode ); myPreviewActor->SetRepresentation( theMode );
} SetVisibility(true, theActor->GetFacesOriented());
void SetCornerNodes (SMESH_Actor* theActor,
TVTKIds& theIds)
{
vtkUnstructuredGrid *aGrid = theActor->GetUnstructuredGrid();
myCornerMapper->SetMarkerStd(theActor->GetMarkerType(), theActor->GetMarkerScale());
myCornerPolyData->Reset();
myCornerPolyData->DeleteCells();
myCornerPolyData->SetPoints(aGrid->GetPoints());
vtkIdList *anIds = vtkIdList::New();
for (int i = 0, iEnd = theIds.size(); i < iEnd; i++) {
anIds->InsertId(i,theIds[i]);
myCornerPolyData->InsertNextCell(VTK_VERTEX, anIds);
anIds->Reset();
}
anIds->Delete();
myCornerPolyData->Modified();
myCornerActor->GetMapper()->Update();
myCornerActor->SetRepresentation(SMESH_Actor::ePoint);
}
void SetSelectedNodes (SMESH_Actor* theActor,
TVTKIds& theIds)
{
vtkUnstructuredGrid *aGrid = theActor->GetUnstructuredGrid();
mySelectCornerMapper->SetMarkerStd(theActor->GetMarkerType(), theActor->GetMarkerScale());
mySelectCornerPolyData->Reset();
mySelectCornerPolyData->DeleteCells();
mySelectCornerPolyData->SetPoints(aGrid->GetPoints());
vtkIdList *anIds = vtkIdList::New();
for (int i = 0, iEnd = theIds.size(); i < iEnd; i++) {
anIds->InsertId(i,theIds[i]);
mySelectCornerPolyData->InsertNextCell(VTK_VERTEX, anIds);
anIds->Reset();
}
anIds->Delete();
mySelectCornerPolyData->Modified();
mySelectCornerActor->GetMapper()->Update();
mySelectCornerActor->SetRepresentation(SMESH_Actor::ePoint);
} }
void SetVisibility ( bool theVisibility,
bool theCornerVisibility = false, void SetVisibility (bool theVisibility, bool theShowOrientation = false)
bool theSelectCornerVisibility = false,
bool theShowOrientation = false )
{ {
myPreviewActor->SetVisibility(theVisibility); myPreviewActor->SetVisibility(theVisibility);
myFaceOrientation->SetVisibility(theShowOrientation); myFaceOrientation->SetVisibility(theShowOrientation);
myCornerActor->SetVisibility(theCornerVisibility);
mySelectCornerActor->SetVisibility(theSelectCornerVisibility);
RepaintCurrentView(); RepaintCurrentView();
} }
~TElementSimulationQuad() ~TElementSimulationQuad()
{ {
if (FindVtkViewWindow(myApplication->activeViewManager(), myViewWindow)) { if (FindVtkViewWindow(myApplication->activeViewManager(), myViewWindow)) {
myVTKViewWindow->RemoveActor(myPreviewActor); myVTKViewWindow->RemoveActor(myPreviewActor);
myVTKViewWindow->RemoveActor(myFaceOrientation); myVTKViewWindow->RemoveActor(myFaceOrientation);
myVTKViewWindow->RemoveActor(myCornerActor);
myVTKViewWindow->RemoveActor(mySelectCornerActor);
} }
myPreviewActor->Delete(); myPreviewActor->Delete();
myFaceOrientation->Delete(); myFaceOrientation->Delete();
myCornerActor->Delete();
mySelectCornerActor->Delete();
myMapper->RemoveAllInputs(); myMapper->RemoveAllInputs();
myMapper->Delete(); myMapper->Delete();
@ -350,14 +249,6 @@ namespace SMESH
myGrid->Delete(); myGrid->Delete();
myCornerMapper->RemoveAllInputs();
myCornerMapper->Delete();
myCornerPolyData->Delete();
mySelectCornerMapper->RemoveAllInputs();
mySelectCornerMapper->Delete();
mySelectCornerPolyData->Delete();
// myProp->Delete(); // myProp->Delete();
// myBackProp->Delete(); // myBackProp->Delete();
} }
@ -552,30 +443,19 @@ SMESHGUI_AddQuadraticElementDlg::SMESHGUI_AddQuadraticElementDlg( SMESHGUI* theM
myCenterNode->setValidator(new SMESHGUI_IdValidator(this, 1)); myCenterNode->setValidator(new SMESHGUI_IdValidator(this, 1));
myReverseCB = new QCheckBox(tr("SMESH_REVERSE"), GroupArguments); myReverseCB = new QCheckBox(tr("SMESH_REVERSE"), GroupArguments);
myAutomaticPresentation = (myGeomType == SMDSEntity_Quad_Quadrangle || myGeomType == SMDSEntity_BiQuad_Quadrangle ||
myGeomType == SMDSEntity_Quad_Pyramid || myGeomType == SMDSEntity_Quad_Penta ||
myGeomType == SMDSEntity_Quad_Hexa || myGeomType == SMDSEntity_TriQuad_Hexa ) ? new QCheckBox(tr("SMESH_AUTOMATIC_PRESENTATION"), GroupArguments) : 0;
if ( myAutomaticPresentation ) {
myNextPresentationButton = new QPushButton(tr("SMESH_BUT_GET_NEXT_SHAPE"), GroupArguments);
myNextPresentationButton->setAutoDefault(false);
}
aGroupArgumentsLayout->addWidget(aCornerNodesLabel, 0, 0); aGroupArgumentsLayout->addWidget(aCornerNodesLabel, 0, 0);
aGroupArgumentsLayout->addWidget(myCornerSelectButton, 0, 1); aGroupArgumentsLayout->addWidget(myCornerSelectButton, 0, 1);
aGroupArgumentsLayout->addWidget(myCornerNodes, 0, 2); aGroupArgumentsLayout->addWidget(myCornerNodes, 0, 2);
if ( myAutomaticPresentation ) { aGroupArgumentsLayout->addWidget(myTable, 1, 0, 1, 3);
myAutomaticPresentation->setChecked(true); aGroupArgumentsLayout->addWidget(myMidFaceLabel, 2, 0);
aGroupArgumentsLayout->addWidget(myAutomaticPresentation, 1, 0, 1, 2); aGroupArgumentsLayout->addWidget(myMidFaceSelectButton, 2, 1);
aGroupArgumentsLayout->addWidget(myNextPresentationButton, 1, 2, 1, 1); aGroupArgumentsLayout->addWidget(myMidFaceNodes, 2, 2);
} aGroupArgumentsLayout->addWidget(myCenterLabel, 3, 0);
aGroupArgumentsLayout->addWidget(myTable, 2, 0, 1, 3); aGroupArgumentsLayout->addWidget(myCenterSelectButton, 3, 1);
aGroupArgumentsLayout->addWidget(myMidFaceLabel, 3, 0); aGroupArgumentsLayout->addWidget(myCenterNode, 3, 2);
aGroupArgumentsLayout->addWidget(myMidFaceSelectButton, 3, 1); aGroupArgumentsLayout->addWidget(myReverseCB, 4, 0, 1, 3);
aGroupArgumentsLayout->addWidget(myMidFaceNodes, 3, 2);
aGroupArgumentsLayout->addWidget(myCenterLabel, 4, 0);
aGroupArgumentsLayout->addWidget(myCenterSelectButton, 4, 1);
aGroupArgumentsLayout->addWidget(myCenterNode, 4, 2);
aGroupArgumentsLayout->addWidget(myReverseCB, 5, 0, 1, 3);
/***************************************************************/ /***************************************************************/
GroupGroups = new QGroupBox( tr( "SMESH_ADD_TO_GROUP" ), this ); GroupGroups = new QGroupBox( tr( "SMESH_ADD_TO_GROUP" ), this );
GroupGroups->setCheckable( true ); GroupGroups->setCheckable( true );
@ -770,10 +650,7 @@ void SMESHGUI_AddQuadraticElementDlg::Init()
connect(mySMESHGUI, SIGNAL (SignalDeactivateActiveDialog()), SLOT(DeactivateActiveDialog())); connect(mySMESHGUI, SIGNAL (SignalDeactivateActiveDialog()), SLOT(DeactivateActiveDialog()));
connect(mySMESHGUI, SIGNAL (SignalStudyFrameChanged()), SLOT(reject())); connect(mySMESHGUI, SIGNAL (SignalStudyFrameChanged()), SLOT(reject()));
connect(mySMESHGUI, SIGNAL (SignalCloseAllDialogs()), SLOT(reject())); connect(mySMESHGUI, SIGNAL (SignalCloseAllDialogs()), SLOT(reject()));
if (myAutomaticPresentation) {
connect(myAutomaticPresentation, SIGNAL(stateChanged(int)), SLOT(SetCurrentSelection()));
connect(myNextPresentationButton, SIGNAL(clicked()), SLOT(SetCurrentSelection()));
}
myCurrentLineEdit = myCornerNodes; myCurrentLineEdit = myCornerNodes;
// set selection mode // set selection mode
@ -1039,6 +916,7 @@ void SMESHGUI_AddQuadraticElementDlg::onTextChange (const QString& theNewText)
if ( myCurrentLineEdit == myCornerNodes ) if ( myCurrentLineEdit == myCornerNodes )
UpdateTable( allOk ); UpdateTable( allOk );
} }
updateButtons(); updateButtons();
displaySimulation(); displaySimulation();
} }
@ -1054,39 +932,41 @@ void SMESHGUI_AddQuadraticElementDlg::SelectionIntoArgument()
BusyLocker lock( myBusy ); BusyLocker lock( myBusy );
QString aCurrentEntry = myEntry; QString aCurrentEntry = myEntry;
QString anOldEditArgument = "";
// clear
myActor = 0;
if ( myCurrentLineEdit ) {
anOldEditArgument = myCurrentLineEdit->text();
myCurrentLineEdit->setText("");
}
if (!GroupButtons->isEnabled()) // inactive if ( myCurrentLineEdit )
return;
mySimulation->SetVisibility(false);
// get selected mesh
SALOME_ListIO aList;
mySelectionMgr->selectedObjects(aList);
if (aList.Extent() != 1)
{ {
UpdateTable(); // clear
updateButtons(); myActor = 0;
return;
}
Handle(SALOME_InteractiveObject) anIO = aList.First(); myCurrentLineEdit->setText("");
myEntry = anIO->getEntry();
myMesh = SMESH::GetMeshByIO(anIO);
if (myMesh->_is_nil()) {
updateButtons();
return;
}
myActor = SMESH::FindActorByEntry(anIO->getEntry()); if (!GroupButtons->isEnabled()) // inactive
return;
mySimulation->SetVisibility(false);
// get selected mesh
SALOME_ListIO aList;
mySelectionMgr->selectedObjects(aList);
if (aList.Extent() != 1)
{
UpdateTable();
updateButtons();
return;
}
Handle(SALOME_InteractiveObject) anIO = aList.First();
myEntry = anIO->getEntry();
myMesh = SMESH::GetMeshByIO(anIO);
if (myMesh->_is_nil()) {
updateButtons();
return;
}
myActor = SMESH::FindActorByEntry(anIO->getEntry());
}
// process groups // process groups
if ( !myMesh->_is_nil() && myEntry != aCurrentEntry ) { if ( !myMesh->_is_nil() && myEntry != aCurrentEntry ) {
@ -1126,42 +1006,18 @@ void SMESHGUI_AddQuadraticElementDlg::SelectionIntoArgument()
updateButtons(); updateButtons();
return; return;
} }
if ( myAutomaticPresentation )
myNextPresentationButton->setEnabled(false);
// get selected nodes // get selected nodes
QString aString = ""; QString aString = "";
int nbNodes = 0; int nbNodes = SMESH::GetNameOfSelectedNodes(mySelector,myActor->getIO(),aString);
while ( aString == "" || anOldEditArgument == aString ) {
if ( myAutomaticPresentation && myAutomaticPresentation->isChecked() ) {
nbNodes = SMESH::GetNameOfSelectedSortedNodes( myGeomType , mySelector, myActor, myShift, aString );
}
else
nbNodes = SMESH::GetNameOfSelectedNodes( mySelector, myActor->getIO(), aString );
if ( aString!= "" && myNbCorners == nbNodes && anOldEditArgument == aString && myAutomaticPresentation && myAutomaticPresentation->isChecked()) {
myShift++;
if ( myShift > nbNodes ) {
myShift = 0;
break;
}
continue;
}
if (myNbCorners != nbNodes && myNbCorners != 1) {
myShift = 0;
break;
}
if ( !myAutomaticPresentation || !myAutomaticPresentation->isChecked() )
break;
}
if ( myCurrentLineEdit ) if ( myCurrentLineEdit )
{ {
if ( myCurrentLineEdit != myCenterNode || nbNodes == 1) if ( myCurrentLineEdit != myCenterNode || nbNodes == 1 )
myCurrentLineEdit->setText(aString); myCurrentLineEdit->setText(aString);
if ( myCurrentLineEdit == myCornerNodes ) { if ( myCurrentLineEdit == myCornerNodes )
UpdateTable(); UpdateTable();
if ( myAutomaticPresentation && myAutomaticPresentation->isChecked() && myNbCorners == nbNodes)
myNextPresentationButton->setEnabled(true);
}
} }
else if ( myTable->isEnabled() && nbNodes == 1 ) else if ( myTable->isEnabled() && nbNodes == 1 )
{ {
@ -1169,6 +1025,7 @@ void SMESHGUI_AddQuadraticElementDlg::SelectionIntoArgument()
if ( theCol == 1 ) if ( theCol == 1 )
myTable->item(theRow, 1)->setText(aString); myTable->item(theRow, 1)->setText(aString);
} }
updateButtons(); updateButtons();
displaySimulation(); displaySimulation();
} }
@ -1178,10 +1035,9 @@ void SMESHGUI_AddQuadraticElementDlg::SelectionIntoArgument()
// purpose : // purpose :
//================================================================================= //=================================================================================
void SMESHGUI_AddQuadraticElementDlg::displaySimulation(int theRow, int theCol) void SMESHGUI_AddQuadraticElementDlg::displaySimulation()
{ {
bool isValid = IsValid(); if ( IsValid() )
if ( ( isValid || myTable->isEnabled() ) && myActor )
{ {
SMESH::TElementSimulationQuad::TVTKIds anIds; SMESH::TElementSimulationQuad::TVTKIds anIds;
@ -1189,6 +1045,7 @@ void SMESHGUI_AddQuadraticElementDlg::displaySimulation(int theRow, int theCol)
int anID; int anID;
bool ok; bool ok;
int aDisplayMode = VTK_SURFACE; int aDisplayMode = VTK_SURFACE;
if ( myGeomType == SMDSEntity_Quad_Edge ) if ( myGeomType == SMDSEntity_Quad_Edge )
{ {
anIds.push_back( myActor->GetObject()->GetNodeVTKId( myTable->item(0, 0)->text().toInt() ) ); anIds.push_back( myActor->GetObject()->GetNodeVTKId( myTable->item(0, 0)->text().toInt() ) );
@ -1212,33 +1069,20 @@ void SMESHGUI_AddQuadraticElementDlg::displaySimulation(int theRow, int theCol)
} }
anIds.push_back( myActor->GetObject()->GetNodeVTKId(anID) ); anIds.push_back( myActor->GetObject()->GetNodeVTKId(anID) );
} }
if ( myNbMidFaceNodes && isValid) if ( myNbMidFaceNodes )
{ {
QStringList aListId = myMidFaceNodes->text().split(" ", QString::SkipEmptyParts); QStringList aListId = myMidFaceNodes->text().split(" ", QString::SkipEmptyParts);
for (int i = 0; i < aListId.count(); i++) for (int i = 0; i < aListId.count(); i++)
anIds.push_back( myActor->GetObject()->GetNodeVTKId( aListId[ i ].toInt() )); anIds.push_back( myActor->GetObject()->GetNodeVTKId( aListId[ i ].toInt() ));
} }
if ( myNbCenterNodes && isValid) if ( myNbCenterNodes )
{ {
QStringList aListId = myCenterNode->text().split(" ", QString::SkipEmptyParts); QStringList aListId = myCenterNode->text().split(" ", QString::SkipEmptyParts);
anIds.push_back( myActor->GetObject()->GetNodeVTKId( aListId[ 0 ].toInt() )); anIds.push_back( myActor->GetObject()->GetNodeVTKId( aListId[ 0 ].toInt() ));
} }
} }
if ( isValid )
mySimulation->SetPosition(myActor,myGeomType,anIds,aDisplayMode,myReverseCB->isChecked()); mySimulation->SetPosition(myActor,myGeomType,anIds,aDisplayMode,myReverseCB->isChecked());
mySimulation->SetCornerNodes(myActor, anIds);
if ( theCol == 1 ) {
anIds.clear();
anIds.push_back( myActor->GetObject()->GetNodeVTKId( myTable->item(theRow, 0)->text().toInt() ) );
anIds.push_back( myActor->GetObject()->GetNodeVTKId( myTable->item(theRow, 2)->text().toInt() ) );
bool ok;
int anID;
anID = myTable->item(theRow, 1)->text().toInt(&ok);
if (ok)
anIds.push_back(myActor->GetObject()->GetNodeVTKId(anID));
mySimulation->SetSelectedNodes(myActor, anIds);
}
mySimulation->SetVisibility(isValid, true, true, myActor->GetFacesOriented());
} }
else else
{ {
@ -1257,16 +1101,12 @@ void SMESHGUI_AddQuadraticElementDlg::SetCurrentSelection()
QPushButton* send = (QPushButton*)sender(); QPushButton* send = (QPushButton*)sender();
myCurrentLineEdit = 0; myCurrentLineEdit = 0;
if (send == myCornerSelectButton || (QCheckBox*)sender() == myAutomaticPresentation) if (send == myCornerSelectButton)
myCurrentLineEdit = myCornerNodes; myCurrentLineEdit = myCornerNodes;
else if ( send == myMidFaceSelectButton ) else if ( send == myMidFaceSelectButton )
myCurrentLineEdit = myMidFaceNodes; myCurrentLineEdit = myMidFaceNodes;
else if ( send == myCenterSelectButton ) else if ( send == myCenterSelectButton )
myCurrentLineEdit = myCenterNode; myCurrentLineEdit = myCenterNode;
else if (send == myNextPresentationButton ) {
myShift++;
myCurrentLineEdit = myCornerNodes;
}
if ( myCurrentLineEdit ) if ( myCurrentLineEdit )
{ {
@ -1464,7 +1304,7 @@ void SMESHGUI_AddQuadraticElementDlg::UpdateTable( bool theConersValidity )
void SMESHGUI_AddQuadraticElementDlg::onCellDoubleClicked( int theRow, int theCol ) void SMESHGUI_AddQuadraticElementDlg::onCellDoubleClicked( int theRow, int theCol )
{ {
myCurrentLineEdit = 0; myCurrentLineEdit = 0;
displaySimulation(theRow, theCol); displaySimulation();
updateButtons(); updateButtons();
} }
@ -1476,7 +1316,7 @@ void SMESHGUI_AddQuadraticElementDlg::onCellDoubleClicked( int theRow, int theCo
void SMESHGUI_AddQuadraticElementDlg::onCellTextChange(int theRow, int theCol) void SMESHGUI_AddQuadraticElementDlg::onCellTextChange(int theRow, int theCol)
{ {
myCurrentLineEdit = 0; myCurrentLineEdit = 0;
displaySimulation(theRow, theCol); displaySimulation();
updateButtons(); updateButtons();
} }

5
src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.h
View File

@ -75,7 +75,7 @@ private:
void Init(); void Init();
void enterEvent( QEvent* ); /* mouse enter the QWidget */ void enterEvent( QEvent* ); /* mouse enter the QWidget */
void keyPressEvent( QKeyEvent* ); void keyPressEvent( QKeyEvent* );
void displaySimulation(int = -1, int = -1); void displaySimulation();
void UpdateTable( bool = true ); void UpdateTable( bool = true );
bool IsValid(); bool IsValid();
void updateButtons(); void updateButtons();
@ -88,7 +88,6 @@ private:
int myNbMidFaceNodes; int myNbMidFaceNodes;
int myNbCenterNodes; int myNbCenterNodes;
bool myBusy; bool myBusy;
int myShift;
SVTK_Selector* mySelector; SVTK_Selector* mySelector;
SMESH::SMESH_Mesh_var myMesh; SMESH::SMESH_Mesh_var myMesh;
@ -113,8 +112,6 @@ private:
QPushButton* myCenterSelectButton; QPushButton* myCenterSelectButton;
QLineEdit* myCenterNode; QLineEdit* myCenterNode;
QTableWidget* myTable; QTableWidget* myTable;
QCheckBox* myAutomaticPresentation;
QPushButton* myNextPresentationButton;
QCheckBox* myReverseCB; QCheckBox* myReverseCB;
QGroupBox* GroupGroups; QGroupBox* GroupGroups;

71
src/SMESHGUI/SMESHGUI_MeshOp.cxx
View File

@ -1396,6 +1396,7 @@ void SMESHGUI_MeshOp::onAlgoSelected( const int theIndex,
const bool isSubmesh = ( myToCreate ? !myIsMesh : myDlg->isObjectShown( SMESHGUI_MeshDlg::Mesh )); const bool isSubmesh = ( myToCreate ? !myIsMesh : myDlg->isObjectShown( SMESHGUI_MeshDlg::Mesh ));
// if ( aDim >= SMESH::DIM_2D ) myAvailableHypData[ aDim ][ Algo ] = myFilteredAlgoData[aDim];
HypothesisData* algoData = hypData( aDim, Algo, theIndex ); HypothesisData* algoData = hypData( aDim, Algo, theIndex );
HypothesisData* algoByDim[4]; HypothesisData* algoByDim[4];
algoByDim[ aDim ] = algoData; algoByDim[ aDim ] = algoData;
@ -2567,7 +2568,7 @@ void SMESHGUI_MeshOp::setFilteredAlgoData( const int theTabIndex, const int theI
if ( anCompareType == "ANY" ) if ( anCompareType == "ANY" )
{ {
for ( int dim = SMESH::DIM_3D; dim >= SMESH::DIM_2D; dim-- ) for ( int dim = SMESH::DIM_2D; dim <= SMESH::DIM_3D; dim++ )
{ {
isNone = currentHyp( dim, Algo ) < 0; isNone = currentHyp( dim, Algo ) < 0;
isAvailableChoiceAlgo = false; isAvailableChoiceAlgo = false;
@ -2580,35 +2581,30 @@ void SMESHGUI_MeshOp::setFilteredAlgoData( const int theTabIndex, const int theI
} }
myAvailableHypData[dim][Algo].clear(); myAvailableHypData[dim][Algo].clear();
anAvailableAlgs.clear(); anAvailableAlgs.clear();
if ( dim != SMESH::DIM_2D || currentHyp( SMESH::DIM_3D, Algo ) < 0 || for (int i = 0 ; i < anAvailableAlgsData.count(); i++)
myAvailableHypData[SMESH::DIM_3D][Algo].empty() ||
!myAvailableHypData[SMESH::DIM_3D][Algo].at( currentHyp( SMESH::DIM_3D, Algo ) )->InputTypes.isEmpty() )
{ {
for (int i = 0 ; i < anAvailableAlgsData.count(); i++) HypothesisData* curAlgo = anAvailableAlgsData.at(i);
if ( aGeomVar->_is_nil() ||
SMESH::IsApplicable( curAlgo->TypeName, aGeomVar, toCheckIsApplicableToAll ))
{ {
HypothesisData* curAlgo = anAvailableAlgsData.at(i); anAvailableAlgs.append( curAlgo->Label );
if ( aGeomVar->_is_nil() || myAvailableHypData[dim][Algo].append( curAlgo );
SMESH::IsApplicable( curAlgo->TypeName, aGeomVar, toCheckIsApplicableToAll )) }
{ }
anAvailableAlgs.append( curAlgo->Label ); if ( !isNone && algoCur ) {
myAvailableHypData[dim][Algo].append( curAlgo ); for (int i = 0 ; i < myAvailableHypData[dim][Algo].count(); i++)
{
HypothesisData* algoAny = myAvailableHypData[dim][Algo].at(i);
if ( algoAny->Label == algoCur->Label ){
isAvailableChoiceAlgo = true;
anCurrentAvailableAlgo = i;
break;
} }
} }
if ( !isNone && algoCur ) { }
for (int i = 0 ; i < myAvailableHypData[dim][Algo].count(); i++) else if ( !isNone ) {
{ isAvailableChoiceAlgo = true;
HypothesisData* algoAny = myAvailableHypData[dim][Algo].at(i); anCurrentAvailableAlgo = currentHyp( dim, Algo );
if ( algoAny->Label == algoCur->Label ){
isAvailableChoiceAlgo = true;
anCurrentAvailableAlgo = i;
break;
}
}
}
else if ( !isNone ) {
isAvailableChoiceAlgo = true;
anCurrentAvailableAlgo = currentHyp( dim, Algo );
}
} }
myDlg->tab( dim )->setAvailableHyps( Algo, anAvailableAlgs ); myDlg->tab( dim )->setAvailableHyps( Algo, anAvailableAlgs );
if ( isAvailableChoiceAlgo ) if ( isAvailableChoiceAlgo )
@ -2734,24 +2730,11 @@ void SMESHGUI_MeshOp::setFilteredAlgoData( const int theTabIndex, const int theI
{ {
for (int i = SMESH::DIM_0D; i <= myMaxShapeDim; i++) for (int i = SMESH::DIM_0D; i <= myMaxShapeDim; i++)
{ {
if ( myAvailableHypData[i][Algo].count() == 0 ) { for (int j = 0; j < myAvailableHypData[i][Algo].count(); ++j) {
availableHyps( i, Algo, anAvailableAlgs, anAvailableAlgsData ); HypothesisData* aCurAlgo = hypData( i, Algo, j );
for ( int i = 0 ; i < anAvailableAlgsData.count(); i++ ) if ( aCurAlgo->Label == algoDataIn->Label ){
{ isAvailable = true;
HypothesisData* aCurAlgo = anAvailableAlgsData.at( i ); break;
if ( aCurAlgo->Label == algoDataIn->Label ){
isAvailable = true;
break;
}
}
}
else {
for (int j = 0; j < myAvailableHypData[i][Algo].count(); ++j) {
HypothesisData* aCurAlgo = hypData( i, Algo, j );
if ( aCurAlgo->Label == algoDataIn->Label ){
isAvailable = true;
break;
}
} }
} }
if ( isAvailable ) break; if ( isAvailable ) break;

720
src/SMESHGUI/SMESHGUI_VTKUtils.cxx
View File

@ -76,14 +76,6 @@
// OCCT includes // OCCT includes
#include <TColStd_IndexedMapOfInteger.hxx> #include <TColStd_IndexedMapOfInteger.hxx>
#include <Standard_ErrorHandler.hxx> #include <Standard_ErrorHandler.hxx>
#include <ProjLib.hxx>
#include <gp_Pln.hxx>
#include <gp_Lin.hxx>
#include <gce_MakePln.hxx>
#include <gce_MakeLin.hxx>
#include <GeomAPI_IntCS.hxx>
#include <Geom_Line.hxx>
#include <Geom_Plane.hxx>
namespace SMESH namespace SMESH
{ {
@ -1120,135 +1112,6 @@ namespace SMESH
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
int GetNameOfSelectedSortedNodes( SMDSAbs_EntityType theElementType,
SVTK_Selector* theSelector,
SMESH_Actor* theActor,
int theShift,
QString& theName)
{
theName = "";
TColStd_IndexedMapOfInteger aMapIndex;
Handle(SALOME_InteractiveObject) anIO = theActor->getIO();
theSelector->GetIndex(anIO, aMapIndex);
SMDS_Mesh* aMesh = 0;
if (theActor)
aMesh = theActor->GetObject()->GetMesh();
std::vector<SMESH_TNodeXYZ> aVectorOfNode;
std::list<int> aListOfId;
int aSize = aMapIndex.Extent();
for( int i = 1 ; i <= aSize; i++) {
SMESH_TNodeXYZ aCurNode = aMesh->FindNode( aMapIndex(i) );
aVectorOfNode.push_back( aCurNode );
aListOfId.push_back( aCurNode._node->GetID() );
}
SMESH_TNodeXYZ aFirstNode;
if ( aSize > 0 )
aFirstNode = aVectorOfNode[0];
int myNbNodes = 0;
std::list<int> aResultListId;
switch ( theElementType ) {
case SMDSEntity_0D:
myNbNodes = 1;
break;
case SMDSEntity_Ball:
myNbNodes = 1;
break;
case SMDSEntity_Edge:
case SMDSEntity_Quad_Edge:
myNbNodes = 2;
break;
case SMDSEntity_Triangle:
case SMDSEntity_Quad_Triangle:
case SMDSEntity_BiQuad_Triangle:
myNbNodes = 3;
break;
case SMDSEntity_Quadrangle:
case SMDSEntity_Quad_Quadrangle:
case SMDSEntity_BiQuad_Quadrangle:
myNbNodes = 4;
if ( myNbNodes <= aSize ) {
aVectorOfNode.resize( myNbNodes );
aVectorOfNode[0] = aVectorOfNode[theShift % myNbNodes];
aVectorOfNode[theShift % myNbNodes] = aFirstNode;
GetSortedNodesOnPolygon( aVectorOfNode, aResultListId );
}
break;
case SMDSEntity_Polygon:
myNbNodes = 0;
if ( aSize > 0 ) {
aVectorOfNode[0] = aVectorOfNode[theShift % aVectorOfNode.size()];
aVectorOfNode[theShift % aVectorOfNode.size()] = aFirstNode;
}
GetSortedNodesOnPolygon( aVectorOfNode, aResultListId );
break;
case SMDSEntity_Tetra:
case SMDSEntity_Quad_Tetra:
myNbNodes = 4;
break;
case SMDSEntity_Pyramid:
case SMDSEntity_Quad_Pyramid:
myNbNodes = 5;
if ( myNbNodes <= aSize ) {
aVectorOfNode.resize( myNbNodes );
aVectorOfNode[0] = aVectorOfNode[theShift % myNbNodes];
aVectorOfNode[theShift % myNbNodes] = aFirstNode;
GetSortedNodesOnPyramid( aVectorOfNode, aResultListId );
}
break;
case SMDSEntity_Hexa:
case SMDSEntity_Quad_Hexa:
case SMDSEntity_TriQuad_Hexa:
myNbNodes = 8;
if ( myNbNodes <= aSize ) {
aVectorOfNode.resize( myNbNodes );
aVectorOfNode[0] = aVectorOfNode[theShift % myNbNodes];
aVectorOfNode[theShift % myNbNodes] = aFirstNode;
GetSortedNodesOnPrism( aVectorOfNode, aResultListId );
}
break;
case SMDSEntity_Penta:
case SMDSEntity_Quad_Penta:
myNbNodes = 6;
if ( myNbNodes <= aSize ) {
aVectorOfNode.resize( myNbNodes );
aVectorOfNode[0] = aVectorOfNode[theShift % myNbNodes];
aVectorOfNode[theShift % myNbNodes] = aFirstNode;
GetSortedNodesOnPrism( aVectorOfNode, aResultListId );
}
break;
case SMDSEntity_Hexagonal_Prism:
myNbNodes = 12;
if ( myNbNodes <= aSize ) {
aVectorOfNode.resize( myNbNodes );
aVectorOfNode[0] = aVectorOfNode[theShift % myNbNodes];
aVectorOfNode[theShift % myNbNodes] = aFirstNode;
GetSortedNodesOnPrism( aVectorOfNode, aResultListId );
}
break;
default:
myNbNodes = 2;
}
if( myNbNodes > 0 ) {
if ( myNbNodes <= 3 || myNbNodes > aSize || theElementType == SMDSEntity_Tetra )
aResultListId = aListOfId;
if ( myNbNodes < aSize ) {
if ( aResultListId.size() == 0 )
return 0;
aVectorOfNode.resize( myNbNodes );
aResultListId.resize( myNbNodes );
}
}
std::list<int>::iterator anIter = aResultListId.begin();
for( ; anIter != aResultListId.end(); anIter++ ) {
theName += QString(" %1").arg( *anIter );
}
if ( myNbNodes <= 3 || myNbNodes > aSize || theElementType == SMDSEntity_Tetra )
return aSize;
return aVectorOfNode.size();
}
int GetNameOfSelectedNodes(SVTK_Selector* theSelector, int GetNameOfSelectedNodes(SVTK_Selector* theSelector,
const Handle(SALOME_InteractiveObject)& theIO, const Handle(SALOME_InteractiveObject)& theIO,
QString& theName) QString& theName)
@ -1544,590 +1407,9 @@ namespace SMESH
DistanceToPosition( theBounds, theNormal, theDist, theOrigin ); DistanceToPosition( theBounds, theNormal, theDist, theOrigin );
return true; return true;
} }
bool CreatePlaneOnThreePoints( const gp_Pnt& thePoint1,
const gp_Pnt& thePoint2,
const gp_Pnt& thePoint3,
gp_Pln& thePlane )
{
gp_Vec aVec1, aVec2;
aVec1 = gp_Vec( thePoint1, thePoint2 );
aVec2 = gp_Vec( thePoint1, thePoint3 );
double anAngle = aVec1.Angle( aVec2 );
bool isOnStraight = ( anAngle != 0 && anAngle != M_PI );
if ( isOnStraight ) {
gce_MakePln aMakePln (thePoint1, thePoint2, thePoint3);
if ( aMakePln.IsDone() ) {
thePlane = aMakePln.Value();
}
}
return isOnStraight;
}
void FindNbLowestPoint( std::list<gp_Pnt2d> theList, gp_Pnt2d& theNode )
{
std::list<gp_Pnt2d>::iterator anIter = theList.begin();
gp_Pnt2d aNode = gp_Pnt2d ( (*anIter).X(), (*anIter).Y());
for( ; anIter != theList.end(); anIter++ ) {
if ( (*anIter).Y() < aNode.Y() || ( (*anIter).Y() == aNode.Y() && (*anIter).X() < aNode.X() ) )
aNode = *anIter;
}
theNode = aNode;
}
static bool CompareNodeOfAngleAndDist (const TNodeOfAngleAndDist& first, const TNodeOfAngleAndDist& second )
{
if ( first.second.second == 0 )
return true;
if ( second.second.second == 0 )
return false;
if ( first.second.first == 0 && second.second.first == 0 )
if ( first.second.second > second.second.second )
return false;
else
return true;
if ( first.second.first < second.second.first ||
( first.second.first == second.second.first && first.second.second >= second.second.second ) )
return true;
return false;
}
static bool CompareNodeOfDist (const TNodeOfAngleAndDist& first, const TNodeOfAngleAndDist& second )
{
if ( first.second.second < second.second.second )
return true;
return false;
}
static bool CompareDistOfPlane ( const TNodeOfDistToPlaneAndDist& first, const TNodeOfDistToPlaneAndDist& second )
{
if ( first.second.first == 0 && second.second.first != 0 )
return true;
if ( first.second.first != 0 && second.second.first == 0 )
return false;
if ( first.second.first < second.second.first ||
( first.second.first != 0 && second.second.first != 0 &&
first.second.first == second.second.first && first.second.second > second.second.second ) )
return true;
return false;
}
static bool CompareDistOfPlaneById ( const TIdOfDistToPlaneAndDist& first, const TIdOfDistToPlaneAndDist& second )
{
if ( first.second.first == 0 && second.second.first != 0 )
return true;
if ( first.second.first != 0 && second.second.first == 0 )
return false;
if ( first.second.first < second.second.first ||
( first.second.first != 0 && second.second.first != 0 &&
first.second.first == second.second.first && first.second.second > second.second.second ) )
return true;
return false;
}
static bool CompareDistForCorrectPlane ( const TNodeOfDist& first, const TNodeOfDist& second )
{
if ( first.second < second.second ) return true;
return false;
}
bool IsNotPlaneIntersection( std::vector<SMESH_TNodeXYZ>& theVector, const gp_Pln& thePlane )
{
double A, B, C, D, aCur;
thePlane.Coefficients(A, B, C, D);
int aPlus = -1;
for ( int i = 0 ; i < (int)theVector.size(); ++i ) {
aCur = A * theVector[i]._xyz[0] + B * theVector[i]._xyz[1] + C * theVector[i]._xyz[2] + D;
if ( aCur == 0 )
continue;
if ( aPlus == -1 && aCur != 0 )
aPlus = ( aCur < 0 ) ? 0 : 1;
if ( aPlus > -1 && aPlus != ( aCur < 0 ) ? 0 : 1 )
return false;
}
return true;
}
bool GetNextCombination ( std::vector<int>& theVector1, std::vector<int>& theVector2, int theNbPoint )
{
int aSize = (int)theVector1.size();
for ( int i = aSize - 1; i >= 0; --i ) {
if ( theVector1[i] < theNbPoint - aSize + i ) {
++theVector1[i];
for ( int j = i + 1; j < aSize; ++j )
theVector1[j] = theVector1[j-1] + 1;
int it = 0;
int it2 = 0;
bool isVec;
for ( int k = 0; k < theNbPoint; ++k ) {
isVec = false;
if( it < aSize ) {
if( k == theVector1[it] ) {
isVec = true;
++it;
}
}
if ( isVec )
continue;
theVector2[it2] = k;
it2++;
if ( it2 == (int)theVector2.size() )
break;
}
return true;
}
}
return false;
}
bool Get2BasePlane( std::vector<SMESH_TNodeXYZ>& theVector,
std::vector<SMESH_TNodeXYZ>& thePlane1,
std::vector<SMESH_TNodeXYZ>& thePlane2 )
{
int aSize = (int)theVector.size() / 2;
if ( aSize < 3 || (int)theVector.size() % 2 != 0 )
return false;
int anArr1[3];
int anArr2[2 * aSize - 3];
for (int i = 0; i < 3 ; i++) {
anArr1[i] = i;
}
for (int i = 0; i < 2 * aSize - 3 ; i++) {
anArr2[i] = i + 3;
}
int aNbSwapFirstPoint = 0;
while ( thePlane1.empty() && thePlane2.empty() && aNbSwapFirstPoint < aSize * 2 ) {
std::vector<int> anIndexPlane1( anArr1, anArr1 + 3 );
std::vector<int> anIndexPlane2( anArr2, anArr2 + 2 * aSize - 3);
int aNbCombination = 0;
double aMax = 0;
double aSumMin = -1;
int aMaxCombination = 0;
thePlane1.clear();
thePlane2.clear();
for (int i = 1; i < 2 * aSize - 1; i++ ) {
aMaxCombination += i;
}
while ( aNbCombination < aMaxCombination ) {
gp_Pln aPlane;
double aSumMinDist1 = 0;
double aSumMinDist2 = 0;
std::vector<SMESH_TNodeXYZ> aVectorOfPoint;
for(int i = 0; i < 2 * aSize - 3; i++) {
aVectorOfPoint.push_back(theVector[anIndexPlane2[i]]);
}
bool isCorrectPlane = false;
bool isCreatePlane = CreatePlaneOnThreePoints( gp_Pnt(theVector[anIndexPlane1[0]]._xyz[0], theVector[anIndexPlane1[0]]._xyz[1], theVector[anIndexPlane1[0]]._xyz[2]),
gp_Pnt(theVector[anIndexPlane1[1]]._xyz[0], theVector[anIndexPlane1[1]]._xyz[1], theVector[anIndexPlane1[1]]._xyz[2]),
gp_Pnt(theVector[anIndexPlane1[2]]._xyz[0], theVector[anIndexPlane1[2]]._xyz[1], theVector[anIndexPlane1[2]]._xyz[2]),
aPlane );
if ( isCreatePlane ) {
isCorrectPlane = IsNotPlaneIntersection( aVectorOfPoint, aPlane );
}
if ( !isCorrectPlane ) {
GetNextCombination( anIndexPlane1, anIndexPlane2, 2*aSize );
aNbCombination++;
continue;
}
std::vector<int> anIndexCorrectPlane1;
std::vector<int> anIndexCorrectPlane2;
if ( aSize == 3 ) {
for (int i = 0; i < aSize ; i++) {
anIndexCorrectPlane1.push_back( anIndexPlane1[i] );
anIndexCorrectPlane2.push_back( anIndexPlane2[i] );
}
}
if ( aSize >= 4 ) {
std::list<TIdOfDistToPlaneAndDist> aListBaseOfPoint;
TIdOfDistToPlaneAndDist aCurDistOfPlane;
for (int i = 0; i < 2 * aSize - 3; i++ ) {
aCurDistOfPlane.second.first = aPlane.Distance( gp_Pnt( theVector[anIndexPlane2[i]]._xyz[0], theVector[anIndexPlane2[i]]._xyz[1], theVector[anIndexPlane2[i]]._xyz[2] ));
if ( aCurDistOfPlane.second.first == 0 )
aCurDistOfPlane.second.second = 0;
else {
double aCurDist = 0;
for (int j = 0; j < 3; j++) {
aCurDist += pow( theVector[anIndexPlane1[j]]._xyz[0] - theVector[anIndexPlane2[i]]._xyz[0], 2.0 ) +
pow( theVector[anIndexPlane1[j]]._xyz[1] - theVector[anIndexPlane2[i]]._xyz[1], 2.0 ) +
pow( theVector[anIndexPlane1[j]]._xyz[2] - theVector[anIndexPlane2[i]]._xyz[2], 2.0 );
}
aCurDistOfPlane.second.second = aCurDist;
}
aCurDistOfPlane.first = anIndexPlane2[i];
aListBaseOfPoint.push_back( aCurDistOfPlane );
}
aListBaseOfPoint.sort( CompareDistOfPlaneById );
std::list<TIdOfDistToPlaneAndDist>::iterator anIterDist = aListBaseOfPoint.begin();
for (int i = 0; i < 3; i++) {
anIndexCorrectPlane1.push_back( anIndexPlane1[i] );
}
for (int i = 0; i < aSize - 3; i++, anIterDist++) {
anIndexCorrectPlane1.push_back((*anIterDist).first);
}
for (int i = 0; i < 2 * aSize - 3 ; i++) {
anIterDist = aListBaseOfPoint.begin();
bool isFinded = false;
for (int j = 0; j < aSize - 3; j++, anIterDist++) {
if ( anIndexPlane2[i] == (*anIterDist).first ) {
isFinded = true;
break;
}
}
if ( !isFinded )
anIndexCorrectPlane2.push_back( anIndexPlane2[i] );
}
}
double aCurDist1, aCurDist2, aMinDist1, aMinDist2, aSumDist1, aSumDist2, aSumDistBase1, aSumDistBase2;
bool isCorrect2Base = true;
aSumDist1 = aSumDistBase1 = aSumDist2 = aSumDistBase2 = 0;
for( int i = 0 ; i < aSize ; i++ ) {
aMinDist1 = 0;
aMinDist2 = 0;
for(int j = 0 ; j < aSize ; j++ ) {
aCurDist1 = pow( theVector[anIndexCorrectPlane1[i]]._xyz[0] - theVector[anIndexCorrectPlane2[j]]._xyz[0], 2.0 ) +
pow( theVector[anIndexCorrectPlane1[i]]._xyz[1] - theVector[anIndexCorrectPlane2[j]]._xyz[1], 2.0 ) +
pow( theVector[anIndexCorrectPlane1[i]]._xyz[2] - theVector[anIndexCorrectPlane2[j]]._xyz[2], 2.0 );
aCurDist2 = pow( theVector[anIndexCorrectPlane1[j]]._xyz[0] - theVector[anIndexCorrectPlane2[i]]._xyz[0], 2.0 ) +
pow( theVector[anIndexCorrectPlane1[j]]._xyz[1] - theVector[anIndexCorrectPlane2[i]]._xyz[1], 2.0 ) +
pow( theVector[anIndexCorrectPlane1[j]]._xyz[2] - theVector[anIndexCorrectPlane2[i]]._xyz[2], 2.0 );
aSumDistBase1 += pow( theVector[anIndexCorrectPlane1[i]]._xyz[0] - theVector[anIndexCorrectPlane1[j]]._xyz[0], 2.0 ) +
pow( theVector[anIndexCorrectPlane1[i]]._xyz[1] - theVector[anIndexCorrectPlane1[j]]._xyz[1], 2.0 ) +
pow( theVector[anIndexCorrectPlane1[i]]._xyz[2] - theVector[anIndexCorrectPlane1[j]]._xyz[2], 2.0 );
aSumDistBase2 += pow( theVector[anIndexCorrectPlane2[i]]._xyz[0] - theVector[anIndexCorrectPlane2[j]]._xyz[0], 2.0 ) +
pow( theVector[anIndexCorrectPlane2[i]]._xyz[1] - theVector[anIndexCorrectPlane2[j]]._xyz[1], 2.0 ) +
pow( theVector[anIndexCorrectPlane2[i]]._xyz[2] - theVector[anIndexCorrectPlane2[j]]._xyz[2], 2.0 );
if ( aCurDist1 < aMinDist1 || aMinDist1 == 0)
aMinDist1 = aCurDist1;
if ( aCurDist2 < aMinDist2 || aMinDist2 == 0)
aMinDist2 = aCurDist2;
aSumDist1 += aCurDist1;
aSumDist2 += aCurDist2;
}
aSumMinDist1 += aMinDist1;
aSumDist1 -= aMinDist1;
aSumMinDist2 += aMinDist2;
aSumDist2 -= aMinDist2;
}
isCorrect2Base = ( aSumDistBase1 + aSumDistBase2 <= aSumDist1 + aSumDist2 );
if ( isCorrect2Base && ( aSumMinDist1 == aSumMinDist2 || ( aSumMinDist1 + aSumMinDist2 ) > aMax || aMax == 0 ||
( (aSumMinDist1 + aSumMinDist2 ) == aMax && ( (aSumDist1 + aSumDist2 - aSumDistBase1 - aSumDistBase2) < aSumMin || aSumMin == -1 ) ) ) ) {
aMax = aSumMinDist1 + aSumMinDist2;
aSumMin = aSumDist1 + aSumDist2 - aSumDistBase1 - aSumDistBase2;
thePlane1.clear();
thePlane2.clear();
for(int i = 0; i < aSize; i++) {
thePlane1.push_back(theVector[anIndexCorrectPlane1[i]]);
thePlane2.push_back(theVector[anIndexCorrectPlane2[i]]);
}
}
if ( aSumMinDist1 == aSumMinDist2 )
break;
if ( !GetNextCombination( anIndexPlane1, anIndexPlane2, 2 * aSize) )
break;
aNbCombination++;
}
if ( thePlane1.empty() && thePlane2.empty() ) {
aNbSwapFirstPoint++;
SMESH_TNodeXYZ aPoint;
aPoint = theVector[0];
theVector[0] = theVector[aNbSwapFirstPoint];
theVector[aNbSwapFirstPoint] = aPoint;
}
}
if ( thePlane1.empty() && thePlane2.empty() )
return false;
return true;
}
bool GetCorrectSequenceOfId( std::vector<SMESH_TNodeXYZ>& theVector )
{
std::list<gp_Pnt2d> aListProjection;
gp_Pnt2d aCurPoint;
int aSize = (int)theVector.size();
if ( aSize < 3 )
return false;
gp_Pln aPlane;
bool isCreatePlane = false;
for (int i = 0; i < aSize - 1; i++ ) {
isCreatePlane = CreatePlaneOnThreePoints( gp_Pnt( theVector[i]._xyz[0], theVector[i]._xyz[1], theVector[i]._xyz[2] ),
gp_Pnt( theVector[i+1]._xyz[0], theVector[i+1]._xyz[1], theVector[i+1]._xyz[2] ),
gp_Pnt( theVector[i+2]._xyz[0], theVector[i+2]._xyz[1], theVector[i+2]._xyz[2] ), aPlane );
if ( isCreatePlane)
break;
}
if ( !isCreatePlane )
return false;
for ( int i = 0; i < aSize; i++) {
aCurPoint = ProjLib::Project( aPlane, gp_Pnt( theVector[i]._xyz[0], theVector[i]._xyz[1], theVector[i]._xyz[2] ));
aListProjection.push_back( aCurPoint );
}
std::list<TNodeOfAngleAndDist> aListIdOfAngleAndDist;
TNodeOfAngleAndDist aCurIdOfAngleAndDist;
FindNbLowestPoint( aListProjection, aCurPoint);
std::list<gp_Pnt2d>::iterator anIter2d = aListProjection.begin();
gp_Vec2d aCurVec;
gp_Vec2d aAxisVec = gp_Vec2d( 1, 0 );
for( int i = 0 ; anIter2d != aListProjection.end(); anIter2d++, i++) {
aCurVec = gp_Vec2d( (*anIter2d).X() - aCurPoint.X(), (*anIter2d).Y() - aCurPoint.Y() );
aCurIdOfAngleAndDist.first = theVector[i];
if ( (*anIter2d).X() == aCurPoint.X() && (*anIter2d).Y() == aCurPoint.Y() )
aCurIdOfAngleAndDist.second.first = 0;
else {
double anAngle = aAxisVec.Angle( aCurVec );
double anRoundAngle = anAngle * 100000;
int anIntAngle = anRoundAngle + 0.5;
anRoundAngle = (double) anIntAngle / 100000;
aCurIdOfAngleAndDist.second.first = anRoundAngle;
}
aCurIdOfAngleAndDist.second.second = pow( (*anIter2d).X() - aCurPoint.X(), 2.0 ) +
pow( (*anIter2d).Y() - aCurPoint.Y(), 2.0 ) +
pow( aPlane.Distance( gp_Pnt( theVector[i]._xyz[0], theVector[i]._xyz[1], theVector[i]._xyz[2] )), 2.0 );
aListIdOfAngleAndDist.push_back( aCurIdOfAngleAndDist );
}
aListIdOfAngleAndDist.sort( CompareNodeOfAngleAndDist );
std::list<TNodeOfAngleAndDist>::iterator anIter = aListIdOfAngleAndDist.begin();
std::list<TNodeOfAngleAndDist> aListResult;
double anAngle = 0;
bool isSort = true;
for(int i = 0 ; anIter != aListIdOfAngleAndDist.end(); anIter++, i++) {
if ( anAngle == (*anIter).second.first && anAngle != 0 ) {
isSort = false;
break;
}
if ( ( anAngle > (*anIter).second.first && anAngle != 0 ) || i > 1)
break;
if ( (*anIter).second.first > 0 )
anAngle = (*anIter).second.first;
}
if ( !isSort ) {
anIter = aListIdOfAngleAndDist.begin();
for( ; anIter != aListIdOfAngleAndDist.end(); anIter++) {
if ( anAngle == (*anIter).second.first)
aListResult.push_back( *anIter );
else if ( anAngle < (*anIter).second.first)
break;
}
}
else
anAngle = 0;
aListResult.sort(CompareNodeOfDist);
anIter = aListIdOfAngleAndDist.begin();
theVector.clear();
for( ; anIter != aListIdOfAngleAndDist.end(); anIter++) {
if ( !isSort && anAngle == (*anIter).second.first ){
for( std::list<TNodeOfAngleAndDist>::iterator anIter2 = aListResult.begin() ; anIter2 != aListResult.end(); anIter2++) {
theVector.push_back((*anIter2).first);
}
isSort = true;
}
if ( isSort && anAngle != 0 && anAngle == (*anIter).second.first )
continue;
theVector.push_back((*anIter).first);
}
return true;
}
void GetCorrectSequenceTwoPlaneOfId( std::vector<SMESH_TNodeXYZ>& thePlane1, std::vector<SMESH_TNodeXYZ>& thePlane2, std::list<int>& theResultListId )
{
int anIndex1, anIndex2, aShift = 0;
double aCurSum;
std::pair<int, double> aShiftOfDist;
int aSize = (int)thePlane1.size();
aShiftOfDist.first = aShiftOfDist.second = 0;
int anArr1[3];
int anArr2[aSize - 3];
for (int i = 0; i < 3 ; i++) {
anArr1[i] = i;
}
for (int i = 0; i < aSize - 3 ; i++) {
anArr2[i] = i + 3;
}
std::vector<int> anIndexPlane1( anArr1, anArr1 + 3 );
std::vector<int> anIndexPlane2( anArr2, anArr2 + aSize - 3);
std::vector<int> anIndexCorrectPlane;
std::vector<SMESH_TNodeXYZ> theNewPlane;
std::vector<SMESH_TNodeXYZ> theCorrectPlane;
GetCorrectSequenceOfId ( thePlane1 );
while( true ) {
anIndexCorrectPlane.clear();
std::vector<SMESH_TNodeXYZ> theNewPlane;
for (int i = 0; i < 3; i++) {
anIndexCorrectPlane.push_back( anIndexPlane1[i] );
}
for (int i = 0; i < aSize - 3; i++) {
anIndexCorrectPlane.push_back( anIndexPlane2[i] );
}
for (int i = 0; i < aSize; i++) {
theNewPlane.push_back( thePlane2[anIndexCorrectPlane[i]] );
}
aShift = 0;
if ( GetCorrectSequenceOfId ( theNewPlane ) )
{
std::vector<double> aVectorSum;
while ( aShift != 2 * aSize ) {
anIndex1 = 0;
aCurSum = 0;
( aShift < aSize ) ? anIndex2 = 0 : anIndex2 = aSize - 1;
while ( ( aShift < aSize && anIndex2 < aSize ) || ( aShift >= aSize && anIndex2 >= 0 ) ) {
aCurSum += pow( thePlane1[anIndex1]._xyz[0] - theNewPlane[ ( anIndex2 + aShift ) % aSize ]._xyz[0], 2.0 ) +
pow( thePlane1[anIndex1]._xyz[1] - theNewPlane[ ( anIndex2 + aShift ) % aSize ]._xyz[1], 2.0 ) +
pow( thePlane1[anIndex1]._xyz[2] - theNewPlane[ ( anIndex2 + aShift ) % aSize ]._xyz[2], 2.0 );
( aShift < aSize ) ? anIndex2++ : anIndex2--;
anIndex1++;
}
aVectorSum.push_back( aCurSum );
aShift++;
}
double aCurSumMin = 0;
std::pair<int, double> aCurShiftOfDist;
aCurShiftOfDist.first = aCurShiftOfDist.second = 0;
for ( int i = 0; i < (int)aVectorSum.size(); i++ ) {
if ( aVectorSum[i] < aCurShiftOfDist.second || aCurShiftOfDist.second == 0 ) {
aCurShiftOfDist.first = i;
aCurShiftOfDist.second = aVectorSum[i];
}
}
if ( aCurShiftOfDist.second <= aShiftOfDist.second || aShiftOfDist.second == 0){
aShiftOfDist = aCurShiftOfDist;
theCorrectPlane = theNewPlane;
}
}
if ( !GetNextCombination( anIndexPlane1, anIndexPlane2, aSize) )
break;
}
thePlane2 = theCorrectPlane;
aShift = aShiftOfDist.first;
anIndex1 = 0;
theResultListId.clear();
( aShift < aSize ) ? anIndex2 = 0 : anIndex2 = aSize - 1;
while ( anIndex1 != aSize ) {
theResultListId.push_back(thePlane1[anIndex1]._node->GetID());
anIndex1++;
}
while ( ( aShift < aSize && anIndex2 < aSize ) || ( aShift >= aSize && anIndex2 >= 0 ) ) {
theResultListId.push_back( thePlane2[( anIndex2 + aShift ) % aSize]._node->GetID() );
( aShift < aSize ) ? anIndex2++ : anIndex2--;
}
}
void GetSortedNodesOnPolygon( std::vector<SMESH_TNodeXYZ>& theVectorOfNode, std::list<int>& theResultListId )
{
GetCorrectSequenceOfId ( theVectorOfNode );
for (int i = 0; i < theVectorOfNode.size(); i++) {
theResultListId.push_back( theVectorOfNode[i]._node->GetID() );
}
}
void GetSortedNodesOnPrism( std::vector<SMESH_TNodeXYZ>& theVectorOfNode, std::list<int>& theResultListId )
{
int aSize = (int)theVectorOfNode.size();
if ( aSize < 6 && aSize % 2 == 0)
return;
std::vector<SMESH_TNodeXYZ> aPlane1, aPlane2;
if ( Get2BasePlane( theVectorOfNode, aPlane1, aPlane2 ) ) {
GetCorrectSequenceTwoPlaneOfId( aPlane1, aPlane2, theResultListId);
}
}
void GetSortedNodesOnPyramid( std::vector<SMESH_TNodeXYZ>& theVectorOfNode, std::list<int>& theResultListId )
{
int aSize = (int)theVectorOfNode.size();
if ( aSize < 5 )
return;
gp_Pln aPlane;
bool isCreatePlane, isCorrectPlane;
int aNumPlane = 0;
double aMax = 0;
while ( aNumPlane != aSize ) {
isCreatePlane = CreatePlaneOnThreePoints( gp_Pnt( theVectorOfNode[aNumPlane]._xyz[0], theVectorOfNode[aNumPlane]._xyz[1], theVectorOfNode[aNumPlane]._xyz[2] ),
gp_Pnt( theVectorOfNode[(aNumPlane + 1) % aSize]._xyz[0], theVectorOfNode[(aNumPlane + 1) % aSize]._xyz[1], theVectorOfNode[(aNumPlane + 1) % aSize]._xyz[2] ),
gp_Pnt( theVectorOfNode[(aNumPlane + 2) % aSize]._xyz[0], theVectorOfNode[(aNumPlane + 2) % aSize]._xyz[1], theVectorOfNode[(aNumPlane + 2) % aSize]._xyz[2] ), aPlane );
isCorrectPlane = false;
std::vector<SMESH_TNodeXYZ> aVectorOfPoint;
if ( isCreatePlane ) {
for(int j = 0; j < aSize - 3; j++) {
aVectorOfPoint.push_back(theVectorOfNode[(aNumPlane + j + 3) % aSize]);
}
isCorrectPlane = IsNotPlaneIntersection( aVectorOfPoint, aPlane );
}
if ( !isCorrectPlane ) {
aNumPlane++;
continue;
}
std::vector<SMESH_TNodeXYZ> aVectorBaseOfPoint;
std::list<TNodeOfDistToPlaneAndDist> aListBaseOfPoint;
TNodeOfDistToPlaneAndDist aCurDistOfPlane;
aListBaseOfPoint.clear();
for (int i = 0; i < aSize; i++ ) {
aCurDistOfPlane.second.first = aPlane.Distance( gp_Pnt( theVectorOfNode[i]._xyz[0], theVectorOfNode[i]._xyz[1], theVectorOfNode[i]._xyz[2] ));
if ( aCurDistOfPlane.second.first == 0 )
aCurDistOfPlane.second.second = 0;
else {
double aCurDist = 0;
for (int j = 0; j < 3; j++) {
aCurDist += pow( theVectorOfNode[(aNumPlane + j) % aSize]._xyz[0] - theVectorOfNode[i]._xyz[0], 2.0 ) +
pow( theVectorOfNode[(aNumPlane + j) % aSize]._xyz[1] - theVectorOfNode[i]._xyz[1], 2.0 ) +
pow( theVectorOfNode[(aNumPlane + j) % aSize]._xyz[2] - theVectorOfNode[i]._xyz[2], 2.0 );
}
aCurDistOfPlane.second.second = aCurDist;
}
aCurDistOfPlane.first = theVectorOfNode[i];
aListBaseOfPoint.push_back( aCurDistOfPlane );
}
aListBaseOfPoint.sort( CompareDistOfPlane );
std::list<TNodeOfDistToPlaneAndDist>::iterator anIterDist = aListBaseOfPoint.begin();
for (; anIterDist != aListBaseOfPoint.end(); anIterDist++ ) {
aVectorBaseOfPoint.push_back((*anIterDist).first);
}
SMESH_TNodeXYZ aTopNode = aVectorBaseOfPoint.back();
aVectorBaseOfPoint.resize( aVectorBaseOfPoint.size() - 1);
double aCur = 0;
double aSum = 0;
std::list<TNodeOfDist> aListBaseCorrect;
for (int i = 0; i < aSize - 1; i++) {
aCur = pow( aVectorBaseOfPoint[i]._xyz[0] - aTopNode._xyz[0], 2.0 ) +
pow( aVectorBaseOfPoint[i]._xyz[1] - aTopNode._xyz[1], 2.0 ) +
pow( aVectorBaseOfPoint[i]._xyz[2] - aTopNode._xyz[2], 2.0 );
aListBaseCorrect.push_back(std::make_pair(aVectorBaseOfPoint[i], aCur) );
}
bool isCorrectTop = true;
for (int i = 0; i < aSize - 1; i++) {
isCreatePlane = CreatePlaneOnThreePoints( gp_Pnt( aVectorBaseOfPoint[i]._xyz[0], aVectorBaseOfPoint[i]._xyz[1], aVectorBaseOfPoint[i]._xyz[2] ),
gp_Pnt( aVectorBaseOfPoint[(i+1) % (aSize - 1)]._xyz[0], aVectorBaseOfPoint[(i+1) % (aSize - 1)]._xyz[1], aVectorBaseOfPoint[(i+1) % (aSize - 1)]._xyz[2] ),
gp_Pnt( aVectorBaseOfPoint[(i+2) % (aSize - 1)]._xyz[0], aVectorBaseOfPoint[(i+2) % (aSize - 1)]._xyz[1], aVectorBaseOfPoint[(i+2) % (aSize - 1)]._xyz[2] ), aPlane );
if ( isCreatePlane ) {
aCur = aPlane.Distance( gp_Pnt( aTopNode._xyz[0], aTopNode._xyz[1], aTopNode._xyz[2] ));
if ( aCur == 0 ) {
isCorrectTop = false;
continue;
}
aSum += aCur;
}
}
aNumPlane++;
if ( ( isCorrectTop || aSum == 0 ) && ( aMax == 0 || aSum > aMax ) ) {
aListBaseCorrect.sort(CompareDistForCorrectPlane);
aVectorBaseOfPoint.clear();
std::list<TNodeOfDist>::iterator anIter = aListBaseCorrect.begin();
for ( ; anIter != aListBaseCorrect.end(); anIter++) {
aVectorBaseOfPoint.push_back((*anIter).first);
}
GetCorrectSequenceOfId( aVectorBaseOfPoint );
aMax = aSum;
theResultListId.clear();
for (int i = 0; i < aVectorBaseOfPoint.size(); i++) {
theResultListId.push_back( aVectorBaseOfPoint[i]._node->GetID() );
}
theResultListId.push_back( aTopNode._node->GetID() );
if ( aSum == 0 )
break;
}
}
}
bool ComputeBounds( std::list<vtkActor*> theActorList, bool ComputeBounds( std::list<vtkActor*> theActorList,
double theBounds[6]) double theBounds[6])
{ {
bool anIsOk = false; bool anIsOk = false;
theBounds[0] = theBounds[2] = theBounds[4] = VTK_DOUBLE_MAX; theBounds[0] = theBounds[2] = theBounds[4] = VTK_DOUBLE_MAX;

57
src/SMESHGUI/SMESHGUI_VTKUtils.h
View File

@ -29,11 +29,8 @@
// SMESH includes // SMESH includes
#include "SMESH_SMESHGUI.hxx" #include "SMESH_SMESHGUI.hxx"
#include "SMESH_TypeDefs.hxx"
#include "SMDS_MeshNode.hxx"
#include "SMESHGUI_Utils.h" #include "SMESHGUI_Utils.h"
#include <SMESH_Object.h> #include <SMESH_Object.h>
// SALOME KERNEL includes // SALOME KERNEL includes
@ -61,15 +58,7 @@ class SMESH_Actor;
class SALOME_Actor; class SALOME_Actor;
class vtkActor; class vtkActor;
class SMDS_Mesh;
class SMDS_MeshNode;
class gp_Pln;
class gp_Lin;
class gp_Dir;
class gp_Pnt2d;
class gp_Vec2d;
class Handle(Geom_Line);
class Handle(Geom_Plane);
namespace SMESH namespace SMESH
{ {
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@ -172,12 +161,6 @@ SMESHGUI_EXPORT
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
SMESHGUI_EXPORT SMESHGUI_EXPORT
int GetNameOfSelectedSortedNodes( SMDSAbs_EntityType,
SVTK_Selector*,
SMESH_Actor*,
int,
QString& );
SMESHGUI_EXPORT
int GetNameOfSelectedNodes( SVTK_Selector*, int GetNameOfSelectedNodes( SVTK_Selector*,
const Handle(SALOME_InteractiveObject)&, const Handle(SALOME_InteractiveObject)&,
QString& ); QString& );
@ -231,44 +214,6 @@ SMESHGUI_EXPORT
double theDirection[3], double theDirection[3],
double thePos[3], double thePos[3],
double& theDist ); double& theDist );
typedef std::pair<SMESH_TNodeXYZ, double> TNodeOfDist;
typedef std::pair<SMESH_TNodeXYZ, std::pair<double, double> > TNodeOfAngleAndDist, TNodeOfDistToPlaneAndDist;
typedef std::pair<int, std::pair<double, double> > TIdOfDistToPlaneAndDist;
bool CreatePlaneOnThreePoints( const gp_Pnt& thePoint1,
const gp_Pnt& thePoint2,
const gp_Pnt& thePoint3,
gp_Pln& thePlane );
void FindNbLowestPoint( std::list<gp_Pnt2d> theList, gp_Pnt2d& theNode );
bool IsNotPlaneIntersection( std::vector<SMESH_TNodeXYZ>& theVector,
const gp_Pln& thePlane );
bool GetCorrectSequenceOfId( std::vector<SMESH_TNodeXYZ>& theVector );
void GetCorrectSequenceTwoPlaneOfId( std::vector<SMESH_TNodeXYZ>& thePlane1,
std::vector<SMESH_TNodeXYZ>& thePlane2,
std::list<int>& theResultListId );
void GetSortedNodesOnPolygon( std::vector<SMESH_TNodeXYZ>& theVectorOfNode,
std::list<int>& theResultListId );
void GetSortedNodesOnPyramid( std::vector<SMESH_TNodeXYZ>& theVectorOfNode,
std::list<int>& theResultListId );
void GetSortedNodesOnPrism( std::vector<SMESH_TNodeXYZ>& theVectorOfNode,
std::list<int>& theResultListId );
bool Get2BasePlane( std::vector<SMESH_TNodeXYZ>& theVector,
std::vector<SMESH_TNodeXYZ>& thePlane1,
std::vector<SMESH_TNodeXYZ>& thePlane2);
bool GetNextCombination ( std::vector<int> & theVector1,
std::vector<int> & theVector2,
int theNbPoint );
static bool CompareNodeOfAngleAndDist ( const TNodeOfAngleAndDist& first,
const TNodeOfAngleAndDist& second );
static bool CompareNodeOfDist ( const TNodeOfAngleAndDist& first,
const TNodeOfAngleAndDist& second );
static bool CompareDistOfPlane ( const TNodeOfDistToPlaneAndDist& first,
const TNodeOfDistToPlaneAndDist& second );
static bool CompareDistOfPlaneById ( const TIdOfDistToPlaneAndDist& first,
const TIdOfDistToPlaneAndDist& second );
static bool CompareDistForCorrectPlane ( const TNodeOfDist& first,
const TNodeOfDist& second );
SMESHGUI_EXPORT SMESHGUI_EXPORT
void RemoveVisualObjectWithActors( const char* theEntry, bool fromAllViews = false ); void RemoveVisualObjectWithActors( const char* theEntry, bool fromAllViews = false );
}; };

8
src/SMESHGUI/SMESH_msg_en.ts
View File

@ -1321,10 +1321,6 @@ Please enter correct values and try again</translation>
<source>SMESH_AUTO_DIM</source> <source>SMESH_AUTO_DIM</source>
<translation>Automatically define space dimension</translation> <translation>Automatically define space dimension</translation>
</message> </message>
<message>
<source>SMESH_AUTOMATIC_PRESENTATION</source>
<translation>Random input ID</translation>
</message>
<message> <message>
<source>SMESH_REQUIRED_GROUPS</source> <source>SMESH_REQUIRED_GROUPS</source>
<translation>Create groups of required entities</translation> <translation>Create groups of required entities</translation>
@ -1421,10 +1417,6 @@ Please enter correct values and try again</translation>
<source>SMESH_BUT_APPLY_AND_CLOSE</source> <source>SMESH_BUT_APPLY_AND_CLOSE</source>
<translation>A&amp;pply and Close</translation> <translation>A&amp;pply and Close</translation>
</message> </message>
<message>
<source>SMESH_BUT_GET_NEXT_SHAPE</source>
<translation>Get next shape</translation>
</message>
<message> <message>
<source>SMESH_BUT_REMOVE</source> <source>SMESH_BUT_REMOVE</source>
<translation>&amp;Remove</translation> <translation>&amp;Remove</translation>

8
src/SMESHGUI/SMESH_msg_fr.ts
View File

@ -1321,10 +1321,6 @@ Merci de les corriger, puis essayez de nouveau</translation>
<source>SMESH_AUTO_DIM</source> <source>SMESH_AUTO_DIM</source>
<translation>Définition automatique des dimensions spatiales</translation> <translation>Définition automatique des dimensions spatiales</translation>
</message> </message>
<message>
<source>SMESH_AUTOMATIC_PRESENTATION</source>
<translation type="unfinished">Random input ID</translation>
</message>
<message> <message>
<source>SMESH_REQUIRED_GROUPS</source> <source>SMESH_REQUIRED_GROUPS</source>
<translation>Créer les groupes des types nécessaires</translation> <translation>Créer les groupes des types nécessaires</translation>
@ -1421,10 +1417,6 @@ Merci de les corriger, puis essayez de nouveau</translation>
<source>SMESH_BUT_APPLY_AND_CLOSE</source> <source>SMESH_BUT_APPLY_AND_CLOSE</source>
<translation>App&amp;liquer et fermer</translation> <translation>App&amp;liquer et fermer</translation>
</message> </message>
<message>
<source>SMESH_BUT_GET_NEXT_SHAPE</source>
<translation type="unfinished">Get next shape</translation>
</message>
<message> <message>
<source>SMESH_BUT_REMOVE</source> <source>SMESH_BUT_REMOVE</source>
<translation>S&amp;upprimer</translation> <translation>S&amp;upprimer</translation>

8
src/SMESHGUI/SMESH_msg_ja.ts
View File

@ -1315,10 +1315,6 @@
<source>SMESH_AUTO_DIM</source> <source>SMESH_AUTO_DIM</source>
<translation>自動的に空間の寸法を定義します。</translation> <translation>自動的に空間の寸法を定義します。</translation>
</message> </message>
<message>
<source>SMESH_AUTOMATIC_PRESENTATION</source>
<translation type="unfinished">Random input ID</translation>
</message>
<message> <message>
<source>SMESH_REQUIRED_GROUPS</source> <source>SMESH_REQUIRED_GROUPS</source>
<translation>必要な種類のグループを作成します。</translation> <translation>必要な種類のグループを作成します。</translation>
@ -1415,10 +1411,6 @@
<source>SMESH_BUT_APPLY_AND_CLOSE</source> <source>SMESH_BUT_APPLY_AND_CLOSE</source>
<translation>適用して閉じる(&amp;p)</translation> <translation>適用して閉じる(&amp;p)</translation>
</message> </message>
<message>
<source>SMESH_BUT_GET_NEXT_SHAPE</source>
<translation type="unfinished">Get next shape</translation>
</message>
<message> <message>
<source>SMESH_BUT_REMOVE</source> <source>SMESH_BUT_REMOVE</source>
<translation>削除(&amp;R)</translation> <translation>削除(&amp;R)</translation>

9
src/SMESH_SWIG/StdMeshersBuilder.py
View File

@ -183,23 +183,20 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
# @param minSize defines the minimal allowed segment length # @param minSize defines the minimal allowed segment length
# @param maxSize defines the maximal allowed segment length # @param maxSize defines the maximal allowed segment length
# @param deflection defines the maximal allowed distance from a segment to an edge # @param deflection defines the maximal allowed distance from a segment to an edge
# @param grading defines how much size of adjacent elements can differ
# @param UseExisting if ==true - searches for an existing hypothesis created with # @param UseExisting if ==true - searches for an existing hypothesis created with
# the same parameters, else (default) - creates a new one # the same parameters, else (default) - creates a new one
# @return an instance of StdMeshers_Adaptive1D hypothesis # @return an instance of StdMeshers_Adaptive1D hypothesis
# @ingroup l3_hypos_1dhyps # @ingroup l3_hypos_1dhyps
def Adaptive(self, minSize, maxSize, deflection, grading, UseExisting=False): def Adaptive(self, minSize, maxSize, deflection, UseExisting=False):
from salome.smesh.smeshBuilder import IsEqual from salome.smesh.smeshBuilder import IsEqual
compFun = lambda hyp, args: ( IsEqual(hyp.GetMinSize(), args[0]) and \ compFun = lambda hyp, args: ( IsEqual(hyp.GetMinSize(), args[0]) and \
IsEqual(hyp.GetMaxSize(), args[1]) and \ IsEqual(hyp.GetMaxSize(), args[1]) and \
IsEqual(hyp.GetDeflection(), args[2]) and \ IsEqual(hyp.GetDeflection(), args[2]))
IsEqual(hyp.GetGrading(), args[3])) hyp = self.Hypothesis("Adaptive1D", [minSize, maxSize, deflection],
hyp = self.Hypothesis("Adaptive1D", [minSize, maxSize, deflection, grading],
UseExisting=UseExisting, CompareMethod=compFun) UseExisting=UseExisting, CompareMethod=compFun)
hyp.SetMinSize(minSize) hyp.SetMinSize(minSize)
hyp.SetMaxSize(maxSize) hyp.SetMaxSize(maxSize)
hyp.SetDeflection(deflection) hyp.SetDeflection(deflection)
hyp.SetGrading(grading)
return hyp return hyp
## Defines "Arithmetic1D" hypothesis to cut an edge in several segments with a length ## Defines "Arithmetic1D" hypothesis to cut an edge in several segments with a length

22
src/StdMeshers/StdMeshers_Adaptive1D.cxx
View File

@ -942,7 +942,6 @@ StdMeshers_Adaptive1D::StdMeshers_Adaptive1D(int hypId,
myMinSize = 1e-10; myMinSize = 1e-10;
myMaxSize = 1e+10; myMaxSize = 1e+10;
myDeflection = 1e-2; myDeflection = 1e-2;
myGrading = 1e-2;
myAlgo = NULL; myAlgo = NULL;
_name = "Adaptive1D"; _name = "Adaptive1D";
_param_algo_dim = 1; // is used by SMESH_Regular_1D _param_algo_dim = 1; // is used by SMESH_Regular_1D
@ -969,20 +968,6 @@ void StdMeshers_Adaptive1D::SetDeflection(double value)
} }
} }
//======================================================================= //=======================================================================
//function : SetGrading
//purpose :
void StdMeshers_Adaptive1D::SetGrading(double value)
throw(SALOME_Exception)
{
if (value <= std::numeric_limits<double>::min() )
throw SALOME_Exception("Grading must be greater that zero");
if (myGrading != value)
{
myGrading = value;
NotifySubMeshesHypothesisModification();
}
}
//=======================================================================
//function : SetMinSize //function : SetMinSize
//purpose : Sets minimal allowed segment length //purpose : Sets minimal allowed segment length
void StdMeshers_Adaptive1D::SetMinSize(double minSize) void StdMeshers_Adaptive1D::SetMinSize(double minSize)
@ -1017,7 +1002,7 @@ void StdMeshers_Adaptive1D::SetMaxSize(double maxSize)
//purpose : Persistence //purpose : Persistence
ostream & StdMeshers_Adaptive1D::SaveTo(ostream & save) ostream & StdMeshers_Adaptive1D::SaveTo(ostream & save)
{ {
save << myMinSize << " " << myMaxSize << " " << myDeflection << " " << myGrading; save << myMinSize << " " << myMaxSize << " " << myDeflection;
save << " " << -1 << " " << -1; // preview addition of parameters save << " " << -1 << " " << -1; // preview addition of parameters
return save; return save;
} }
@ -1027,7 +1012,7 @@ ostream & StdMeshers_Adaptive1D::SaveTo(ostream & save)
istream & StdMeshers_Adaptive1D::LoadFrom(istream & load) istream & StdMeshers_Adaptive1D::LoadFrom(istream & load)
{ {
int dummyParam; int dummyParam;
bool isOK = (load >> myMinSize >> myMaxSize >> myDeflection >> myGrading >> dummyParam >> dummyParam); bool isOK = (load >> myMinSize >> myMaxSize >> myDeflection >> dummyParam >> dummyParam);
if (!isOK) if (!isOK)
load.clear(ios::badbit | load.rdstate()); load.clear(ios::badbit | load.rdstate());
return load; return load;
@ -1097,7 +1082,6 @@ bool StdMeshers_Adaptive1D::SetParametersByDefaults(const TDefaults& dflts,
myMinSize = dflts._elemLength / 10; myMinSize = dflts._elemLength / 10;
myMaxSize = dflts._elemLength * 2; myMaxSize = dflts._elemLength * 2;
myDeflection = myMinSize / 7; myDeflection = myMinSize / 7;
myGrading = 0.7;
return true; return true;
} }
@ -1161,7 +1145,7 @@ bool AdaptiveAlgo::Compute(SMESH_Mesh & theMesh,
myMesh = &theMesh; myMesh = &theMesh;
SMESH_MesherHelper helper( theMesh ); SMESH_MesherHelper helper( theMesh );
const double grading = myHyp->GetGrading(); const double grading = 0.7;
TopTools_IndexedMapOfShape edgeMap, faceMap; TopTools_IndexedMapOfShape edgeMap, faceMap;
TopExp::MapShapes( theShape, TopAbs_EDGE, edgeMap ); TopExp::MapShapes( theShape, TopAbs_EDGE, edgeMap );

9
src/StdMeshers/StdMeshers_Adaptive1D.hxx
View File

@ -59,13 +59,6 @@ class STDMESHERS_EXPORT StdMeshers_Adaptive1D : public SMESH_Hypothesis
void SetDeflection(double value) throw(SALOME_Exception); void SetDeflection(double value) throw(SALOME_Exception);
double GetDeflection() const { return myDeflection; } double GetDeflection() const { return myDeflection; }
/*!
* Sets <grading> parameter value,
* i.e. how much size of adjacent elements can differ
*/
void SetGrading(double value) throw(SALOME_Exception);
double GetGrading() const { return myGrading; }
virtual std::ostream & SaveTo(std::ostream & save); virtual std::ostream & SaveTo(std::ostream & save);
virtual std::istream & LoadFrom(std::istream & load); virtual std::istream & LoadFrom(std::istream & load);
@ -90,7 +83,7 @@ class STDMESHERS_EXPORT StdMeshers_Adaptive1D : public SMESH_Hypothesis
protected: protected:
double myMinSize, myMaxSize, myDeflection, myGrading; double myMinSize, myMaxSize, myDeflection;
SMESH_Algo* myAlgo; // StdMeshers_AdaptiveAlgo_1D implemented in cxx file SMESH_Algo* myAlgo; // StdMeshers_AdaptiveAlgo_1D implemented in cxx file
}; };

12
src/StdMeshersGUI/StdMeshersGUI_StdHypothesisCreator.cxx
View File

@ -609,8 +609,6 @@ QString StdMeshersGUI_StdHypothesisCreator::storeParams() const
h->SetMaxSize( params[1].myValue.toDouble() ); h->SetMaxSize( params[1].myValue.toDouble() );
h->SetVarParameter( params[0].text(), "SetDeflection" ); h->SetVarParameter( params[0].text(), "SetDeflection" );
h->SetDeflection( params[2].myValue.toDouble() ); h->SetDeflection( params[2].myValue.toDouble() );
h->SetVarParameter( params[0].text(), "SetGrading" );
h->SetGrading( params[3].myValue.toDouble() );
} }
else if( hypType()=="AutomaticLength" ) else if( hypType()=="AutomaticLength" )
{ {
@ -1050,11 +1048,6 @@ bool StdMeshersGUI_StdHypothesisCreator::stdParams( ListOfStdParams& p ) const
if(!initVariableName( hyp, item, "SetDeflection" )) if(!initVariableName( hyp, item, "SetDeflection" ))
item.myValue = h->GetDeflection(); item.myValue = h->GetDeflection();
p.append( item ); p.append( item );
item.myName = tr( "SMESH_GRADING1D_PARAM" );
if(!initVariableName( hyp, item, "SetGrading" ))
item.myValue = h->GetGrading();
p.append( item );
} }
else if( hypType()=="AutomaticLength" ) else if( hypType()=="AutomaticLength" )
{ {
@ -1428,10 +1421,7 @@ void StdMeshersGUI_StdHypothesisCreator::attuneStdWidget (QWidget* w, const int)
} }
else if( hypType()=="Adaptive1D" ) else if( hypType()=="Adaptive1D" )
{ {
if (sb->objectName() == tr("SMESH_GRADING1D_PARAM")) sb->RangeStepAndValidator( VALUE_SMALL, VALUE_MAX, 1.0, "length_precision" );
sb->RangeStepAndValidator( 0.0, 2.0, 0.1, "length_precision" );
else
sb->RangeStepAndValidator( VALUE_SMALL, VALUE_MAX, 1.0, "length_precision" );
} }
else if( hypType().startsWith( "ViscousLayers" )) else if( hypType().startsWith( "ViscousLayers" ))
{ {

4
src/StdMeshersGUI/StdMeshers_msg_en.ts
View File

@ -150,10 +150,6 @@
<source>SMESH_INVALID_FUNCTION</source> <source>SMESH_INVALID_FUNCTION</source>
<translation>Function is invalid</translation> <translation>Function is invalid</translation>
</message> </message>
<message>
<source>SMESH_GRADING1D_PARAM</source>
<translation>Grading</translation>
</message>
<message> <message>
<source>SMESH_LAYERS_DISTRIBUTION</source> <source>SMESH_LAYERS_DISTRIBUTION</source>
<translation>1D Hypothesis</translation> <translation>1D Hypothesis</translation>

4
src/StdMeshersGUI/StdMeshers_msg_fr.ts
View File

@ -135,10 +135,6 @@
<source>SMESH_INVALID_FUNCTION</source> <source>SMESH_INVALID_FUNCTION</source>
<translation>La fonction n&apos;est pas valide</translation> <translation>La fonction n&apos;est pas valide</translation>
</message> </message>
<message>
<source>SMESH_GRADING1D_PARAM</source>
<translation type="unfinished">Grading</translation>
</message>
<message> <message>
<source>SMESH_LAYERS_DISTRIBUTION</source> <source>SMESH_LAYERS_DISTRIBUTION</source>
<translation>Hypothèse 1D </translation> <translation>Hypothèse 1D </translation>

4
src/StdMeshersGUI/StdMeshers_msg_ja.ts
View File

@ -150,10 +150,6 @@
<source>SMESH_INVALID_FUNCTION</source> <source>SMESH_INVALID_FUNCTION</source>
<translation>関数が無効です。</translation> <translation>関数が無効です。</translation>
</message> </message>
<message>
<source>SMESH_GRADING1D_PARAM</source>
<translation type="unfinished">Grading</translation>
</message>
<message> <message>
<source>SMESH_LAYERS_DISTRIBUTION</source> <source>SMESH_LAYERS_DISTRIBUTION</source>
<translation>仮説 1 d</translation> <translation>仮説 1 d</translation>

31
src/StdMeshers_I/StdMeshers_Adaptive1D_i.cxx
View File

@ -152,37 +152,6 @@ CORBA::Double StdMeshers_Adaptive1D_i::GetDeflection()
return this->GetImpl()->GetDeflection(); return this->GetImpl()->GetDeflection();
} }
//=======================================================================
//function : SetGrading
//purpose : Sets how much size of adjacent elements can differ.
//=======================================================================
void StdMeshers_Adaptive1D_i::SetGrading( CORBA::Double theValue )
throw ( SALOME::SALOME_Exception )
{
ASSERT( myBaseImpl );
try {
this->GetImpl()->SetGrading( theValue );
}
catch ( SALOME_Exception& S_ex ) {
THROW_SALOME_CORBA_EXCEPTION( S_ex.what(), SALOME::BAD_PARAM );
}
// Update Python script
SMESH::TPythonDump() << _this() << ".SetGrading( " << SMESH::TVar(theValue) << " )";
}
//=======================================================================
//function : GetGrading
//purpose : Returns grading
//=======================================================================
CORBA::Double StdMeshers_Adaptive1D_i::GetGrading()
{
ASSERT( myBaseImpl );
return this->GetImpl()->GetGrading();
}
//======================================================================= //=======================================================================
//function : GetImpl //function : GetImpl
//purpose : Get implementation //purpose : Get implementation

6
src/StdMeshers_I/StdMeshers_Adaptive1D_i.hxx
View File

@ -70,12 +70,6 @@ class STDMESHERS_I_EXPORT StdMeshers_Adaptive1D_i:
void SetDeflection( CORBA::Double theLength ) throw (SALOME::SALOME_Exception); void SetDeflection( CORBA::Double theLength ) throw (SALOME::SALOME_Exception);
CORBA::Double GetDeflection(); CORBA::Double GetDeflection();
/*!
* Sets <grading> parameter value,
// * i.e. a maximal allowed distance between a segment and an edge.
*/
void SetGrading( CORBA::Double theLength ) throw (SALOME::SALOME_Exception);
CORBA::Double GetGrading();
/*! /*!
* Returns implementation * Returns implementation