-// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2023 CEA, EDF, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
#include <GEOMUtils.hxx>
-#include <Basics_OCCTVersion.hxx>
-
-#include <utilities.h>
-#include <OpUtil.hxx>
#include <Utils_ExceptHandlers.hxx>
+#include <Basics_OCCTVersion.hxx>
+
// OCCT Includes
#include <BRepMesh_IncrementalMesh.hxx>
#include <BRepGProp.hxx>
#include <BRepTools.hxx>
+#include <BRepClass_FaceClassifier.hxx>
#include <BRepClass3d_SolidClassifier.hxx>
#include <BRepBuilderAPI_MakeFace.hxx>
#include <BRepBuilderAPI_Sewing.hxx>
+#include <BRepCheck_Analyzer.hxx>
+
#include <Bnd_Box.hxx>
+#include <BOPAlgo_ArgumentAnalyzer.hxx>
+#include <BOPTools_AlgoTools.hxx>
+
#include <TopAbs.hxx>
#include <TopExp.hxx>
#include <TopoDS.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_Array1OfShape.hxx>
+#include <GeomAPI_ProjectPointOnSurf.hxx>
+
#include <Geom_Circle.hxx>
#include <Geom_Surface.hxx>
#include <Geom_Plane.hxx>
#include <gp_Pln.hxx>
#include <gp_Lin.hxx>
-#include <ShapeAnalysis.hxx>
#include <ShapeFix_Shape.hxx>
+#include <ShapeFix_ShapeTolerance.hxx>
#include <ProjLib.hxx>
#include <ElSLib.hxx>
#include <vector>
#include <sstream>
+#include <algorithm>
#include <Standard_Failure.hxx>
#include <Standard_NullObject.hxx>
#include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
+#define MAX2(X, Y) (Abs(X) > Abs(Y) ? Abs(X) : Abs(Y))
+#define MAX3(X, Y, Z) (MAX2(MAX2(X,Y), Z))
+
#define STD_SORT_ALGO 1
+#define DEFAULT_TOLERANCE_TOLERANCE 1.e-02
+#define DEFAULT_MAX_TOLERANCE_TOLERANCE 1.e-06
+
+// When the following macro is defined, ShapeFix_ShapeTolerance function is used to set max tolerance of curve
+// in GEOMUtils::FixShapeCurves function; otherwise less restrictive BRep_Builder::UpdateEdge/UpdateVertex
+// approach is used
+// VSR (29/12/2014): macro disabled
+//#define USE_LIMIT_TOLERANCE
+
namespace
{
/**
// non solid case or any periodic surface (Mantis 22454).
double U1,U2,V1,V2;
- // changes for 0020677: EDF 1219 GEOM: MinDistance gives 0 instead of 20.88
- //S->Bounds(U1,U2,V1,V2); changed by
- ShapeAnalysis::GetFaceUVBounds(TopoDS::Face(theModifiedShape),U1,U2,V1,V2);
+ BRepTools::UVBounds(TopoDS::Face(theModifiedShape),U1,U2,V1,V2);
// end of changes for 020677 (dmv)
Handle(Geom_RectangularTrimmedSurface) TrS1 =
new Geom_RectangularTrimmedSurface(S,U1,(U1+U2)/2.,V1,V2);
return Standard_False;
}
- //=======================================================================
- //function : ShapeToDouble
- //purpose : used by CompareShapes::operator()
- //=======================================================================
- std::pair<double, double> ShapeToDouble (const TopoDS_Shape& S, bool isOldSorting)
- {
- // Computing of CentreOfMass
- gp_Pnt GPoint;
- double Len;
-
- if (S.ShapeType() == TopAbs_VERTEX) {
- GPoint = BRep_Tool::Pnt(TopoDS::Vertex(S));
- Len = (double)S.Orientation();
- }
- else {
- GProp_GProps GPr;
- // BEGIN: fix for Mantis issue 0020842
- if (isOldSorting) {
- BRepGProp::LinearProperties(S, GPr);
- }
- else {
- if (S.ShapeType() == TopAbs_EDGE || S.ShapeType() == TopAbs_WIRE) {
- BRepGProp::LinearProperties(S, GPr);
- }
- else if (S.ShapeType() == TopAbs_FACE || S.ShapeType() == TopAbs_SHELL) {
- BRepGProp::SurfaceProperties(S, GPr);
- }
- else {
- BRepGProp::VolumeProperties(S, GPr);
- }
- }
- // END: fix for Mantis issue 0020842
- GPoint = GPr.CentreOfMass();
- Len = GPr.Mass();
- }
-
- double dMidXYZ = GPoint.X() * 999.0 + GPoint.Y() * 99.0 + GPoint.Z() * 0.9;
- return std::make_pair(dMidXYZ, Len);
- }
-
void parseWard( const GEOMUtils::LevelsList &theLevelList, std::string &treeStr )
{
treeStr.append( "{" );
levelsListStr.push_back( substr );
}
GEOMUtils::LevelsList levelsListData;
- for( int level = 0; level < levelsListStr.size(); level++ ) {
+ for( size_t level = 0; level < levelsListStr.size(); level++ ) {
std::vector<std::string> namesListStr;
std::stringstream ss1( levelsListStr[level] );
while ( std::getline( ss1, substr, ',' ) ) {
namesListStr.push_back( substr );
}
GEOMUtils::LevelInfo levelInfoData;
- for( int node = 0; node < namesListStr.size(); node++ ) {
+ for( size_t node = 0; node < namesListStr.size(); node++ ) {
std::vector<std::string> linksListStr;
std::stringstream ss2( namesListStr[node] );
while ( std::getline( ss2, substr, '_' ) ) {
std::string nodeItem = linksListStr[0];
if( !nodeItem.empty() ) {
GEOMUtils::NodeLinks linksListData;
- for( int link = 1; link < linksListStr.size(); link++ ) {
+ for( size_t link = 1; link < linksListStr.size(); link++ ) {
std::string linkItem = linksListStr[link];
linksListData.push_back( linkItem );
}// Links
}
+//=======================================================================
+//function : ShapeToDouble
+//purpose : used by CompareShapes::operator()
+//=======================================================================
+std::pair<double, double> GEOMUtils::ShapeToDouble (const TopoDS_Shape& S, bool isOldSorting)
+{
+ // Computing of CentreOfMass
+ gp_Pnt GPoint;
+ double Len;
+
+ if (S.ShapeType() == TopAbs_VERTEX) {
+ GPoint = BRep_Tool::Pnt(TopoDS::Vertex(S));
+ Len = (double)S.Orientation();
+ }
+ else {
+ GProp_GProps GPr;
+ // BEGIN: fix for Mantis issue 0020842
+ if (isOldSorting) {
+ BRepGProp::LinearProperties(S, GPr);
+ }
+ else {
+ if (S.ShapeType() == TopAbs_EDGE || S.ShapeType() == TopAbs_WIRE) {
+ BRepGProp::LinearProperties(S, GPr);
+ }
+ else if (S.ShapeType() == TopAbs_FACE || S.ShapeType() == TopAbs_SHELL) {
+ BRepGProp::SurfaceProperties(S, GPr);
+ }
+ else {
+ BRepGProp::VolumeProperties(S, GPr);
+ }
+ }
+ // END: fix for Mantis issue 0020842
+ GPoint = GPr.CentreOfMass();
+ Len = GPr.Mass();
+ }
+
+ double dMidXYZ = GPoint.X() * 999.0 + GPoint.Y() * 99.0 + GPoint.Z() * 0.9;
+ return std::make_pair(dMidXYZ, Len);
+}
+
//=======================================================================
//function : GetPosition
//purpose :
// skl 30.06.2008
// additional workaround for bugs 19899, 19908 and 19910 from Mantis
- double dist = GEOMUtils::GetMinDistanceSingular
- (theShape1, theShape2, thePnt1, thePnt2);
+#if OCC_VERSION_LARGE < 0x07070000
+ aResult = GEOMUtils::GetMinDistanceSingular(theShape1, theShape2, thePnt1, thePnt2);
+#endif
+ /*
if (dist > -1.0) {
return dist;
}
+ */
BRepExtrema_DistShapeShape dst (theShape1, theShape2);
if (dst.IsDone()) {
P2 = dst.PointOnShape2(i);
Standard_Real Dist = P1.Distance(P2);
- if (aResult > Dist) {
+ if (aResult < 0 || aResult > Dist) {
aResult = Dist;
thePnt1 = P1;
thePnt2 = P2;
return aResult;
}
+//=======================================================================
+// function : ProjectPointOnFace()
+// purpose : Returns the projection (3d point) if found, throws an exception otherwise
+//=======================================================================
+gp_Pnt GEOMUtils::ProjectPointOnFace(const gp_Pnt& thePoint,
+ const TopoDS_Shape& theFace,
+ double& theU, double& theV,
+ const double theTol)
+{
+ if (theFace.IsNull() || theFace.ShapeType() != TopAbs_FACE)
+ Standard_TypeMismatch::Raise
+ ("Projection aborted : the target shape is not a face");
+
+ TopoDS_Face aFace = TopoDS::Face(theFace);
+ Handle(Geom_Surface) surface = BRep_Tool::Surface(aFace);
+ double U1, U2, V1, V2;
+ BRepTools::UVBounds(aFace, U1, U2, V1, V2);
+
+ // projector
+ GeomAPI_ProjectPointOnSurf proj;
+ proj.Init(surface, U1, U2, V1, V2);
+ proj.Perform(thePoint);
+ if (!proj.IsDone())
+ StdFail_NotDone::Raise("Projection aborted : the algorithm failed");
+ int nbPoints = proj.NbPoints();
+ if (nbPoints < 1)
+ Standard_ConstructionError::Raise("Projection aborted : No solution found");
+ proj.LowerDistanceParameters(theU, theV);
+ gp_Pnt2d aProjPnt (theU, theV);
+
+ // classifier
+ Standard_Real tol = Max(theTol, 1.e-4);
+ BRepClass_FaceClassifier aClsf (aFace, aProjPnt, tol);
+ if (aClsf.State() != TopAbs_IN && aClsf.State() != TopAbs_ON) {
+ bool isSol = false;
+ double minDist = RealLast();
+ for (int i = 1; i <= nbPoints; i++) {
+ Standard_Real Ui, Vi;
+ proj.Parameters(i, Ui, Vi);
+ aProjPnt = gp_Pnt2d(Ui, Vi);
+ aClsf.Perform(aFace, aProjPnt, tol);
+ if (aClsf.State() == TopAbs_IN || aClsf.State() == TopAbs_ON) {
+ isSol = true;
+ double dist = proj.Distance(i);
+ if (dist < minDist) {
+ minDist = dist;
+ theU = Ui;
+ theV = Vi;
+ }
+ }
+ }
+ if (!isSol) {
+ Standard_ConstructionError::Raise("Projection aborted : No solution found");
+ }
+ }
+
+ gp_Pnt surfPnt = surface->Value(theU, theV);
+ return surfPnt;
+}
+
//=======================================================================
// function : ConvertClickToPoint()
// purpose : Returns the point clicked in 3D view
//=======================================================================
gp_Pnt GEOMUtils::ConvertClickToPoint( int x, int y, Handle(V3d_View) aView )
{
- V3d_Coordinate XEye, YEye, ZEye, XAt, YAt, ZAt;
- aView->Eye( XEye, YEye, ZEye );
-
- aView->At( XAt, YAt, ZAt );
- gp_Pnt EyePoint( XEye, YEye, ZEye );
- gp_Pnt AtPoint( XAt, YAt, ZAt );
+ // We can't rely on Eye and At points to get EyeDir, because they collapse
+ // for views with flat bounding boxes. For example if you create a circle and
+ // switch to the top view, then both camera's Eye and At points will fall to zero
+ // inside V3d_View::FitMinMax() method. It's by occt design.
+ // So, we should use camera direction instead.
- gp_Vec EyeVector( EyePoint, AtPoint );
- gp_Dir EyeDir( EyeVector );
+ Standard_Real XAt, YAt, ZAt;
+ aView->At(XAt, YAt, ZAt);
+ gp_Pnt AtPoint(XAt, YAt, ZAt);
- gp_Pln PlaneOfTheView = gp_Pln( AtPoint, EyeDir );
+ gp_Pln PlaneOfTheView = gp_Pln( AtPoint, aView->Camera()->Direction() );
Standard_Real X, Y, Z;
aView->Convert( x, y, X, Y, Z );
gp_Pnt ConvertedPoint( X, Y, Z );
// function : ConvertTreeToString()
// purpose : Returns the string representation of dependency tree
//=======================================================================
-void GEOMUtils::ConvertTreeToString( const TreeModel &tree,
- std::string &treeStr )
+void GEOMUtils::ConvertTreeToString( const TreeModel& tree,
+ std::string& dependencyStr )
{
TreeModel::const_iterator i;
for ( i = tree.begin(); i != tree.end(); ++i ) {
- treeStr.append( i->first );
- treeStr.append( "-" );
+ dependencyStr.append( i->first );
+ dependencyStr.append( "-" );
std::vector<LevelInfo> upLevelList = i->second.first;
- treeStr.append( "upward" );
- parseWard( upLevelList, treeStr );
+ dependencyStr.append( "upward" );
+ parseWard( upLevelList, dependencyStr );
std::vector<LevelInfo> downLevelList = i->second.second;
- treeStr.append( "downward" );
- parseWard( downLevelList, treeStr );
+ dependencyStr.append( "downward" );
+ parseWard( downLevelList, dependencyStr );
}
}
// function : ConvertStringToTree()
// purpose : Returns the dependency tree
//=======================================================================
-void GEOMUtils::ConvertStringToTree( const std::string &theData,
- TreeModel &tree )
+void GEOMUtils::ConvertStringToTree( const std::string& dependencyStr,
+ TreeModel& tree )
{
std::size_t cursor = 0;
- while( theData.find('-',cursor) != std::string::npos ) //find next selected object
+ while( dependencyStr.find('-',cursor) != std::string::npos ) //find next selected object
{
- std::size_t objectIndex = theData.find( '-', cursor );
- std::string objectEntry = theData.substr( cursor, objectIndex - cursor );
+ std::size_t objectIndex = dependencyStr.find( '-', cursor );
+ std::string objectEntry = dependencyStr.substr( cursor, objectIndex - cursor );
cursor = objectIndex;
- std::size_t upwardIndexBegin = theData.find("{",cursor) + 1;
- std::size_t upwardIndexFinish = theData.find("}",upwardIndexBegin);
- LevelsList upwardList = parseWard( theData, cursor );
+ //std::size_t upwardIndexBegin = dependencyStr.find("{",cursor) + 1;
+ //std::size_t upwardIndexFinish = dependencyStr.find("}",upwardIndexBegin);
+ LevelsList upwardList = parseWard( dependencyStr, cursor );
- LevelsList downwardList = parseWard( theData, cursor );
+ LevelsList downwardList = parseWard( dependencyStr, cursor );
tree[objectEntry] = std::pair<LevelsList,LevelsList>( upwardList, downwardList );
}
}
+
+bool GEOMUtils::CheckShape( TopoDS_Shape& shape,
+ bool checkGeometry )
+{
+ BRepCheck_Analyzer analyzer( shape, checkGeometry );
+ return analyzer.IsValid();
+}
+
+bool GEOMUtils::CheckBOPArguments(const TopoDS_Shape &theShape)
+{
+ BOPAlgo_ArgumentAnalyzer aChecker;
+
+ aChecker.SetShape1(theShape);
+
+ // Set default options
+ aChecker.ArgumentTypeMode() = Standard_True;
+ aChecker.SelfInterMode() = Standard_True;
+ aChecker.SmallEdgeMode() = Standard_True;
+ aChecker.RebuildFaceMode() = Standard_True;
+ aChecker.ContinuityMode() = Standard_True;
+ aChecker.CurveOnSurfaceMode() = Standard_True;
+
+ aChecker.StopOnFirstFaulty() = Standard_True;
+ aChecker.Perform();
+
+ // process result of checking
+ const bool isValid = !aChecker.HasFaulty();
+
+ return isValid;
+}
+
+bool GEOMUtils::FixShapeTolerance( TopoDS_Shape& shape,
+ TopAbs_ShapeEnum type,
+ Standard_Real tolerance,
+ bool checkGeometry )
+{
+ ShapeFix_ShapeTolerance aSft;
+ aSft.LimitTolerance( shape, tolerance, tolerance, type );
+ Handle(ShapeFix_Shape) aSfs = new ShapeFix_Shape( shape );
+ aSfs->Perform();
+ shape = aSfs->Shape();
+ return CheckShape( shape, checkGeometry );
+}
+
+bool GEOMUtils::FixShapeTolerance( TopoDS_Shape& shape,
+ Standard_Real tolerance,
+ bool checkGeometry )
+{
+ return FixShapeTolerance( shape, TopAbs_SHAPE, tolerance, checkGeometry );
+}
+
+bool GEOMUtils::FixShapeTolerance( TopoDS_Shape& shape,
+ bool checkGeometry )
+{
+ return FixShapeTolerance( shape, Precision::Confusion(), checkGeometry );
+}
+
+bool GEOMUtils::FixShapeCurves( TopoDS_Shape& shape )
+{
+ Standard_Real aT, aTolE, aD, aDMax;
+ TopExp_Explorer aExpF, aExpE;
+ NCollection_DataMap<TopoDS_Edge, Standard_Real, TopTools_ShapeMapHasher> aDMETol;
+ aExpF.Init(shape, TopAbs_FACE);
+ for (; aExpF.More(); aExpF.Next()) {
+ const TopoDS_Face& aF = *(TopoDS_Face*)&aExpF.Current();
+ aExpE.Init(aF, TopAbs_EDGE);
+ for (; aExpE.More(); aExpE.Next()) {
+ const TopoDS_Edge& aE = *(TopoDS_Edge*)&aExpE.Current();
+ try {
+ if (!BOPTools_AlgoTools::ComputeTolerance(aF, aE, aDMax, aT)) {
+ continue;
+ }
+ }
+ catch(...) {
+ continue;
+ }
+ aTolE = BRep_Tool::Tolerance(aE);
+ if (aDMax < aTolE) continue;
+ if (aDMETol.IsBound(aE)) {
+ aD = aDMETol.Find(aE);
+ if (aDMax > aD) {
+ aDMETol.UnBind(aE);
+ aDMETol.Bind(aE, aDMax);
+ }
+ }
+ else {
+ aDMETol.Bind(aE, aDMax);
+ }
+ }
+ }
+ NCollection_DataMap<TopoDS_Edge, Standard_Real, TopTools_ShapeMapHasher>::Iterator aDMETolIt(aDMETol);
+#ifdef USE_LIMIT_TOLERANCE
+ ShapeFix_ShapeTolerance sat;
+#else
+ BRep_Builder b;
+#endif
+ for (; aDMETolIt.More(); aDMETolIt.Next()) {
+#ifdef USE_LIMIT_TOLERANCE
+ sat.LimitTolerance(aDMETolIt.Key(), aDMETolIt.Value()*1.001);
+#else
+ TopoDS_Iterator itv(aDMETolIt.Key());
+ for (; itv.More(); itv.Next())
+ b.UpdateVertex(TopoDS::Vertex(itv.Value()), aDMETolIt.Value()*1.001);
+ b.UpdateEdge(aDMETolIt.Key(), aDMETolIt.Value()*1.001);
+#endif
+ }
+ return CheckShape( shape );
+}
+
+bool GEOMUtils::Write( const TopoDS_Shape& shape, const char* fileName )
+{
+ return BRepTools::Write( shape, fileName );
+}
+
+TopoDS_Shape GEOMUtils::ReduceCompound( const TopoDS_Shape& shape )
+{
+ TopoDS_Shape result = shape;
+
+ if ( shape.ShapeType() == TopAbs_COMPOUND ||
+ shape.ShapeType() == TopAbs_COMPSOLID ) {
+
+ TopTools_ListOfShape l;
+
+ TopoDS_Iterator it ( shape );
+ for ( ; it.More(); it.Next() )
+ l.Append( it.Value() );
+ if ( l.Extent() == 1 && l.First() != shape )
+ result = ReduceCompound( l.First() );
+ }
+
+ return result;
+}
+
+void GEOMUtils::MeshShape( const TopoDS_Shape shape,
+ double deflection, bool theForced )
+{
+ Standard_Real aDeflection = ( deflection <= 0 ) ? DefaultDeflection() : deflection;
+
+ // Is shape triangulated?
+ Standard_Boolean alreadyMeshed = true;
+ TopExp_Explorer ex;
+ TopLoc_Location aLoc;
+ for ( ex.Init( shape, TopAbs_FACE ); ex.More() && alreadyMeshed; ex.Next() ) {
+ const TopoDS_Face& aFace = TopoDS::Face( ex.Current() );
+ Handle(Poly_Triangulation) aPoly = BRep_Tool::Triangulation( aFace, aLoc );
+ alreadyMeshed = !aPoly.IsNull();
+ }
+
+ if ( !alreadyMeshed || theForced ) {
+ // Compute bounding box
+ Bnd_Box B;
+ BRepBndLib::Add( shape, B );
+ if ( B.IsVoid() )
+ return; // NPAL15983 (Bug when displaying empty groups)
+ Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax;
+ B.Get( aXmin, aYmin, aZmin, aXmax, aYmax, aZmax );
+
+ // This magic line comes from Prs3d_ShadedShape.gxx in OCCT
+ aDeflection = MAX3(aXmax-aXmin, aYmax-aYmin, aZmax-aZmin) * aDeflection * 4;
+
+ // Clean triangulation before compute incremental mesh
+ BRepTools::Clean( shape );
+
+ // Compute triangulation
+ BRepMesh_IncrementalMesh mesh( shape, aDeflection );
+ }
+}
+
+double GEOMUtils::DefaultDeflection()
+{
+ return 0.001;
+}
+
+//=======================================================================
+//function : IsOpenPath
+//purpose :
+//=======================================================================
+bool GEOMUtils::IsOpenPath(const TopoDS_Shape &theShape)
+{
+ bool isOpen = true;
+
+ if (theShape.IsNull() == Standard_False) {
+ if (theShape.Closed()) {
+ // The shape is closed
+ isOpen = false;
+ } else {
+ const TopAbs_ShapeEnum aType = theShape.ShapeType();
+
+ if (aType == TopAbs_EDGE || aType == TopAbs_WIRE) {
+ // Check if path ends are coincident.
+ TopoDS_Vertex aV[2];
+
+ if (aType == TopAbs_EDGE) {
+ // Edge
+ TopExp::Vertices(TopoDS::Edge(theShape), aV[0], aV[1]);
+ } else {
+ // Wire
+ TopExp::Vertices(TopoDS::Wire(theShape), aV[0], aV[1]);
+ }
+
+ if (aV[0].IsNull() == Standard_False &&
+ aV[1].IsNull() == Standard_False) {
+ if (aV[0].IsSame(aV[1])) {
+ // The shape is closed
+ isOpen = false;
+ } else {
+ const Standard_Real aTol1 = BRep_Tool::Tolerance(aV[0]);
+ const Standard_Real aTol2 = BRep_Tool::Tolerance(aV[1]);
+ const gp_Pnt aPnt1 = BRep_Tool::Pnt(aV[0]);
+ const gp_Pnt aPnt2 = BRep_Tool::Pnt(aV[1]);
+
+ if (aPnt1.Distance(aPnt2) <= aTol1 + aTol2) {
+ // The shape is closed
+ isOpen = false;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return isOpen;
+}
+
+//=======================================================================
+//function : CompareToleranceValues
+//purpose :
+//=======================================================================
+int GEOMUtils::CompareToleranceValues(const double theTolShape,
+ const double theTolRef)
+{
+ const double aTolTol = Min(DEFAULT_MAX_TOLERANCE_TOLERANCE,
+ theTolRef*DEFAULT_TOLERANCE_TOLERANCE);
+
+ int aResult = 0;
+
+ if (theTolShape < theTolRef - aTolTol) {
+ aResult = -1;
+ } else if (theTolShape > theTolRef + aTolTol) {
+ aResult = 1;
+ }
+
+ return aResult;
+}
+
+//=======================================================================
+//function : IsFitCondition
+//purpose :
+//=======================================================================
+bool GEOMUtils::IsFitCondition(const ComparisonCondition theCondition,
+ const double theTolShape,
+ const double theTolRef)
+{
+ const int aCompValue = CompareToleranceValues(theTolShape, theTolRef);
+ bool isFit = false;
+
+ switch (theCondition) {
+ case CC_GT:
+ isFit = aCompValue == 1;
+ break;
+ case GEOMUtils::CC_GE:
+ isFit = aCompValue != -1;
+ break;
+ case GEOMUtils::CC_LT:
+ isFit = aCompValue == -1;
+ break;
+ case GEOMUtils::CC_LE:
+ isFit = aCompValue != 1;
+ break;
+ default:
+ break;
+ }
+
+ return isFit;
+}
