0024481: Test "Perform Infinite Point" provides wrong result for a solid

Test cases for issue CR24481

src/BRepClass3d/BRepClass3d_SClassifier.cxx

@@ -30,12 +30,14 @@
 #include <ElCLib.hxx>
 #include <Geom_Surface.hxx>
 #include <BRep_Tool.hxx>
+#include <math_RealRandom.hxx>
+#include <BRepTopAdaptor_FClass2d.hxx>
 
 static
-  void FaceNormal (const TopoDS_Face& aF,
+  Standard_Boolean FaceNormal (const TopoDS_Face& aF,
-		   const Standard_Real U,
+                               const Standard_Real U,
-		   const Standard_Real V,
+                               const Standard_Real V,
-		   gp_Dir& aDN);
+                               gp_Dir& aDN);
 
 static 
   Standard_Real GetAddToParam(const gp_Lin& L,const Standard_Real P,const Bnd_Box& B);
@@ -73,12 +75,16 @@ BRepClass3d_SClassifier::BRepClass3d_SClassifier(BRepClass3d_SolidExplorer& S,
 //=======================================================================
 void BRepClass3d_SClassifier::PerformInfinitePoint(BRepClass3d_SolidExplorer& aSE,
 						   const Standard_Real /*Tol*/) {
-  //-- Idea : Take point A in face1 and point B in face B 
+
-  //-- (if there is only one face, take 2 points in the same face.)
+  //Take a normal to the first extracted face in its random inner point
-  //-- 
+  //and intersect this reversed normal with the faces of the solid.
-  //-- Intersect straight line AB with the solid and produce transition of the 
+  //If the min.par.-intersection point is
-  //-- first point. If the solid has only one face and the straight line AB does not cut it 
+  // a) inner point of a face
-  //-- it is not possible to decide.
+  // b) transition is not TANGENT
+  //    (the line does not touch the face but pierces it)
+  //then set <myState> to IN or OUT according to transition
+  //else take the next random point inside the min.par.-intersected face
+  //and continue
   
   if(aSE.Reject(gp_Pnt(0,0,0))) { 
     myState=3; //-- in ds solid case without face 
@@ -87,150 +93,83 @@ void BRepClass3d_SClassifier::PerformInfinitePoint(BRepClass3d_SolidExplorer& aS
   //
   //------------------------------------------------------------
   // 1
-  Standard_Boolean bFound, bFlag;
+  Standard_Boolean bFound;
-  Standard_Integer nump;
+  Standard_Real aParam, aU = 0., aV = 0.;
-  Standard_Real aParam, aU1 = 0., aV1 = 0., aU2 = 0., aV2 = 0.;
+  gp_Pnt aPoint;
-  gp_Pnt A,B;
+  gp_Dir aDN;
-  gp_Dir aDN1, aDN2;
+
-  TopoDS_Face aF1, aF2;
+  math_RealRandom RandomGenerator(0.1, 0.9);
-  //
-  nump = 0;
-  aParam = 0.5;
   myFace.Nullify();
   myState=2;
-  for(aSE.InitShell(); aSE.MoreShell() && nump<2;  aSE.NextShell()) { 
+
-    for(aSE.InitFace();	aSE.MoreFace()  && nump<2; ) {
+  aSE.InitShell();
+  if (aSE.MoreShell())
+  {
+    aSE.InitFace();
+    if (aSE.MoreFace())
+    {
       TopoDS_Face aF = aSE.CurrentFace();
-      aSE.NextFace();
+      TopAbs_State aState = TopAbs_OUT;
-      if(!nump) { 
+      IntCurveSurface_TransitionOnCurve aTransition = IntCurveSurface_Tangent;
-	nump++;
+      TopoDS_Face MinFace = aF;
-	bFound=aSE.FindAPointInTheFace(aF, A, aU1, aV1, aParam);
+      for (;;)
-	if (!bFound) {
-	  return;
-	}
-	aF1=aF;
-	if(!aSE.MoreFace()) { 
-	  nump++;
-	  bFound=aSE.FindAPointInTheFace(aF, B, aU2, aV2, aParam);
-	  if (!bFound) {
-	    return;
-	  }
-	  aF2=aF;
-	}
-      }// if(nump==0) {    
-      else if(nump==1) { 
-	bFound=aSE.FindAPointInTheFace(aF, B, aU2, aV2, aParam);
-	if(!bFound) { 
-	  return;
-	} 
-	aF2=aF;
-	nump++;
-      }
-    }// for(aSE.InitFace();	aSE.MoreFace()  && nump<2; ) {
-  }// for(aSE.InitShell(); aSE.MoreShell() && nump<2;  aSE.NextShell()) { 
-  //
-  //------------------------------------------------------------
-  // 2
-  Standard_Integer cpasbon;
-  Standard_Real parmin, aD2, aSP;
-  IntCurveSurface_TransitionOnCurve aTC;    
-  TopAbs_State aState;
-  //
-  parmin = RealLast();
-  //
-  bFlag=Standard_False;
-  if (aF1!=aF2) {
-    FaceNormal(aF1, aU1, aV1, aDN1);
-    FaceNormal(aF2, aU2, aV2, aDN2);
-    aSP=1.-aDN1*aDN2;
-    if (aSP < 1.e-5) {
-      bFlag=!bFlag;
-    }
-  }
-  //
-  aD2=A.SquareDistance(B);
-  if(aD2<0.000001 || bFlag) { 
-    B.SetCoord(A.X()+1,A.Y()+1,A.Z()+1);
-  }
-  //
-  cpasbon = 0;
-  gp_Vec AB(A,B);
-  //
-  do { 
-    switch (cpasbon) 
       {
-      case 1 : AB.SetX(-AB.X());break;
+        aParam = RandomGenerator.Next();
-      case 2 : AB.SetY(-AB.Y());break;
+	bFound = aSE.FindAPointInTheFace(aF, aPoint, aU, aV, aParam);
-      case 3 : AB.SetZ(-AB.Z());break;
+	if (!bFound)
-      case 4 : AB.SetY(-AB.Y());break;
+	  return;
-      case 5 : AB.SetX(-AB.X());break;
-      }
-    gp_Lin L(A,gp_Dir(AB));    
-    //-- cout<<"\npoint A "<<A.X()<<" "<<A.Y()<<" "<<A.Z()<<endl;
-    //-- cout<<"\npoint B "<<B.X()<<" "<<B.Y()<<" "<<B.Z()<<endl;
-    for(aSE.InitShell();aSE.MoreShell();aSE.NextShell()) { 
-      if(aSE.RejectShell(L) == Standard_False) { 
-	for(aSE.InitFace();aSE.MoreFace(); aSE.NextFace()) {
-	  if(aSE.RejectFace(L) == Standard_False) { 
-	    TopoDS_Shape aLocalShape = aSE.CurrentFace();
-	    TopoDS_Face f = TopoDS::Face(aLocalShape);
-	    IntCurvesFace_Intersector& Intersector3d = aSE.Intersector(f);
-	    Intersector3d.Perform(L,-RealLast(),parmin); 
 
-	    if(Intersector3d.IsDone()) { 
+        if (!FaceNormal(aF, aU, aV, aDN))
-	      if(Intersector3d.NbPnt()) { 
+          continue;
-		if(Intersector3d.WParameter(1) < parmin) {
+        gp_Lin aLin(aPoint, -aDN);
-		  aState=Intersector3d.State(1);
+        Standard_Real parmin = RealLast();
-		  parmin = Intersector3d.WParameter(1);
+        for (aSE.InitShell();aSE.MoreShell();aSE.NextShell()) { 
-		  if(aState==TopAbs_IN || aState==TopAbs_ON) { 
+          if (aSE.RejectShell(aLin) == Standard_False) { 
-		    aTC=Intersector3d.Transition(1);
+            for (aSE.InitFace();aSE.MoreFace(); aSE.NextFace()) {
-		    //-- The intersection point between the line and a face F 
+              if (aSE.RejectFace(aLin) == Standard_False) { 
-		    // -- of the solid is in the face F 
+                TopoDS_Shape aLocalShape = aSE.CurrentFace();
-		    if(aTC == IntCurveSurface_Out) { 
+                TopoDS_Face CurFace = TopoDS::Face(aLocalShape);
-		      //-- The line is going from inside the solid to outside 
+                IntCurvesFace_Intersector& Intersector3d = aSE.Intersector(CurFace);
-		      //-- the solid.
+                Intersector3d.Perform(aLin,-RealLast(),parmin); 
-		      myState = 3; //-- IN --
-		    }
-		    else if(aTC == IntCurveSurface_In) { 
-		      myState = 4; //-- OUT --
-		    }
-		    myFace  = f;
-		  }
-		  /*
-		  else if(Intersector3d.State(1)==TopAbs_ON)  {
-		    //-- The intersection point between the line and a face F 
-		    //-- of the solid is in the face F 
-		    if(Intersector3d.Transition(1) == IntCurveSurface_Out) { 
-		      //-- The line is going from inside the solid to outside 
-		      //-- the solid.
-		      myState = 3; //-- IN --
-		    }
-		    else if(Intersector3d.Transition(1) == IntCurveSurface_In) { 
-		      myState = 4; //-- OUT --
-		    }
-		    //-- myState = 2;
-		    myFace  = f;
-		  }
-		  */
-		}
                 
-		else { 
+                if(Intersector3d.IsDone()) {
-		  //-- No point has been found by the Intersector3d.
+                  if(Intersector3d.NbPnt()) { 
-		  //-- Or a Point has been found with a greater parameter.
+                    Standard_Integer imin = 1;
-		}
+                    for (Standard_Integer i = 2; i <= Intersector3d.NbPnt(); i++)
-	      }
+                      if (Intersector3d.WParameter(i) < Intersector3d.WParameter(imin))
-	    }
+                        imin = i;
-	  }
+                    parmin = Intersector3d.WParameter(imin);
-	} //-- Exploration of the faces
+                    aState = Intersector3d.State(imin);
-      } //-- Shell has not been rejected
+                    aTransition = Intersector3d.Transition(imin);
-      else { 
+                    MinFace = CurFace;
-	myState=1; 
+                  }
+                }
+              }
+            }
+          }
+          else
+            myState = 1;
+        } //end of loop on the whole solid
+        
+        if (aState == TopAbs_IN)
+        {
+          if (aTransition == IntCurveSurface_Out) { 
+            //-- The line is going from inside the solid to outside 
+            //-- the solid.
+            myState = 3; //-- IN --
+            return;
+          }
+          else if (aTransition == IntCurveSurface_In) { 
+            myState = 4; //-- OUT --
+            return;
+          }
+        }
+        aF = MinFace;
       }
-    } //-- Exploration of the shells
+    } //if (aSE.MoreFace())
-    cpasbon++;
+  } //if (aSE.MoreShell())
-  }
-  while(cpasbon!=0 && cpasbon<5);
 }
+
 //=======================================================================
 //function : Perform
 //purpose  : 
@@ -516,10 +455,10 @@ Standard_Real GetAddToParam(const gp_Lin&       L,
 //function : FaceNormal
 //purpose  : 
 //=======================================================================
-void FaceNormal (const TopoDS_Face& aF,
+Standard_Boolean FaceNormal (const TopoDS_Face& aF,
-		 const Standard_Real U,
+                             const Standard_Real U,
-		 const Standard_Real V,
+                             const Standard_Real V,
-		 gp_Dir& aDN)
+                             gp_Dir& aDN)
 {
   gp_Pnt aPnt ;
   gp_Vec aD1U, aD1V, aN;
@@ -528,10 +467,13 @@ void FaceNormal (const TopoDS_Face& aF,
   aS=BRep_Tool::Surface(aF);
   aS->D1 (U, V, aPnt, aD1U, aD1V);
   aN=aD1U.Crossed(aD1V);
+  if (aN.Magnitude() <= gp::Resolution())
+    return Standard_False;
+  
   aN.Normalize();  
   aDN.SetXYZ(aN.XYZ());
   if (aF.Orientation() == TopAbs_REVERSED){
     aDN.Reverse();
   }
-  return;
+  return Standard_True;
 }

src/BRepClass3d/BRepClass3d_SolidExplorer.cxx

@@ -54,6 +54,8 @@
 #include <BRep_Tool.hxx> 
 #include <BRepClass_FaceClassifier.hxx>
 //<-OCC454(apo)
+#include <BRepTopAdaptor_FClass2d.hxx> 
+
 
 //=======================================================================
 //function : FindAPointInTheFace
@@ -177,6 +179,14 @@ Standard_Boolean BRepClass3d_SolidExplorer::FindAPointInTheFace
       ParamInit *= 0.41234;
       u_ = P.X() + ParamInit* T.X();
       v_ = P.Y() + ParamInit* T.Y();
+
+      //Additional check
+      BRepTopAdaptor_FClass2d Classifier(face, Precision::Confusion());
+      gp_Pnt2d aPnt2d(u_, v_);
+      TopAbs_State StateOfResultingPoint = Classifier.Perform(aPnt2d);
+      if (StateOfResultingPoint != TopAbs_IN)
+        return Standard_False;
+      
       BRepAdaptor_Surface s;
       s.Initialize (face, Standard_False);
       s.D1 (u_, v_, APoint_, theVecD1U, theVecD1V);

tests/bugs/modalg_5/bug24481_1

@@ -0,0 +1,18 @@
+puts "================"
+puts "OCC24481"
+puts "================"
+puts ""
+#######################################################################
+# Test "Perform Infinite Point" provides wrong result for a solid
+#######################################################################
+
+set BugNumber OCC24481
+
+restore [locate_data_file bug24481_b1_64.brep] b
+
+set res [xclassify b]
+if { [regexp "OUT" $res] == 1 } {
+   puts "OK ${BugNumber}"
+} else {
+   puts "Faulty ${BugNumber}"
+}

tests/bugs/modalg_5/bug24481_2

@@ -0,0 +1,19 @@
+puts "================"
+puts "OCC24481"
+puts "================"
+puts ""
+#######################################################################
+# Test "Perform Infinite Point" provides wrong result for a solid
+#######################################################################
+
+set BugNumber OCC24481
+
+restore [locate_data_file bug24481_sdp.brep] b
+
+set res [xclassify b]
+
+if { [regexp "OUT" $res] == 1 } {
+   puts "OK ${BugNumber}"
+} else {
+   puts "Faulty ${BugNumber}"
+}