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, 1, 0, 1, 3);
+ GroupC1Layout->addWidget(Reverse, 2, 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)));
-
+ 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
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 = 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;
+ 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;
}
// 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 :
// 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;
