X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FControls%2FSMESH_Controls.cxx;h=a8f371a4bc1c859aea8fc52bef5cb677340d4365;hb=64c772da5a9dd285f16f1f7efa07bb4c7fbdd4c3;hp=2bf885a7a29a0d1500bc03e04f0818c4e2eda230;hpb=090aff07266d376ae028ae43434bdea7c0a0f9bb;p=modules%2Fsmesh.git diff --git a/src/Controls/SMESH_Controls.cxx b/src/Controls/SMESH_Controls.cxx index 2bf885a7a..a8f371a4b 100644 --- a/src/Controls/SMESH_Controls.cxx +++ b/src/Controls/SMESH_Controls.cxx @@ -1,61 +1,66 @@ // Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, -// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS -// -// This library is free software; you can redistribute it and/or -// modify it under the terms of the GNU Lesser General Public +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either -// version 2.1 of the License. -// -// This library is distributed in the hope that it will be useful, +// version 2.1 of the License. +// +// This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public -// License along with this library; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -// -// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com #include "SMESH_ControlsDef.hxx" #include +#include #include -#include -#include -#include -#include -#include -#include -#include -#include #include +#include +#include #include -#include +#include #include #include -#include +#include #include #include #include #include +#include +#include +#include +#include +#include +#include +#include #include "SMDS_Mesh.hxx" #include "SMDS_Iterator.hxx" #include "SMDS_MeshElement.hxx" #include "SMDS_MeshNode.hxx" +#include "SMDS_VolumeTool.hxx" +#include "SMDS_QuadraticFaceOfNodes.hxx" +#include "SMDS_QuadraticEdge.hxx" /* - AUXILIARY METHODS + AUXILIARY METHODS */ namespace{ inline double getAngle( const gp_XYZ& P1, const gp_XYZ& P2, const gp_XYZ& P3 ) { gp_Vec v1( P1 - P2 ), v2( P3 - P2 ); - + return v1.Magnitude() < gp::Resolution() || v2.Magnitude() < gp::Resolution() ? 0 : v1.Angle( v2 ); } @@ -80,39 +85,76 @@ namespace{ return aDist; } - int getNbMultiConnection( SMDS_Mesh* theMesh, const int theId ) + int getNbMultiConnection( const SMDS_Mesh* theMesh, const int theId ) { if ( theMesh == 0 ) return 0; - + const SMDS_MeshElement* anEdge = theMesh->FindElement( theId ); - if ( anEdge == 0 || anEdge->GetType() != SMDSAbs_Edge || anEdge->NbNodes() != 2 ) + if ( anEdge == 0 || anEdge->GetType() != SMDSAbs_Edge/* || anEdge->NbNodes() != 2 */) return 0; - - TColStd_MapOfInteger aMap; - - int aResult = 0; - SMDS_ElemIteratorPtr anIter = anEdge->nodesIterator(); - if ( anIter != 0 ) { - while( anIter->more() ) { - const SMDS_MeshNode* aNode = (SMDS_MeshNode*)anIter->next(); - if ( aNode == 0 ) - return 0; - SMDS_ElemIteratorPtr anElemIter = aNode->GetInverseElementIterator(); - while( anElemIter->more() ) { - const SMDS_MeshElement* anElem = anElemIter->next(); - if ( anElem != 0 && anElem->GetType() != SMDSAbs_Edge ) { - int anId = anElem->GetID(); - - if ( anIter->more() ) // i.e. first node - aMap.Add( anId ); - else if ( aMap.Contains( anId ) ) - aResult++; - } - } + + // for each pair of nodes in anEdge (there are 2 pairs in a quadratic edge) + // count elements containing both nodes of the pair. + // Note that there may be such cases for a quadratic edge (a horizontal line): + // + // Case 1 Case 2 + // | | | | | + // | | | | | + // +-----+------+ +-----+------+ + // | | | | + // | | | | + // result sould be 2 in both cases + // + int aResult0 = 0, aResult1 = 0; + // last node, it is a medium one in a quadratic edge + const SMDS_MeshNode* aLastNode = anEdge->GetNode( anEdge->NbNodes() - 1 ); + const SMDS_MeshNode* aNode0 = anEdge->GetNode( 0 ); + const SMDS_MeshNode* aNode1 = anEdge->GetNode( 1 ); + if ( aNode1 == aLastNode ) aNode1 = 0; + + SMDS_ElemIteratorPtr anElemIter = aLastNode->GetInverseElementIterator(); + while( anElemIter->more() ) { + const SMDS_MeshElement* anElem = anElemIter->next(); + if ( anElem != 0 && anElem->GetType() != SMDSAbs_Edge ) { + SMDS_ElemIteratorPtr anIter = anElem->nodesIterator(); + while ( anIter->more() ) { + if ( const SMDS_MeshElement* anElemNode = anIter->next() ) { + if ( anElemNode == aNode0 ) { + aResult0++; + if ( !aNode1 ) break; // not a quadratic edge + } + else if ( anElemNode == aNode1 ) + aResult1++; + } + } } } - + int aResult = max ( aResult0, aResult1 ); + +// TColStd_MapOfInteger aMap; + +// SMDS_ElemIteratorPtr anIter = anEdge->nodesIterator(); +// if ( anIter != 0 ) { +// while( anIter->more() ) { +// const SMDS_MeshNode* aNode = (SMDS_MeshNode*)anIter->next(); +// if ( aNode == 0 ) +// return 0; +// SMDS_ElemIteratorPtr anElemIter = aNode->GetInverseElementIterator(); +// while( anElemIter->more() ) { +// const SMDS_MeshElement* anElem = anElemIter->next(); +// if ( anElem != 0 && anElem->GetType() != SMDSAbs_Edge ) { +// int anId = anElem->GetID(); + +// if ( anIter->more() ) // i.e. first node +// aMap.Add( anId ); +// else if ( aMap.Contains( anId ) ) +// aResult++; +// } +// } +// } +// } + return aResult; } @@ -136,7 +178,7 @@ NumericalFunctor::NumericalFunctor(): myPrecision = -1; } -void NumericalFunctor::SetMesh( SMDS_Mesh* theMesh ) +void NumericalFunctor::SetMesh( const SMDS_Mesh* theMesh ) { myMesh = theMesh; } @@ -153,23 +195,41 @@ bool NumericalFunctor::GetPoints(const int theId, } bool NumericalFunctor::GetPoints(const SMDS_MeshElement* anElem, - TSequenceOfXYZ& theRes ) + TSequenceOfXYZ& theRes ) { theRes.clear(); if ( anElem == 0) return false; + theRes.reserve( anElem->NbNodes() ); + // Get nodes of the element - SMDS_ElemIteratorPtr anIter = anElem->nodesIterator(); - if ( anIter != 0 ) - { - while( anIter->more() ) - { - const SMDS_MeshNode* aNode = (SMDS_MeshNode*)anIter->next(); - if ( aNode != 0 ){ + SMDS_ElemIteratorPtr anIter; + + if ( anElem->IsQuadratic() ) { + switch ( anElem->GetType() ) { + case SMDSAbs_Edge: + anIter = static_cast + (anElem)->interlacedNodesElemIterator(); + break; + case SMDSAbs_Face: + anIter = static_cast + (anElem)->interlacedNodesElemIterator(); + break; + default: + anIter = anElem->nodesIterator(); + //return false; + } + } + else { + anIter = anElem->nodesIterator(); + } + + if ( anIter ) { + while( anIter->more() ) { + if ( const SMDS_MeshNode* aNode = static_cast( anIter->next() )) theRes.push_back( gp_XYZ( aNode->X(), aNode->Y(), aNode->Z() ) ); - } } } @@ -188,6 +248,7 @@ void NumericalFunctor::SetPrecision( const long thePrecision ) double NumericalFunctor::GetValue( long theId ) { + myCurrElement = myMesh->FindElement( theId ); TSequenceOfXYZ P; if ( GetPoints( theId, P )) { @@ -203,6 +264,42 @@ double NumericalFunctor::GetValue( long theId ) return 0.; } +//======================================================================= +//function : GetValue +//purpose : +//======================================================================= + +double Volume::GetValue( long theElementId ) +{ + if ( theElementId && myMesh ) { + SMDS_VolumeTool aVolumeTool; + if ( aVolumeTool.Set( myMesh->FindElement( theElementId ))) + return aVolumeTool.GetSize(); + } + return 0; +} + +//======================================================================= +//function : GetBadRate +//purpose : meaningless as it is not quality control functor +//======================================================================= + +double Volume::GetBadRate( double Value, int /*nbNodes*/ ) const +{ + return Value; +} + +//======================================================================= +//function : GetType +//purpose : +//======================================================================= + +SMDSAbs_ElementType Volume::GetType() const +{ + return SMDSAbs_Volume; +} + + /* Class : MinimumAngle Description : Functor for calculation of minimum angle @@ -212,32 +309,24 @@ double MinimumAngle::GetValue( const TSequenceOfXYZ& P ) { double aMin; - if ( P.size() == 3 ) - { - double A0 = getAngle( P( 3 ), P( 1 ), P( 2 ) ); - double A1 = getAngle( P( 1 ), P( 2 ), P( 3 ) ); - double A2 = getAngle( P( 2 ), P( 3 ), P( 1 ) ); + if (P.size() <3) + return 0.; - aMin = Min( A0, Min( A1, A2 ) ); - } - else if ( P.size() == 4 ) - { - double A0 = getAngle( P( 4 ), P( 1 ), P( 2 ) ); - double A1 = getAngle( P( 1 ), P( 2 ), P( 3 ) ); - double A2 = getAngle( P( 2 ), P( 3 ), P( 4 ) ); - double A3 = getAngle( P( 3 ), P( 4 ), P( 1 ) ); - - aMin = Min( Min( A0, A1 ), Min( A2, A3 ) ); + aMin = getAngle(P( P.size() ), P( 1 ), P( 2 )); + aMin = Min(aMin,getAngle(P( P.size()-1 ), P( P.size() ), P( 1 ))); + + for (int i=2; i aLen (nbNodes); + for ( int i = 0; i < nbNodes - 1; i++ ) + aLen[ i ] = getDistance( P( i + 1 ), P( i + 2 ) ); + aLen[ nbNodes - 1 ] = getDistance( P( 1 ), P( nbNodes ) ); + // Q = alfa * h * p / S, where + // + // alfa = sqrt( 3 ) / 6 + // h - length of the longest edge + // p - half perimeter + // S - triangle surface + const double alfa = sqrt( 3. ) / 6.; + double maxLen = Max( aLen[ 0 ], Max( aLen[ 1 ], aLen[ 2 ] ) ); + double half_perimeter = ( aLen[0] + aLen[1] + aLen[2] ) / 2.; double anArea = getArea( P( 1 ), P( 2 ), P( 3 ) ); if ( anArea <= Precision::Confusion() ) return 0.; - double aMaxLen = Max( aLen[ 0 ], Max( aLen[ 1 ], aLen[ 2 ] ) ); - static double aCoef = sqrt( 3. ) / 4; - - return aCoef * aMaxLen * aMaxLen / anArea; - } - else - { - double aMinLen = Min( Min( aLen[ 0 ], aLen[ 1 ] ), Min( aLen[ 2 ], aLen[ 3 ] ) ); - if ( aMinLen <= Precision::Confusion() ) + return alfa * maxLen * half_perimeter / anArea; + } + else if ( nbNodes == 6 ) { // quadratic triangles + // Compute lengths of the sides + vector< double > aLen (3); + aLen[0] = getDistance( P(1), P(3) ); + aLen[1] = getDistance( P(3), P(5) ); + aLen[2] = getDistance( P(5), P(1) ); + // Q = alfa * h * p / S, where + // + // alfa = sqrt( 3 ) / 6 + // h - length of the longest edge + // p - half perimeter + // S - triangle surface + const double alfa = sqrt( 3. ) / 6.; + double maxLen = Max( aLen[ 0 ], Max( aLen[ 1 ], aLen[ 2 ] ) ); + double half_perimeter = ( aLen[0] + aLen[1] + aLen[2] ) / 2.; + double anArea = getArea( P(1), P(3), P(5) ); + if ( anArea <= Precision::Confusion() ) return 0.; - double aMaxLen = Max( Max( aLen[ 0 ], aLen[ 1 ] ), Max( aLen[ 2 ], aLen[ 3 ] ) ); - - return aMaxLen / aMinLen; + return alfa * maxLen * half_perimeter / anArea; + } + else if( nbNodes == 4 ) { // quadrangle + // return aspect ratio of the worst triange which can be built + // taking three nodes of the quadrangle + TSequenceOfXYZ triaPnts(3); + // triangle on nodes 1 3 2 + triaPnts(1) = P(1); + triaPnts(2) = P(3); + triaPnts(3) = P(2); + double ar = GetValue( triaPnts ); + // triangle on nodes 1 3 4 + triaPnts(3) = P(4); + ar = Max ( ar, GetValue( triaPnts )); + // triangle on nodes 1 2 4 + triaPnts(2) = P(2); + ar = Max ( ar, GetValue( triaPnts )); + // triangle on nodes 3 2 4 + triaPnts(1) = P(3); + ar = Max ( ar, GetValue( triaPnts )); + + return ar; + } + else { // nbNodes==8 - quadratic quadrangle + // return aspect ratio of the worst triange which can be built + // taking three nodes of the quadrangle + TSequenceOfXYZ triaPnts(3); + // triangle on nodes 1 3 2 + triaPnts(1) = P(1); + triaPnts(2) = P(5); + triaPnts(3) = P(3); + double ar = GetValue( triaPnts ); + // triangle on nodes 1 3 4 + triaPnts(3) = P(7); + ar = Max ( ar, GetValue( triaPnts )); + // triangle on nodes 1 2 4 + triaPnts(2) = P(3); + ar = Max ( ar, GetValue( triaPnts )); + // triangle on nodes 3 2 4 + triaPnts(1) = P(5); + ar = Max ( ar, GetValue( triaPnts )); + + return ar; } } @@ -344,7 +494,7 @@ namespace{ double Q = b2*f2*(a2+c2+d2+e2-b2-f2); double R = c2*d2*(a2+b2+e2+f2-c2-d2); double S = a2*b2*d2+b2*c2*e2+a2*c2*f2+d2*e2*f2; - + return sqrt(P+Q+R-S)/12.0; } @@ -353,7 +503,7 @@ namespace{ gp_Vec aVec2( P( 3 ) - P( 1 ) ); gp_Vec aVec3( P( 4 ) - P( 1 ) ); gp_Vec anAreaVec( aVec1 ^ aVec2 ); - return abs(aVec3 * anAreaVec) / 6.0; + return fabs(aVec3 * anAreaVec) / 6.0; } inline double getMaxHeight(double theLen[6]) @@ -371,7 +521,18 @@ namespace{ double AspectRatio3D::GetValue( const TSequenceOfXYZ& P ) { double aQuality = 0.0; + if(myCurrElement->IsPoly()) return aQuality; + int nbNodes = P.size(); + + if(myCurrElement->IsQuadratic()) { + if(nbNodes==10) nbNodes=4; // quadratic tetrahedron + else if(nbNodes==13) nbNodes=5; // quadratic pyramid + else if(nbNodes==15) nbNodes=6; // quadratic pentahedron + else if(nbNodes==20) nbNodes=8; // quadratic hexahedron + else return aQuality; + } + switch(nbNodes){ case 4:{ double aLen[6] = { @@ -404,8 +565,9 @@ double AspectRatio3D::GetValue( const TSequenceOfXYZ& P ) double aVolume = getVolume(P); //double aVolume = getVolume(aLen); double aHeight = getMaxHeight(aLen); - static double aCoeff = sqrt(6.0)/36.0; - aQuality = aCoeff*aHeight*aSumArea/aVolume; + static double aCoeff = sqrt(2.0)/12.0; + if ( aVolume > DBL_MIN ) + aQuality = aCoeff*aHeight*aSumArea/aVolume; break; } case 5:{ @@ -590,6 +752,21 @@ double AspectRatio3D::GetValue( const TSequenceOfXYZ& P ) break; } } + if ( nbNodes > 4 ) { + // avaluate aspect ratio of quadranle faces + AspectRatio aspect2D; + SMDS_VolumeTool::VolumeType type = SMDS_VolumeTool::GetType( nbNodes ); + int nbFaces = SMDS_VolumeTool::NbFaces( type ); + TSequenceOfXYZ points(4); + for ( int i = 0; i < nbFaces; ++i ) { // loop on faces of a volume + if ( SMDS_VolumeTool::NbFaceNodes( type, i ) != 4 ) + continue; + const int* pInd = SMDS_VolumeTool::GetFaceNodesIndices( type, i, true ); + for ( int p = 0; p < 4; ++p ) // loop on nodes of a quadranle face + points( p + 1 ) = P( pInd[ p ] + 1 ); + aQuality = max( aQuality, aspect2D.GetValue( points )); + } + } return aQuality; } @@ -616,7 +793,7 @@ double Warping::GetValue( const TSequenceOfXYZ& P ) if ( P.size() != 4 ) return 0; - gp_XYZ G = ( P( 1 ) + P( 2 ) + P( 3 ) + P( 4 ) ) / 4; + gp_XYZ G = ( P( 1 ) + P( 2 ) + P( 3 ) + P( 4 ) ) / 4.; double A1 = ComputeA( P( 1 ), P( 2 ), P( 3 ), G ); double A2 = ComputeA( P( 2 ), P( 3 ), P( 4 ), G ); @@ -637,8 +814,8 @@ double Warping::ComputeA( const gp_XYZ& thePnt1, if ( L < Precision::Confusion()) return 0.; - gp_XYZ GI = ( thePnt2 - thePnt1 ) / 2. - theG; - gp_XYZ GJ = ( thePnt3 - thePnt2 ) / 2. - theG; + gp_XYZ GI = ( thePnt2 + thePnt1 ) / 2. - theG; + gp_XYZ GJ = ( thePnt3 + thePnt2 ) / 2. - theG; gp_XYZ N = GI.Crossed( GJ ); if ( N.Modulus() < gp::Resolution() ) @@ -647,7 +824,7 @@ double Warping::ComputeA( const gp_XYZ& thePnt1, N.Normalize(); double H = ( thePnt2 - theG ).Dot( N ); - return asin( fabs( H / L ) ) * 180 / PI; + return asin( fabs( H / L ) ) * 180. / PI; } double Warping::GetBadRate( double Value, int /*nbNodes*/ ) const @@ -671,13 +848,13 @@ SMDSAbs_ElementType Warping::GetType() const double Taper::GetValue( const TSequenceOfXYZ& P ) { if ( P.size() != 4 ) - return 0; + return 0.; // Compute taper - double J1 = getArea( P( 4 ), P( 1 ), P( 2 ) ) / 2; - double J2 = getArea( P( 3 ), P( 1 ), P( 2 ) ) / 2; - double J3 = getArea( P( 2 ), P( 3 ), P( 4 ) ) / 2; - double J4 = getArea( P( 3 ), P( 4 ), P( 1 ) ) / 2; + double J1 = getArea( P( 4 ), P( 1 ), P( 2 ) ) / 2.; + double J2 = getArea( P( 3 ), P( 1 ), P( 2 ) ) / 2.; + double J3 = getArea( P( 2 ), P( 3 ), P( 4 ) ) / 2.; + double J4 = getArea( P( 3 ), P( 4 ), P( 1 ) ) / 2.; double JA = 0.25 * ( J1 + J2 + J3 + J4 ); if ( JA <= Precision::Confusion() ) @@ -711,42 +888,46 @@ SMDSAbs_ElementType Taper::GetType() const */ static inline double skewAngle( const gp_XYZ& p1, const gp_XYZ& p2, const gp_XYZ& p3 ) { - gp_XYZ p12 = ( p2 + p1 ) / 2; - gp_XYZ p23 = ( p3 + p2 ) / 2; - gp_XYZ p31 = ( p3 + p1 ) / 2; + gp_XYZ p12 = ( p2 + p1 ) / 2.; + gp_XYZ p23 = ( p3 + p2 ) / 2.; + gp_XYZ p31 = ( p3 + p1 ) / 2.; gp_Vec v1( p31 - p2 ), v2( p12 - p23 ); - return v1.Magnitude() < gp::Resolution() || v2.Magnitude() < gp::Resolution() ? 0 : v1.Angle( v2 ); + return v1.Magnitude() < gp::Resolution() || v2.Magnitude() < gp::Resolution() ? 0. : v1.Angle( v2 ); } double Skew::GetValue( const TSequenceOfXYZ& P ) { if ( P.size() != 3 && P.size() != 4 ) - return 0; + return 0.; // Compute skew - static double PI2 = PI / 2; + static double PI2 = PI / 2.; if ( P.size() == 3 ) { double A0 = fabs( PI2 - skewAngle( P( 3 ), P( 1 ), P( 2 ) ) ); double A1 = fabs( PI2 - skewAngle( P( 1 ), P( 2 ), P( 3 ) ) ); double A2 = fabs( PI2 - skewAngle( P( 2 ), P( 3 ), P( 1 ) ) ); - return Max( A0, Max( A1, A2 ) ) * 180 / PI; + return Max( A0, Max( A1, A2 ) ) * 180. / PI; } - else + else { - gp_XYZ p12 = ( P( 1 ) + P( 2 ) ) / 2; - gp_XYZ p23 = ( P( 2 ) + P( 3 ) ) / 2; - gp_XYZ p34 = ( P( 3 ) + P( 4 ) ) / 2; - gp_XYZ p41 = ( P( 4 ) + P( 1 ) ) / 2; + gp_XYZ p12 = ( P( 1 ) + P( 2 ) ) / 2.; + gp_XYZ p23 = ( P( 2 ) + P( 3 ) ) / 2.; + gp_XYZ p34 = ( P( 3 ) + P( 4 ) ) / 2.; + gp_XYZ p41 = ( P( 4 ) + P( 1 ) ) / 2.; gp_Vec v1( p34 - p12 ), v2( p23 - p41 ); double A = v1.Magnitude() <= gp::Resolution() || v2.Magnitude() <= gp::Resolution() - ? 0 : fabs( PI2 - v1.Angle( v2 ) ); + ? 0. : fabs( PI2 - v1.Angle( v2 ) ); + + //BUG SWP12743 + if ( A < Precision::Angular() ) + return 0.; - return A * 180 / PI; + return A * 180. / PI; } } @@ -770,16 +951,21 @@ SMDSAbs_ElementType Skew::GetType() const */ double Area::GetValue( const TSequenceOfXYZ& P ) { - if ( P.size() == 3 ) - return getArea( P( 1 ), P( 2 ), P( 3 ) ); - else if ( P.size() == 4 ) - return getArea( P( 1 ), P( 2 ), P( 3 ) ) + getArea( P( 1 ), P( 3 ), P( 4 ) ); - else - return 0; + gp_Vec aVec1( P(2) - P(1) ); + gp_Vec aVec2( P(3) - P(1) ); + gp_Vec SumVec = aVec1 ^ aVec2; + for (int i=4; i<=P.size(); i++) { + gp_Vec aVec1( P(i-1) - P(1) ); + gp_Vec aVec2( P(i) - P(1) ); + gp_Vec tmp = aVec1 ^ aVec2; + SumVec.Add(tmp); + } + return SumVec.Magnitude() * 0.5; } double Area::GetBadRate( double Value, int /*nbNodes*/ ) const { + // meaningless as it is not a quality control functor return Value; } @@ -795,11 +981,16 @@ SMDSAbs_ElementType Area::GetType() const */ double Length::GetValue( const TSequenceOfXYZ& P ) { - return ( P.size() == 2 ? getDistance( P( 1 ), P( 2 ) ) : 0 ); + switch ( P.size() ) { + case 2: return getDistance( P( 1 ), P( 2 ) ); + case 3: return getDistance( P( 1 ), P( 2 ) ) + getDistance( P( 2 ), P( 3 ) ); + default: return 0.; + } } double Length::GetBadRate( double Value, int /*nbNodes*/ ) const { + // meaningless as it is not quality control functor return Value; } @@ -817,21 +1008,28 @@ double Length2D::GetValue( long theElementId) { TSequenceOfXYZ P; + //cout<<"Length2D::GetValue"<FindElement( theElementId ); SMDSAbs_ElementType aType = aElem->GetType(); - + int len = P.size(); - + switch (aType){ case SMDSAbs_All: - case SMDSAbs_Node: + case SMDSAbs_Node: case SMDSAbs_Edge: if (len == 2){ aVal = getDistance( P( 1 ), P( 2 ) ); - break; + break; + } + else if (len == 3){ // quadratic edge + aVal = getDistance(P( 1 ),P( 3 )) + getDistance(P( 3 ),P( 2 )); + break; } case SMDSAbs_Face: if (len == 3){ // triangles @@ -849,6 +1047,22 @@ double Length2D::GetValue( long theElementId) aVal = Max(Max(L1,L2),Max(L3,L4)); break; } + if (len == 6){ // quadratic triangles + double L1 = getDistance(P( 1 ),P( 2 )) + getDistance(P( 2 ),P( 3 )); + double L2 = getDistance(P( 3 ),P( 4 )) + getDistance(P( 4 ),P( 5 )); + double L3 = getDistance(P( 5 ),P( 6 )) + getDistance(P( 6 ),P( 1 )); + aVal = Max(L1,Max(L2,L3)); + //cout<<"L1="<GetType() && myType != SMDSAbs_All ) return false; } - + if ( myIds.Contains( theId ) ) return true; @@ -1549,7 +1909,7 @@ Comparator::Comparator(): Comparator::~Comparator() {} -void Comparator::SetMesh( SMDS_Mesh* theMesh ) +void Comparator::SetMesh( const SMDS_Mesh* theMesh ) { if ( myFunctor ) myFunctor->SetMesh( theMesh ); @@ -1634,7 +1994,7 @@ bool LogicalNOT::IsSatisfy( long theId ) return myPredicate && !myPredicate->IsSatisfy( theId ); } -void LogicalNOT::SetMesh( SMDS_Mesh* theMesh ) +void LogicalNOT::SetMesh( const SMDS_Mesh* theMesh ) { if ( myPredicate ) myPredicate->SetMesh( theMesh ); @@ -1661,7 +2021,7 @@ LogicalBinary::LogicalBinary() LogicalBinary::~LogicalBinary() {} -void LogicalBinary::SetMesh( SMDS_Mesh* theMesh ) +void LogicalBinary::SetMesh( const SMDS_Mesh* theMesh ) { if ( myPredicate1 ) myPredicate1->SetMesh( theMesh ); @@ -1698,10 +2058,10 @@ SMDSAbs_ElementType LogicalBinary::GetType() const */ bool LogicalAND::IsSatisfy( long theId ) { - return - myPredicate1 && - myPredicate2 && - myPredicate1->IsSatisfy( theId ) && + return + myPredicate1 && + myPredicate2 && + myPredicate1->IsSatisfy( theId ) && myPredicate2->IsSatisfy( theId ); } @@ -1712,10 +2072,10 @@ bool LogicalAND::IsSatisfy( long theId ) */ bool LogicalOR::IsSatisfy( long theId ) { - return - myPredicate1 && - myPredicate2 && - myPredicate1->IsSatisfy( theId ) || + return + myPredicate1 && + myPredicate2 && + myPredicate1->IsSatisfy( theId ) || myPredicate2->IsSatisfy( theId ); } @@ -1735,11 +2095,10 @@ void Filter::SetPredicate( PredicatePtr thePredicate ) myPredicate = thePredicate; } - -template -void FillSequence(const TIterator& theIterator, - TPredicate& thePredicate, - Filter::TIdSequence& theSequence) +template +inline void FillSequence(const TIterator& theIterator, + TPredicate& thePredicate, + Filter::TIdSequence& theSequence) { if ( theIterator ) { while( theIterator->more() ) { @@ -1751,40 +2110,46 @@ void FillSequence(const TIterator& theIterator, } } -Filter::TIdSequence -Filter::GetElementsId( SMDS_Mesh* theMesh ) +void +Filter:: +GetElementsId( const SMDS_Mesh* theMesh, + PredicatePtr thePredicate, + TIdSequence& theSequence ) { - TIdSequence aSequence; - if ( !theMesh || !myPredicate ) return aSequence; + theSequence.clear(); + + if ( !theMesh || !thePredicate ) + return; - myPredicate->SetMesh( theMesh ); + thePredicate->SetMesh( theMesh ); - SMDSAbs_ElementType aType = myPredicate->GetType(); + SMDSAbs_ElementType aType = thePredicate->GetType(); switch(aType){ - case SMDSAbs_Node:{ - FillSequence(theMesh->nodesIterator(),myPredicate,aSequence); + case SMDSAbs_Node: + FillSequence(theMesh->nodesIterator(),thePredicate,theSequence); break; - } - case SMDSAbs_Edge:{ - FillSequence(theMesh->edgesIterator(),myPredicate,aSequence); + case SMDSAbs_Edge: + FillSequence(theMesh->edgesIterator(),thePredicate,theSequence); break; - } - case SMDSAbs_Face:{ - FillSequence(theMesh->facesIterator(),myPredicate,aSequence); + case SMDSAbs_Face: + FillSequence(theMesh->facesIterator(),thePredicate,theSequence); break; - } - case SMDSAbs_Volume:{ - FillSequence(theMesh->volumesIterator(),myPredicate,aSequence); + case SMDSAbs_Volume: + FillSequence(theMesh->volumesIterator(),thePredicate,theSequence); break; - } - case SMDSAbs_All:{ - FillSequence(theMesh->edgesIterator(),myPredicate,aSequence); - FillSequence(theMesh->facesIterator(),myPredicate,aSequence); - FillSequence(theMesh->volumesIterator(),myPredicate,aSequence); + case SMDSAbs_All: + FillSequence(theMesh->edgesIterator(),thePredicate,theSequence); + FillSequence(theMesh->facesIterator(),thePredicate,theSequence); + FillSequence(theMesh->volumesIterator(),thePredicate,theSequence); break; } - } - return aSequence; +} + +void +Filter::GetElementsId( const SMDS_Mesh* theMesh, + Filter::TIdSequence& theSequence ) +{ + GetElementsId(theMesh,myPredicate,theSequence); } /* @@ -1793,9 +2158,9 @@ Filter::GetElementsId( SMDS_Mesh* theMesh ) typedef std::set TMapOfFacePtr; -/* +/* Internal class Link -*/ +*/ ManifoldPart::Link::Link( SMDS_MeshNode* theNode1, SMDS_MeshNode* theNode2 ) @@ -1832,7 +2197,7 @@ bool ManifoldPart::Link::operator<( const ManifoldPart::Link& x ) const bool ManifoldPart::IsEqual( const ManifoldPart::Link& theLink1, const ManifoldPart::Link& theLink2 ) -{ +{ return theLink1.IsEqual( theLink2 ); } @@ -1848,7 +2213,7 @@ ManifoldPart::~ManifoldPart() myMesh = 0; } -void ManifoldPart::SetMesh( SMDS_Mesh* theMesh ) +void ManifoldPart::SetMesh( const SMDS_Mesh* theMesh ) { myMesh = theMesh; process(); @@ -1878,7 +2243,7 @@ bool ManifoldPart::process() { myMapIds.Clear(); myMapBadGeomIds.Clear(); - + myAllFacePtr.clear(); myAllFacePtrIntDMap.clear(); if ( !myMesh ) @@ -1910,7 +2275,7 @@ bool ManifoldPart::process() if ( fi == aStartIndx ) isStartTreat = true; // as result next time when fi will be equal to aStartIndx - + SMDS_MeshFace* aFacePtr = myAllFacePtr[ fi ]; if ( aMapOfTreated.Contains( aFacePtr->GetID() ) ) continue; @@ -1943,7 +2308,7 @@ static void getLinks( const SMDS_MeshFace* theFace, SMDS_MeshNode* aNode = 0; for ( ; aNodeItr->more() && i <= aNbNode; ) { - + SMDS_MeshNode* aN1 = (SMDS_MeshNode*)aNodeItr->next(); if ( i == 1 ) aNode = aN1; @@ -1962,17 +2327,15 @@ static gp_XYZ getNormale( const SMDS_MeshFace* theFace ) TColgp_Array1OfXYZ anArrOfXYZ(1,4); SMDS_ElemIteratorPtr aNodeItr = theFace->nodesIterator(); int i = 1; - for ( ; aNodeItr->more() && i <= 4; i++ ) - { + for ( ; aNodeItr->more() && i <= 4; i++ ) { SMDS_MeshNode* aNode = (SMDS_MeshNode*)aNodeItr->next(); anArrOfXYZ.SetValue(i, gp_XYZ( aNode->X(), aNode->Y(), aNode->Z() ) ); } - + gp_XYZ q1 = anArrOfXYZ.Value(2) - anArrOfXYZ.Value(1); gp_XYZ q2 = anArrOfXYZ.Value(3) - anArrOfXYZ.Value(1); n = q1 ^ q2; - if ( aNbNode > 3 ) - { + if ( aNbNode > 3 ) { gp_XYZ q3 = anArrOfXYZ.Value(4) - anArrOfXYZ.Value(1); n += q2 ^ q3; } @@ -1992,7 +2355,7 @@ bool ManifoldPart::findConnected theResFaces.Clear(); if ( !theAllFacePtrInt.size() ) return false; - + if ( getNormale( theStartFace ).SquareModulus() <= gp::Resolution() ) { myMapBadGeomIds.Add( theStartFace->GetID() ); @@ -2004,7 +2367,7 @@ bool ManifoldPart::findConnected theResFaces.Add( theStartFace->GetID() ); ManifoldPart::TDataMapOfLinkFacePtr aDMapLinkFace; - expandBoundary( aMapOfBoundary, aSeqOfBoundary, + expandBoundary( aMapOfBoundary, aSeqOfBoundary, aDMapLinkFace, theNonManifold, theStartFace ); bool isDone = false; @@ -2022,7 +2385,7 @@ bool ManifoldPart::findConnected ManifoldPart::TVectorOfFacePtr aFaces; // find next - if ( myIsOnlyManifold && + if ( myIsOnlyManifold && (theNonManifold.find( aLink ) != theNonManifold.end()) ) continue; else @@ -2046,7 +2409,7 @@ bool ManifoldPart::findConnected continue; } } - + // compare normal with normals of neighbor element SMDS_MeshFace* aPrevFace = aDMapLinkFace[ aLink ]; ManifoldPart::TVectorOfFacePtr::iterator pFace = aFaces.begin(); @@ -2065,7 +2428,7 @@ bool ManifoldPart::findConnected continue; // add new element to connected and extend the boundaries. theResFaces.Add( anNextFaceID ); - expandBoundary( aMapOfBoundary, aSeqOfBoundary, + expandBoundary( aMapOfBoundary, aSeqOfBoundary, aDMapLinkFace, theNonManifold, aNextFace ); isToReset = true; } @@ -2101,7 +2464,7 @@ void ManifoldPart::expandBoundary { ManifoldPart::TVectorOfLink aLinks; getLinks( theNextFace, aLinks ); - int aNbLink = aLinks.size(); + int aNbLink = (int)aLinks.size(); for ( int i = 0; i < aNbLink; i++ ) { ManifoldPart::Link aLink = aLinks[ i ]; @@ -2170,6 +2533,7 @@ ElementsOnSurface::ElementsOnSurface() myType = SMDSAbs_All; mySurf.Nullify(); myToler = Precision::Confusion(); + myUseBoundaries = false; } ElementsOnSurface::~ElementsOnSurface() @@ -2177,12 +2541,11 @@ ElementsOnSurface::~ElementsOnSurface() myMesh = 0; } -void ElementsOnSurface::SetMesh( SMDS_Mesh* theMesh ) -{ +void ElementsOnSurface::SetMesh( const SMDS_Mesh* theMesh ) +{ if ( myMesh == theMesh ) return; myMesh = theMesh; - myIds.Clear(); process(); } @@ -2195,25 +2558,41 @@ SMDSAbs_ElementType ElementsOnSurface::GetType() const { return myType; } void ElementsOnSurface::SetTolerance( const double theToler ) -{ myToler = theToler; } +{ + if ( myToler != theToler ) + myIds.Clear(); + myToler = theToler; +} double ElementsOnSurface::GetTolerance() const +{ return myToler; } + +void ElementsOnSurface::SetUseBoundaries( bool theUse ) { - return myToler; + if ( myUseBoundaries != theUse ) { + myUseBoundaries = theUse; + SetSurface( mySurf, myType ); + } } void ElementsOnSurface::SetSurface( const TopoDS_Shape& theShape, const SMDSAbs_ElementType theType ) { + myIds.Clear(); myType = theType; mySurf.Nullify(); if ( theShape.IsNull() || theShape.ShapeType() != TopAbs_FACE ) - { - mySurf.Nullify(); return; - } - TopoDS_Face aFace = TopoDS::Face( theShape ); - mySurf = BRep_Tool::Surface( aFace ); + mySurf = TopoDS::Face( theShape ); + BRepAdaptor_Surface SA( mySurf, myUseBoundaries ); + Standard_Real + u1 = SA.FirstUParameter(), + u2 = SA.LastUParameter(), + v1 = SA.FirstVParameter(), + v2 = SA.LastVParameter(); + Handle(Geom_Surface) surf = BRep_Tool::Surface( mySurf ); + myProjector.Init( surf, u1,u2, v1,v2 ); + process(); } void ElementsOnSurface::process() @@ -2227,6 +2606,7 @@ void ElementsOnSurface::process() if ( myType == SMDSAbs_Face || myType == SMDSAbs_All ) { + myIds.ReSize( myMesh->NbFaces() ); SMDS_FaceIteratorPtr anIter = myMesh->facesIterator(); for(; anIter->more(); ) process( anIter->next() ); @@ -2234,6 +2614,7 @@ void ElementsOnSurface::process() if ( myType == SMDSAbs_Edge || myType == SMDSAbs_All ) { + myIds.ReSize( myMesh->NbEdges() ); SMDS_EdgeIteratorPtr anIter = myMesh->edgesIterator(); for(; anIter->more(); ) process( anIter->next() ); @@ -2241,6 +2622,7 @@ void ElementsOnSurface::process() if ( myType == SMDSAbs_Node ) { + myIds.ReSize( myMesh->NbNodes() ); SMDS_NodeIteratorPtr anIter = myMesh->nodesIterator(); for(; anIter->more(); ) process( anIter->next() ); @@ -2264,32 +2646,34 @@ void ElementsOnSurface::process( const SMDS_MeshElement* theElemPtr ) myIds.Add( theElemPtr->GetID() ); } -bool ElementsOnSurface::isOnSurface( const SMDS_MeshNode* theNode ) const +bool ElementsOnSurface::isOnSurface( const SMDS_MeshNode* theNode ) { if ( mySurf.IsNull() ) return false; gp_Pnt aPnt( theNode->X(), theNode->Y(), theNode->Z() ); - double aToler2 = myToler * myToler; - if ( mySurf->IsKind(STANDARD_TYPE(Geom_Plane))) - { - gp_Pln aPln = Handle(Geom_Plane)::DownCast(mySurf)->Pln(); - if ( aPln.SquareDistance( aPnt ) > aToler2 ) - return false; - } - else if ( mySurf->IsKind(STANDARD_TYPE(Geom_CylindricalSurface))) - { - gp_Cylinder aCyl = Handle(Geom_CylindricalSurface)::DownCast(mySurf)->Cylinder(); - double aRad = aCyl.Radius(); - gp_Ax3 anAxis = aCyl.Position(); - gp_XYZ aLoc = aCyl.Location().XYZ(); - double aXDist = anAxis.XDirection().XYZ() * ( aPnt.XYZ() - aLoc ); - double aYDist = anAxis.YDirection().XYZ() * ( aPnt.XYZ() - aLoc ); - if ( fabs(aXDist*aXDist + aYDist*aYDist - aRad*aRad) > aToler2 ) - return false; - } - else - return false; - - return true; + // double aToler2 = myToler * myToler; +// if ( mySurf->IsKind(STANDARD_TYPE(Geom_Plane))) +// { +// gp_Pln aPln = Handle(Geom_Plane)::DownCast(mySurf)->Pln(); +// if ( aPln.SquareDistance( aPnt ) > aToler2 ) +// return false; +// } +// else if ( mySurf->IsKind(STANDARD_TYPE(Geom_CylindricalSurface))) +// { +// gp_Cylinder aCyl = Handle(Geom_CylindricalSurface)::DownCast(mySurf)->Cylinder(); +// double aRad = aCyl.Radius(); +// gp_Ax3 anAxis = aCyl.Position(); +// gp_XYZ aLoc = aCyl.Location().XYZ(); +// double aXDist = anAxis.XDirection().XYZ() * ( aPnt.XYZ() - aLoc ); +// double aYDist = anAxis.YDirection().XYZ() * ( aPnt.XYZ() - aLoc ); +// if ( fabs(aXDist*aXDist + aYDist*aYDist - aRad*aRad) > aToler2 ) +// return false; +// } +// else +// return false; + myProjector.Perform( aPnt ); + bool isOn = ( myProjector.IsDone() && myProjector.LowerDistance() <= myToler ); + + return isOn; }