# 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 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
maxSize = 200
deflection = 0.05
-grading = 0.7
mesh = smesh.Mesh( shape )
-mesh.Segment().Adaptive( minSize, maxSize, deflection, grading )
+mesh.Segment().Adaptive( minSize, maxSize, deflection )
mesh.Triangle().MaxElementArea( 300 )
mesh.Compute()
- <b>Min size</b> parameter limits the minimal segment size.
- <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>Grading</b> parameter defines how much size of adjacent elements can differ.
+- \b Deflection parameter gives maximal distance of a segment from a curved edge.
+
\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.
*/
void SetDeflection(in double deflection) raises (SALOME::SALOME_Exception);
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();
};
/*!
<hypo>GeometricProgression=GeometricProgression(SetStartLength(),SetCommonRatio(),SetReversedEdges())</hypo>
<hypo>StartEndLength=StartEndLength(SetStartLength(),SetEndLength(),SetReversedEdges())</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>FixedPoints1D=FixedPoints1D(SetPoints(),SetNbSegments(),SetReversedEdges())</hypo>
<hypo>Propagation=Propagation()</hypo>
<hypo>GeometricProgression=GeometricProgression(SetStartLength(),SetCommonRatio(),SetReversedEdges())</hypo>
<hypo>StartEndLength=StartEndLength(SetStartLength(),SetEndLength(),SetReversedEdges())</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>FixedPoints1D=FixedPoints1D(SetPoints(),SetNbSegments(),SetReversedEdges())</hypo>
<hypo>Propagation=Propagation()</hypo>
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;
QLabel* diameterLabel = DiameterSpinBox ? new QLabel( tr("BALL_DIAMETER"),GroupC1) : 0;
GroupC1Layout->addWidget(TextLabelC1A1, 0, 0);
GroupC1Layout->addWidget(SelectButtonC1A1, 0, 1);
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 ) {
- GroupC1Layout->addWidget(Reverse, 2, 0, 1, 3);
+ GroupC1Layout->addWidget(Reverse, 1, 0, 1, 3);
}
if ( DiameterSpinBox ) {
GroupC1Layout->addWidget(diameterLabel, 1, 0);
myActor = 0;
/* signals and slots connections */
- connect(buttonOk, SIGNAL(clicked()), SLOT(ClickOnOk()));
- connect(buttonCancel, SIGNAL(clicked()), SLOT(reject()));
- connect(buttonApply, SIGNAL(clicked()), SLOT(ClickOnApply()));
- connect(buttonHelp, SIGNAL(clicked()), SLOT(ClickOnHelp()));
-
- connect(SelectButtonC1A1, SIGNAL(clicked()), SLOT(SetEditCurrentArgument()));
- connect(LineEditC1A1, SIGNAL(textChanged(const QString&)), SLOT(onTextChange(const QString&)));
- connect(mySMESHGUI, SIGNAL(SignalDeactivateActiveDialog()),SLOT(DeactivateActiveDialog()));
- connect(mySelectionMgr, SIGNAL(currentSelectionChanged()), SLOT(SelectionIntoArgument()));
+ connect(buttonOk, SIGNAL(clicked()), SLOT(ClickOnOk()));
+ connect(buttonCancel, SIGNAL(clicked()), SLOT(reject()));
+ connect(buttonApply, SIGNAL(clicked()), SLOT(ClickOnApply()));
+ connect(buttonHelp, SIGNAL(clicked()), SLOT(ClickOnHelp()));
+
+ connect(SelectButtonC1A1,SIGNAL(clicked()), SLOT(SetEditCurrentArgument()));
+ connect(LineEditC1A1, SIGNAL(textChanged(const QString&)), SLOT(onTextChange(const QString&)));
+ connect(mySMESHGUI, SIGNAL(SignalDeactivateActiveDialog()),SLOT(DeactivateActiveDialog()));
+ connect(mySelectionMgr, SIGNAL(currentSelectionChanged()), SLOT(SelectionIntoArgument()));
/* to close dialog if study frame change */
- connect(mySMESHGUI, SIGNAL(SignalStudyFrameChanged()), SLOT(reject()));
- connect(mySMESHGUI, SIGNAL(SignalCloseAllDialogs()), SLOT(reject()));
+ connect(mySMESHGUI, SIGNAL(SignalStudyFrameChanged()), SLOT(reject()));
+ connect(mySMESHGUI, SIGNAL(SignalCloseAllDialogs()), SLOT(reject()));
if (Reverse)
- connect(Reverse, SIGNAL(stateChanged(int)), SLOT(CheckBox(int)));
- if (AutomaticPresentation) {
- connect(AutomaticPresentation, SIGNAL(stateChanged(int)), SLOT(SelectionIntoArgument()));
- connect(GetNextPresentationButton, SIGNAL(clicked()), SLOT(GetNextShapePresentation()));
- }
+ connect(Reverse, SIGNAL(stateChanged(int)), SLOT(CheckBox(int)));
+
// set selection mode
SMESH::SetPointRepresentation(true);
buttonOk->setEnabled(false);
buttonApply->setEnabled(false);
- if ( AutomaticPresentation )
- GetNextPresentationButton->setEnabled(false);
myEditCurrentArgument->setText("");
buttonOk->setEnabled(false);
buttonApply->setEnabled(false);
- if ( AutomaticPresentation )
- GetNextPresentationButton->setEnabled(false);
mySimulation->SetVisibility(false);
if(myNbOkNodes) {
buttonOk->setEnabled(true);
buttonApply->setEnabled(true);
- if ( AutomaticPresentation && AutomaticPresentation->isChecked() )
- GetNextPresentationButton->setEnabled(true);
displaySimulation();
}
myActor = 0;
myBusy = true;
- QString anOldEditArgument = myEditCurrentArgument->text();
myEditCurrentArgument->setText("");
myBusy = false;
buttonOk->setEnabled(false);
buttonApply->setEnabled(false);
- if ( AutomaticPresentation )
- GetNextPresentationButton->setEnabled(false);
mySimulation->SetVisibility(false);
// SMESH::SetPointRepresentation(true);
// get selected nodes
QString aString = "";
- int nbNodes = 0;
- while ( aString == "" || anOldEditArgument == aString ) {
- if ( AutomaticPresentation && AutomaticPresentation->isChecked() ) {
- nbNodes = SMESH::GetNameOfSelectedSortedNodes( myGeomType , mySelector, myActor, myShift, aString );
- }
- else
- nbNodes = SMESH::GetNameOfSelectedNodes( mySelector, myActor->getIO(), aString );
- if ( aString!= "" && myNbNodes == nbNodes && anOldEditArgument == aString && AutomaticPresentation && AutomaticPresentation->isChecked()) {
- 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;
+ int nbNodes = SMESH::GetNameOfSelectedNodes(mySelector,myActor->getIO(),aString);
+ myBusy = true;
+ myEditCurrentArgument->setText(aString);
+ myBusy = false;
+ if (myIsPoly && myElementType == SMDSAbs_Face && nbNodes >= 3 ) {
+ myNbNodes = nbNodes;
+ } else if (myNbNodes != nbNodes && myNbNodes != 1) {
+ return;
}
// OK
buttonOk->setEnabled(true);
buttonApply->setEnabled(true);
- if ( AutomaticPresentation && AutomaticPresentation->isChecked() )
- GetNextPresentationButton->setEnabled(true);
displaySimulation();
}
SelectionIntoArgument();
}
-//=================================================================================
-// function : GetNextShapePresentation()
-// purpose :
-//=================================================================================
-void SMESHGUI_AddMeshElementDlg::GetNextShapePresentation()
-{
- myShift++;
- SetEditCurrentArgument();
-}
-
//=================================================================================
// function : DeactivateActiveDialog()
// purpose :
int myElementType;
int myNbNodes;
bool myIsPoly;
- int myShift;
SMESH::SMESH_Mesh_var myMesh;
SMESH_Actor* myActor;
QGroupBox* GroupC1;
QLabel* TextLabelC1A1;
QPushButton* SelectButtonC1A1;
- QPushButton* GetNextPresentationButton;
QLineEdit* LineEditC1A1;
QCheckBox* Reverse;
- QCheckBox* AutomaticPresentation;
SMESHGUI_SpinBox* DiameterSpinBox;
QString myHelpFileName;
void ClickOnOk();
void ClickOnApply();
void ClickOnHelp();
- void GetNextShapePresentation();
void SetEditCurrentArgument();
void SelectionIntoArgument();
void DeactivateActiveDialog();
#include <SMESH_Actor.h>
#include <SMESH_ActorUtils.h>
-#include <SMESH_DeviceActor.h>
#include <SMESH_FaceOrientationFilter.h>
#include <SMDS_Mesh.hxx>
#include <SVTK_ViewWindow.h>
#include <SALOME_ListIO.hxx>
-#include <SALOME_ListIteratorOfListIO.hxx>
-#include <VTKViewer_PolyDataMapper.h>
#include <SalomeApp_Application.h>
#include <TColStd_MapOfInteger.hxx>
// VTK includes
-#include <vtkCell.h>
#include <vtkIdList.h>
#include <vtkUnstructuredGrid.h>
#include <vtkDataSetMapper.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
#include <vtkCellType.h>
-#include <vtkCellData.h>
// Qt includes
#include <QComboBox>
SALOME_Actor* myPreviewActor;
vtkDataSetMapper* myMapper;
vtkUnstructuredGrid* myGrid;
-
- SALOME_Actor* myCornerActor;
- VTKViewer_PolyDataMapper* myCornerMapper;
- vtkPolyData* myCornerPolyData;
-
- SALOME_Actor* mySelectCornerActor;
- VTKViewer_PolyDataMapper* mySelectCornerMapper;
- vtkPolyData* mySelectCornerPolyData;
+ //vtkProperty* myBackProp, *myProp;
//double myRGB[3], myBackRGB[3];
anOrientationProp->Delete();
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;
myPreviewActor->GetMapper()->Update();
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,
- bool theSelectCornerVisibility = false,
- bool theShowOrientation = false )
+ void SetVisibility (bool theVisibility, bool theShowOrientation = false)
{
myPreviewActor->SetVisibility(theVisibility);
myFaceOrientation->SetVisibility(theShowOrientation);
- myCornerActor->SetVisibility(theCornerVisibility);
- mySelectCornerActor->SetVisibility(theSelectCornerVisibility);
RepaintCurrentView();
}
+
~TElementSimulationQuad()
{
if (FindVtkViewWindow(myApplication->activeViewManager(), myViewWindow)) {
myVTKViewWindow->RemoveActor(myPreviewActor);
myVTKViewWindow->RemoveActor(myFaceOrientation);
- myVTKViewWindow->RemoveActor(myCornerActor);
- myVTKViewWindow->RemoveActor(mySelectCornerActor);
}
myPreviewActor->Delete();
myFaceOrientation->Delete();
- myCornerActor->Delete();
- mySelectCornerActor->Delete();
myMapper->RemoveAllInputs();
myMapper->Delete();
myGrid->Delete();
- myCornerMapper->RemoveAllInputs();
- myCornerMapper->Delete();
- myCornerPolyData->Delete();
-
- mySelectCornerMapper->RemoveAllInputs();
- mySelectCornerMapper->Delete();
- mySelectCornerPolyData->Delete();
-
// myProp->Delete();
// myBackProp->Delete();
}
myCenterNode->setValidator(new SMESHGUI_IdValidator(this, 1));
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(myCornerSelectButton, 0, 1);
aGroupArgumentsLayout->addWidget(myCornerNodes, 0, 2);
- if ( myAutomaticPresentation ) {
- myAutomaticPresentation->setChecked(true);
- aGroupArgumentsLayout->addWidget(myAutomaticPresentation, 1, 0, 1, 2);
- aGroupArgumentsLayout->addWidget(myNextPresentationButton, 1, 2, 1, 1);
- }
- aGroupArgumentsLayout->addWidget(myTable, 2, 0, 1, 3);
- aGroupArgumentsLayout->addWidget(myMidFaceLabel, 3, 0);
- aGroupArgumentsLayout->addWidget(myMidFaceSelectButton, 3, 1);
- 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);
+ aGroupArgumentsLayout->addWidget(myTable, 1, 0, 1, 3);
+ aGroupArgumentsLayout->addWidget(myMidFaceLabel, 2, 0);
+ aGroupArgumentsLayout->addWidget(myMidFaceSelectButton, 2, 1);
+ aGroupArgumentsLayout->addWidget(myMidFaceNodes, 2, 2);
+ aGroupArgumentsLayout->addWidget(myCenterLabel, 3, 0);
+ aGroupArgumentsLayout->addWidget(myCenterSelectButton, 3, 1);
+ aGroupArgumentsLayout->addWidget(myCenterNode, 3, 2);
+ aGroupArgumentsLayout->addWidget(myReverseCB, 4, 0, 1, 3);
+
/***************************************************************/
GroupGroups = new QGroupBox( tr( "SMESH_ADD_TO_GROUP" ), this );
GroupGroups->setCheckable( true );
connect(mySMESHGUI, SIGNAL (SignalDeactivateActiveDialog()), SLOT(DeactivateActiveDialog()));
connect(mySMESHGUI, SIGNAL (SignalStudyFrameChanged()), 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;
// set selection mode
if ( myCurrentLineEdit == myCornerNodes )
UpdateTable( allOk );
}
+
updateButtons();
displaySimulation();
}
BusyLocker lock( myBusy );
QString aCurrentEntry = myEntry;
- QString anOldEditArgument = "";
- // clear
- myActor = 0;
- if ( myCurrentLineEdit ) {
- anOldEditArgument = myCurrentLineEdit->text();
+
+ if ( myCurrentLineEdit )
+ {
+ // clear
+ myActor = 0;
+
myCurrentLineEdit->setText("");
- }
- if (!GroupButtons->isEnabled()) // inactive
- return;
+ if (!GroupButtons->isEnabled()) // inactive
+ return;
- mySimulation->SetVisibility(false);
+ mySimulation->SetVisibility(false);
- // get selected mesh
- SALOME_ListIO aList;
- mySelectionMgr->selectedObjects(aList);
+ // get selected mesh
+ SALOME_ListIO aList;
+ mySelectionMgr->selectedObjects(aList);
- if (aList.Extent() != 1)
- {
- UpdateTable();
- updateButtons();
- return;
- }
+ 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;
- }
+ Handle(SALOME_InteractiveObject) anIO = aList.First();
+ myEntry = anIO->getEntry();
+ myMesh = SMESH::GetMeshByIO(anIO);
+ if (myMesh->_is_nil()) {
+ updateButtons();
+ return;
+ }
- myActor = SMESH::FindActorByEntry(anIO->getEntry());
+ myActor = SMESH::FindActorByEntry(anIO->getEntry());
+
+ }
// process groups
if ( !myMesh->_is_nil() && myEntry != aCurrentEntry ) {
updateButtons();
return;
}
- if ( myAutomaticPresentation )
- myNextPresentationButton->setEnabled(false);
+
// get selected nodes
QString aString = "";
- int nbNodes = 0;
- 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;
- }
+ int nbNodes = SMESH::GetNameOfSelectedNodes(mySelector,myActor->getIO(),aString);
+
if ( myCurrentLineEdit )
{
- if ( myCurrentLineEdit != myCenterNode || nbNodes == 1)
+ if ( myCurrentLineEdit != myCenterNode || nbNodes == 1 )
myCurrentLineEdit->setText(aString);
- if ( myCurrentLineEdit == myCornerNodes ) {
+ if ( myCurrentLineEdit == myCornerNodes )
UpdateTable();
- if ( myAutomaticPresentation && myAutomaticPresentation->isChecked() && myNbCorners == nbNodes)
- myNextPresentationButton->setEnabled(true);
- }
}
else if ( myTable->isEnabled() && nbNodes == 1 )
{
if ( theCol == 1 )
myTable->item(theRow, 1)->setText(aString);
}
+
updateButtons();
displaySimulation();
}
// purpose :
//=================================================================================
-void SMESHGUI_AddQuadraticElementDlg::displaySimulation(int theRow, int theCol)
+void SMESHGUI_AddQuadraticElementDlg::displaySimulation()
{
- bool isValid = IsValid();
- if ( ( isValid || myTable->isEnabled() ) && myActor )
+ if ( IsValid() )
{
SMESH::TElementSimulationQuad::TVTKIds anIds;
int anID;
bool ok;
int aDisplayMode = VTK_SURFACE;
+
if ( myGeomType == SMDSEntity_Quad_Edge )
{
anIds.push_back( myActor->GetObject()->GetNodeVTKId( myTable->item(0, 0)->text().toInt() ) );
}
anIds.push_back( myActor->GetObject()->GetNodeVTKId(anID) );
}
- if ( myNbMidFaceNodes && isValid)
+ if ( myNbMidFaceNodes )
{
QStringList aListId = myMidFaceNodes->text().split(" ", QString::SkipEmptyParts);
for (int i = 0; i < aListId.count(); i++)
anIds.push_back( myActor->GetObject()->GetNodeVTKId( aListId[ i ].toInt() ));
}
- if ( myNbCenterNodes && isValid)
+ if ( myNbCenterNodes )
{
QStringList aListId = myCenterNode->text().split(" ", QString::SkipEmptyParts);
anIds.push_back( myActor->GetObject()->GetNodeVTKId( aListId[ 0 ].toInt() ));
}
}
- if ( isValid )
- 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());
+
+ mySimulation->SetPosition(myActor,myGeomType,anIds,aDisplayMode,myReverseCB->isChecked());
}
else
{
QPushButton* send = (QPushButton*)sender();
myCurrentLineEdit = 0;
- if (send == myCornerSelectButton || (QCheckBox*)sender() == myAutomaticPresentation)
+ if (send == myCornerSelectButton)
myCurrentLineEdit = myCornerNodes;
else if ( send == myMidFaceSelectButton )
myCurrentLineEdit = myMidFaceNodes;
else if ( send == myCenterSelectButton )
myCurrentLineEdit = myCenterNode;
- else if (send == myNextPresentationButton ) {
- myShift++;
- myCurrentLineEdit = myCornerNodes;
- }
if ( myCurrentLineEdit )
{
void SMESHGUI_AddQuadraticElementDlg::onCellDoubleClicked( int theRow, int theCol )
{
myCurrentLineEdit = 0;
- displaySimulation(theRow, theCol);
+ displaySimulation();
updateButtons();
}
void SMESHGUI_AddQuadraticElementDlg::onCellTextChange(int theRow, int theCol)
{
myCurrentLineEdit = 0;
- displaySimulation(theRow, theCol);
+ displaySimulation();
updateButtons();
}
void Init();
void enterEvent( QEvent* ); /* mouse enter the QWidget */
void keyPressEvent( QKeyEvent* );
- void displaySimulation(int = -1, int = -1);
+ void displaySimulation();
void UpdateTable( bool = true );
bool IsValid();
void updateButtons();
int myNbMidFaceNodes;
int myNbCenterNodes;
bool myBusy;
- int myShift;
SVTK_Selector* mySelector;
SMESH::SMESH_Mesh_var myMesh;
QPushButton* myCenterSelectButton;
QLineEdit* myCenterNode;
QTableWidget* myTable;
- QCheckBox* myAutomaticPresentation;
- QPushButton* myNextPresentationButton;
QCheckBox* myReverseCB;
QGroupBox* GroupGroups;
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* algoByDim[4];
algoByDim[ aDim ] = algoData;
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;
isAvailableChoiceAlgo = false;
}
myAvailableHypData[dim][Algo].clear();
anAvailableAlgs.clear();
- if ( dim != SMESH::DIM_2D || currentHyp( SMESH::DIM_3D, Algo ) < 0 ||
- 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++)
{
- 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);
- if ( aGeomVar->_is_nil() ||
- SMESH::IsApplicable( curAlgo->TypeName, aGeomVar, toCheckIsApplicableToAll ))
- {
- anAvailableAlgs.append( curAlgo->Label );
- myAvailableHypData[dim][Algo].append( curAlgo );
- }
+ anAvailableAlgs.append( curAlgo->Label );
+ myAvailableHypData[dim][Algo].append( curAlgo );
}
- if ( !isNone && algoCur ) {
- 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++)
+ {
+ HypothesisData* algoAny = myAvailableHypData[dim][Algo].at(i);
+ if ( algoAny->Label == algoCur->Label ){
+ isAvailableChoiceAlgo = true;
+ anCurrentAvailableAlgo = i;
+ break;
}
}
- else if ( !isNone ) {
- isAvailableChoiceAlgo = true;
- anCurrentAvailableAlgo = currentHyp( dim, Algo );
- }
+ }
+ else if ( !isNone ) {
+ isAvailableChoiceAlgo = true;
+ anCurrentAvailableAlgo = currentHyp( dim, Algo );
}
myDlg->tab( dim )->setAvailableHyps( Algo, anAvailableAlgs );
if ( isAvailableChoiceAlgo )
{
for (int i = SMESH::DIM_0D; i <= myMaxShapeDim; i++)
{
- if ( myAvailableHypData[i][Algo].count() == 0 ) {
- availableHyps( i, Algo, anAvailableAlgs, anAvailableAlgsData );
- for ( int i = 0 ; i < anAvailableAlgsData.count(); i++ )
- {
- HypothesisData* aCurAlgo = anAvailableAlgsData.at( i );
- 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;
- }
+ 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;
// OCCT includes
#include <TColStd_IndexedMapOfInteger.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
{
//----------------------------------------------------------------------------
- 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,
const Handle(SALOME_InteractiveObject)& theIO,
QString& theName)
DistanceToPosition( theBounds, theNormal, theDist, theOrigin );
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,
- double theBounds[6])
+ double theBounds[6])
{
bool anIsOk = false;
theBounds[0] = theBounds[2] = theBounds[4] = VTK_DOUBLE_MAX;
// SMESH includes
#include "SMESH_SMESHGUI.hxx"
-#include "SMESH_TypeDefs.hxx"
-#include "SMDS_MeshNode.hxx"
#include "SMESHGUI_Utils.h"
-
#include <SMESH_Object.h>
// SALOME KERNEL includes
class SALOME_Actor;
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
{
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
SMESHGUI_EXPORT
- int GetNameOfSelectedSortedNodes( SMDSAbs_EntityType,
- SVTK_Selector*,
- SMESH_Actor*,
- int,
- QString& );
-SMESHGUI_EXPORT
int GetNameOfSelectedNodes( SVTK_Selector*,
const Handle(SALOME_InteractiveObject)&,
QString& );
double theDirection[3],
double thePos[3],
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
void RemoveVisualObjectWithActors( const char* theEntry, bool fromAllViews = false );
};
<source>SMESH_AUTO_DIM</source>
<translation>Automatically define space dimension</translation>
</message>
- <message>
- <source>SMESH_AUTOMATIC_PRESENTATION</source>
- <translation>Random input ID</translation>
- </message>
<message>
<source>SMESH_REQUIRED_GROUPS</source>
<translation>Create groups of required entities</translation>
<source>SMESH_BUT_APPLY_AND_CLOSE</source>
<translation>A&pply and Close</translation>
</message>
- <message>
- <source>SMESH_BUT_GET_NEXT_SHAPE</source>
- <translation>Get next shape</translation>
- </message>
<message>
<source>SMESH_BUT_REMOVE</source>
<translation>&Remove</translation>
<source>SMESH_AUTO_DIM</source>
<translation>Définition automatique des dimensions spatiales</translation>
</message>
- <message>
- <source>SMESH_AUTOMATIC_PRESENTATION</source>
- <translation type="unfinished">Random input ID</translation>
- </message>
<message>
<source>SMESH_REQUIRED_GROUPS</source>
<translation>Créer les groupes des types nécessaires</translation>
<source>SMESH_BUT_APPLY_AND_CLOSE</source>
<translation>App&liquer et fermer</translation>
</message>
- <message>
- <source>SMESH_BUT_GET_NEXT_SHAPE</source>
- <translation type="unfinished">Get next shape</translation>
- </message>
<message>
<source>SMESH_BUT_REMOVE</source>
<translation>S&upprimer</translation>
<source>SMESH_AUTO_DIM</source>
<translation>自動的に空間の寸法を定義します。</translation>
</message>
- <message>
- <source>SMESH_AUTOMATIC_PRESENTATION</source>
- <translation type="unfinished">Random input ID</translation>
- </message>
<message>
<source>SMESH_REQUIRED_GROUPS</source>
<translation>必要な種類のグループを作成します。</translation>
<source>SMESH_BUT_APPLY_AND_CLOSE</source>
<translation>適用して閉じる(&p)</translation>
</message>
- <message>
- <source>SMESH_BUT_GET_NEXT_SHAPE</source>
- <translation type="unfinished">Get next shape</translation>
- </message>
<message>
<source>SMESH_BUT_REMOVE</source>
<translation>削除(&R)</translation>
# @param minSize defines the minimal 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 grading defines how much size of adjacent elements can differ
# @param UseExisting if ==true - searches for an existing hypothesis created with
# the same parameters, else (default) - creates a new one
# @return an instance of StdMeshers_Adaptive1D hypothesis
# @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
compFun = lambda hyp, args: ( IsEqual(hyp.GetMinSize(), args[0]) and \
IsEqual(hyp.GetMaxSize(), args[1]) and \
- IsEqual(hyp.GetDeflection(), args[2]) and \
- IsEqual(hyp.GetGrading(), args[3]))
- hyp = self.Hypothesis("Adaptive1D", [minSize, maxSize, deflection, grading],
+ IsEqual(hyp.GetDeflection(), args[2]))
+ hyp = self.Hypothesis("Adaptive1D", [minSize, maxSize, deflection],
UseExisting=UseExisting, CompareMethod=compFun)
hyp.SetMinSize(minSize)
hyp.SetMaxSize(maxSize)
hyp.SetDeflection(deflection)
- hyp.SetGrading(grading)
return hyp
## Defines "Arithmetic1D" hypothesis to cut an edge in several segments with a length
myMinSize = 1e-10;
myMaxSize = 1e+10;
myDeflection = 1e-2;
- myGrading = 1e-2;
myAlgo = NULL;
_name = "Adaptive1D";
_param_algo_dim = 1; // is used by SMESH_Regular_1D
}
}
//=======================================================================
-//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
//purpose : Sets minimal allowed segment length
void StdMeshers_Adaptive1D::SetMinSize(double minSize)
//purpose : Persistence
ostream & StdMeshers_Adaptive1D::SaveTo(ostream & save)
{
- save << myMinSize << " " << myMaxSize << " " << myDeflection << " " << myGrading;
+ save << myMinSize << " " << myMaxSize << " " << myDeflection;
save << " " << -1 << " " << -1; // preview addition of parameters
return save;
}
istream & StdMeshers_Adaptive1D::LoadFrom(istream & load)
{
int dummyParam;
- bool isOK = (load >> myMinSize >> myMaxSize >> myDeflection >> myGrading >> dummyParam >> dummyParam);
+ bool isOK = (load >> myMinSize >> myMaxSize >> myDeflection >> dummyParam >> dummyParam);
if (!isOK)
load.clear(ios::badbit | load.rdstate());
return load;
myMinSize = dflts._elemLength / 10;
myMaxSize = dflts._elemLength * 2;
myDeflection = myMinSize / 7;
- myGrading = 0.7;
return true;
}
myMesh = &theMesh;
SMESH_MesherHelper helper( theMesh );
- const double grading = myHyp->GetGrading();
+ const double grading = 0.7;
TopTools_IndexedMapOfShape edgeMap, faceMap;
TopExp::MapShapes( theShape, TopAbs_EDGE, edgeMap );
void SetDeflection(double value) throw(SALOME_Exception);
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::istream & LoadFrom(std::istream & load);
protected:
- double myMinSize, myMaxSize, myDeflection, myGrading;
+ double myMinSize, myMaxSize, myDeflection;
SMESH_Algo* myAlgo; // StdMeshers_AdaptiveAlgo_1D implemented in cxx file
};
h->SetMaxSize( params[1].myValue.toDouble() );
h->SetVarParameter( params[0].text(), "SetDeflection" );
h->SetDeflection( params[2].myValue.toDouble() );
- h->SetVarParameter( params[0].text(), "SetGrading" );
- h->SetGrading( params[3].myValue.toDouble() );
}
else if( hypType()=="AutomaticLength" )
{
if(!initVariableName( hyp, item, "SetDeflection" ))
item.myValue = h->GetDeflection();
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()=="Adaptive1D" )
{
- if (sb->objectName() == tr("SMESH_GRADING1D_PARAM"))
- sb->RangeStepAndValidator( 0.0, 2.0, 0.1, "length_precision" );
- else
- sb->RangeStepAndValidator( VALUE_SMALL, VALUE_MAX, 1.0, "length_precision" );
+ sb->RangeStepAndValidator( VALUE_SMALL, VALUE_MAX, 1.0, "length_precision" );
}
else if( hypType().startsWith( "ViscousLayers" ))
{
<source>SMESH_INVALID_FUNCTION</source>
<translation>Function is invalid</translation>
</message>
- <message>
- <source>SMESH_GRADING1D_PARAM</source>
- <translation>Grading</translation>
- </message>
<message>
<source>SMESH_LAYERS_DISTRIBUTION</source>
<translation>1D Hypothesis</translation>
<source>SMESH_INVALID_FUNCTION</source>
<translation>La fonction n'est pas valide</translation>
</message>
- <message>
- <source>SMESH_GRADING1D_PARAM</source>
- <translation type="unfinished">Grading</translation>
- </message>
<message>
<source>SMESH_LAYERS_DISTRIBUTION</source>
<translation>Hypothèse 1D </translation>
<source>SMESH_INVALID_FUNCTION</source>
<translation>関数が無効です。</translation>
</message>
- <message>
- <source>SMESH_GRADING1D_PARAM</source>
- <translation type="unfinished">Grading</translation>
- </message>
<message>
<source>SMESH_LAYERS_DISTRIBUTION</source>
<translation>仮説 1 d</translation>
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
//purpose : Get implementation
void SetDeflection( CORBA::Double theLength ) throw (SALOME::SALOME_Exception);
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
