0026151: Wrong result obtained by intersection algorithm.

1. Methods IntPolyh_MaillageAffinage::GetMinDeflection() and IntPolyh_MaillageAffinage::GetMaxDeflection() have been created (see cdl-file for more detail information).
2. Extended check, if starting point of WLine is a tangent point, has been implemented in IntWalk_PWalking::Perform(...) method.

Test cases for issue CR26151

src/BOPTest/BOPTest_BOPCommands.cxx

@@ -678,8 +678,8 @@ Standard_Integer bopcurves (Draw_Interpretor& di,
   //
   anIsDone=aFF.IsDone();
   if (!anIsDone) {
-    di << " anIsDone=" << (Standard_Integer) anIsDone << "\n";
+    di << "Error: anIsDone=" << (Standard_Integer) anIsDone << "\n";
-    return 1;
+    return 0;
   }
   //
   aFF.PrepareLines3D(Standard_False);
@@ -692,7 +692,7 @@ Standard_Integer bopcurves (Draw_Interpretor& di,
   aNbCurves=aSCs.Length();
   if (!aNbCurves) {
     di << " has no 3d curve\n";
-    return 1;
+    return 0;
   }
   else
   {

src/IntPolyh/IntPolyh_Intersection.cdl

@@ -23,9 +23,9 @@
 -- times.
 
 class Intersection from IntPolyh
-	---Purpose:  the main   algorithm.  Algorythm   outputs are
+	---Purpose:  the main   algorithm.  Algorithm   outputs are
-	--           lines  and  points like   discribe   in the last
+	--           lines  and  points like   describe   in the last
-	--           paragraph.  The Algorythm provides direct acces to
+	--           paragraph.  The Algorithm provides direct access to
 	--           the elements of those   lines  and points. Other
 	--           classes  of this package  are for internal use and
 	--           only concern the algorithmic part.

src/IntPolyh/IntPolyh_Intersection.cxx

@@ -65,27 +65,17 @@ void IntPolyh_Intersection::Perform() {
 
   done = Standard_True;
 
-  Standard_Boolean startFromAdvanced = Standard_False;
   Standard_Boolean isStdDone = Standard_False;
   Standard_Boolean isAdvDone = Standard_False;
   Standard_Integer nbCouplesStd = 0;
   Standard_Integer nbCouplesAdv = 0;
   
-  //GeomAbs_SurfaceType ST1 = mySurf1->GetType();
-  //GeomAbs_SurfaceType ST2 = mySurf2->GetType();
-
-//   if(ST1 == GeomAbs_Torus || ST2 == GeomAbs_Torus)
-//     startFromAdvanced = Standard_True;
-  
   IntPolyh_PMaillageAffinage aPMaillageStd = 0;
   IntPolyh_PMaillageAffinage aPMaillageFF = 0;
   IntPolyh_PMaillageAffinage aPMaillageFR = 0;
   IntPolyh_PMaillageAffinage aPMaillageRF = 0;
   IntPolyh_PMaillageAffinage aPMaillageRR = 0;
 
-
-  if(!startFromAdvanced) {
-
   isStdDone = PerformStd(aPMaillageStd,nbCouplesStd);
 
   // default interference done well, use it
@@ -121,32 +111,6 @@ void IntPolyh_Intersection::Perform() {
     // 	aPMaillageRR->StartPointsChain(TSectionLines,TTangentZones);
     //       }
   }
-  }// start from default
-  else {
-    
-    isAdvDone = PerformAdv(aPMaillageFF,aPMaillageFR,aPMaillageRF,aPMaillageRR,nbCouplesAdv);
-
-    // advanced done, interference found; use it
-    if(isAdvDone) {
-
-      if(nbCouplesAdv > 0) {
-	aPMaillageFF->StartPointsChain(TSectionLines,TTangentZones);
-	aPMaillageFR->StartPointsChain(TSectionLines,TTangentZones);
-	aPMaillageRF->StartPointsChain(TSectionLines,TTangentZones);
-	aPMaillageRR->StartPointsChain(TSectionLines,TTangentZones);
-      }
-      else {
-	isStdDone = PerformStd(aPMaillageStd,nbCouplesStd);
-	if(isStdDone && nbCouplesStd > 0)
-	  aPMaillageStd->StartPointsChain(TSectionLines, TTangentZones);
-      }
-    }
-    else {
-      isStdDone = PerformStd(aPMaillageStd,nbCouplesStd);
-      if(isStdDone && nbCouplesStd > 0)
-	aPMaillageStd->StartPointsChain(TSectionLines, TTangentZones);
-    }
-  } // start from advanced
 
   // accept result
   nbsectionlines = TSectionLines.NbItems();

src/IntPolyh/IntPolyh_Intersection_1.cxx

@@ -27,7 +27,6 @@ Standard_Integer MYPRINT1   = 0;
 //function : IntPolyh_Intersection
 //purpose  : 
 //=======================================================================
-
 IntPolyh_Intersection::IntPolyh_Intersection(const Handle(Adaptor3d_HSurface)& S1,
                                              const TColStd_Array1OfReal& Upars1,
                                              const TColStd_Array1OfReal& Vpars1,
@@ -59,7 +58,6 @@ void IntPolyh_Intersection::Perform(const TColStd_Array1OfReal& Upars1,
 
   done = Standard_True;
 
-  Standard_Boolean startFromAdvanced = Standard_False;
   Standard_Boolean isStdDone = Standard_False;
   Standard_Boolean isAdvDone = Standard_False;
   Standard_Integer nbCouplesStd = 0;
@@ -72,9 +70,6 @@ void IntPolyh_Intersection::Perform(const TColStd_Array1OfReal& Upars1,
   IntPolyh_PMaillageAffinage aPMaillageRF = 0;
   IntPolyh_PMaillageAffinage aPMaillageRR = 0;
 
-
-  if(!startFromAdvanced) {
-
   isStdDone = PerformStd( Upars1, Vpars1, Upars2, Vpars2, 
                           aPMaillageStd,nbCouplesStd);
 
@@ -86,7 +81,8 @@ void IntPolyh_Intersection::Perform(const TColStd_Array1OfReal& Upars1,
   // use advanced interference
   else if(isStdDone && nbCouplesStd <= 10) {
     isAdvDone = PerformAdv( Upars1, Vpars1, Upars2, Vpars2,
-			     aPMaillageFF,aPMaillageFR,aPMaillageRF,aPMaillageRR,nbCouplesAdv);
+                            aPMaillageFF,aPMaillageFR,aPMaillageRF,
+                            aPMaillageRR,nbCouplesAdv);
       
     // advanced interference found
     if(isAdvDone && nbCouplesAdv > 10) {
@@ -112,34 +108,6 @@ void IntPolyh_Intersection::Perform(const TColStd_Array1OfReal& Upars1,
 // 	aPMaillageRR->StartPointsChain(TSectionLines,TTangentZones);
 //       }
   }
-  }// start from default
-  else {
-    
-    isAdvDone = PerformAdv(Upars1, Vpars1, Upars2, Vpars2,
-			   aPMaillageFF,aPMaillageFR,aPMaillageRF,aPMaillageRR,nbCouplesAdv);
-
-    // advanced done, interference found; use it
-    if(isAdvDone) {
-
-      if(nbCouplesAdv > 0) {
-	aPMaillageFF->StartPointsChain(TSectionLines,TTangentZones);
-	aPMaillageFR->StartPointsChain(TSectionLines,TTangentZones);
-	aPMaillageRF->StartPointsChain(TSectionLines,TTangentZones);
-	aPMaillageRR->StartPointsChain(TSectionLines,TTangentZones);
-      }
-      else {
-	isStdDone = PerformStd(aPMaillageStd,nbCouplesStd);
-	if(isStdDone && nbCouplesStd > 0)
-	  aPMaillageStd->StartPointsChain(TSectionLines, TTangentZones);
-      }
-    }
-    else {
-      isStdDone = PerformStd(Upars1, Vpars1, Upars2, Vpars2,
-			     aPMaillageStd,nbCouplesStd);
-      if(isStdDone && nbCouplesStd > 0)
-	aPMaillageStd->StartPointsChain(TSectionLines, TTangentZones);
-    }
-  } // start from advanced
 
   // accept result
   nbsectionlines = TSectionLines.NbItems();
@@ -305,7 +273,6 @@ Standard_Boolean IntPolyh_Intersection::PerformMaillage(const TColStd_Array1OfRe
 //function : PerformAdv
 //purpose  : 
 //=======================================================================
-
 Standard_Boolean IntPolyh_Intersection::PerformAdv(const TColStd_Array1OfReal& Upars1,
 						   const TColStd_Array1OfReal& Vpars1,
 						   const TColStd_Array1OfReal& Upars2,

src/IntPolyh/IntPolyh_MaillageAffinage.cdl

@@ -268,6 +268,10 @@ is
     SetEnlargeZone(me: in out; EnlargeZone: in out Boolean from Standard);
     GetEnlargeZone(me) returns Boolean from Standard;
 
+    GetMinDeflection(me; SurfID: Integer from Standard) returns Real from Standard;
+    --- Purpose: returns FlecheMin
+    GetMaxDeflection(me; SurfID: Integer from Standard) returns Real from Standard;
+    --- Purpose: returns FlecheMax
     
 fields
 
@@ -283,6 +287,9 @@ fields
     NbSamplesV1    : Integer from Standard;
     NbSamplesV2    : Integer from Standard;
     
+    -- Minimal and maximal distance between array of points in 
+    -- the surface (MaSurface1 and MaSurface2 correspondingly) and 
+    -- triangles on it.
     FlecheMax1     : Real    from Standard;
     FlecheMax2     : Real    from Standard;
     FlecheMin1     : Real    from Standard;

src/IntPolyh/IntPolyh_MaillageAffinage.cxx

@@ -3832,6 +3832,25 @@ Standard_Boolean IntPolyh_MaillageAffinage::GetEnlargeZone() const
 {
   return myEnlargeZone;
 }
+
+//=======================================================================
+//function : GetMinDeflection
+//purpose  : 
+//=======================================================================
+Standard_Real IntPolyh_MaillageAffinage::GetMinDeflection(const Standard_Integer SurfID) const
+{
+  return (SurfID==1)? FlecheMin1:FlecheMin2;
+}
+
+//=======================================================================
+//function : GetMaxDeflection
+//purpose  : 
+//=======================================================================
+Standard_Real IntPolyh_MaillageAffinage::GetMaxDeflection(const Standard_Integer SurfID) const
+{
+  return (SurfID==1)? FlecheMax1:FlecheMax2;
+}
+
 //=======================================================================
 //function : DegeneratedIndex
 //purpose  : 

src/IntWalk/IntWalk_PWalking.cxx

@@ -32,6 +32,8 @@
 #include <Standard_Failure.hxx>
 #include <gp_Pnt2d.hxx>
 
+#include <Extrema_GenLocateExtPS.hxx>
+
 //==================================================================================
 // function : IntWalk_PWalking::IntWalk_PWalking
 // purpose  :
@@ -575,6 +577,94 @@ void IntWalk_PWalking::Perform(const TColStd_Array1OfReal& ParDep)
 {
   Perform(ParDep,Um1,Vm1,Um2,Vm2,UM1,VM1,UM2,VM2);
 }
+
+//=======================================================================
+//function : SQDistPointSurface
+//purpose  : Returns square distance between thePnt and theSurf.
+//            (theU0, theV0) is initial point for extrema
+//=======================================================================
+static Standard_Real SQDistPointSurface(const gp_Pnt &thePnt,
+                                        const Adaptor3d_Surface& theSurf,
+                                        const Standard_Real theU0,
+                                        const Standard_Real theV0)
+{
+  const Extrema_GenLocateExtPS aExtPS(thePnt, theSurf, theU0, theV0,
+                      Precision::PConfusion(), Precision::PConfusion());
+  if(!aExtPS.IsDone())
+    return RealLast();
+  
+  return aExtPS.SquareDistance();
+}
+
+//==================================================================================
+// function : IsTangentExtCheck
+// purpose  : Additional check if the surfaces are tangent.
+//            Checks if any point in one surface lie in another surface
+//            (with given tolerance)
+//==================================================================================
+static Standard_Boolean IsTangentExtCheck(const Handle(Adaptor3d_HSurface)& theSurf1,
+                                          const Handle(Adaptor3d_HSurface)& theSurf2,
+                                          const Standard_Real theU10,
+                                          const Standard_Real theV10,
+                                          const Standard_Real theU20,
+                                          const Standard_Real theV20,
+                                          const Standard_Real theArrStep[])
+{
+  {
+    gp_Pnt aPt;
+    gp_Vec aDu1, aDv1, aDu2, aDv2;
+    theSurf1->D1(theU10, theV10, aPt, aDu1, aDv1);
+    theSurf2->D1(theU20, theV20, aPt, aDu2, aDv2);
+
+    const gp_Vec  aN1(aDu1.Crossed(aDv1)),
+                  aN2(aDu2.Crossed(aDv2));
+    const Standard_Real aDP = aN1.Dot(aN2),
+                        aSQ1 = aN1.SquareMagnitude(),
+                        aSQ2 = aN2.SquareMagnitude();
+
+    if((aSQ1 < RealSmall()) || (aSQ2 < RealSmall()))
+      return Standard_True; //Tangent
+
+    if(aDP*aDP < 0.9998*aSQ1*aSQ2)
+    {//cos(ang N1<->N2) < 0.9999
+      return Standard_False; //Not tangent
+    }
+  }
+
+  const Standard_Real aSQToler = 4.0e-14;
+  const Standard_Integer aNbItems = 4;
+  const Standard_Real aParUS1[aNbItems] = { theU10 + theArrStep[0],
+                                            theU10 - theArrStep[0],
+                                            theU10, theU10};
+  const Standard_Real aParVS1[aNbItems] = { theV10, theV10,
+                                            theV10 + theArrStep[1],
+                                            theV10 - theArrStep[1]};
+  const Standard_Real aParUS2[aNbItems] = { theU20 + theArrStep[2],
+                                            theU20 - theArrStep[2],
+                                            theU20, theU20};
+  const Standard_Real aParVS2[aNbItems] = { theV20, theV20,
+                                            theV20 + theArrStep[3],
+                                            theV20 - theArrStep[3]};
+
+  for(Standard_Integer i = 0; i < aNbItems; i++)
+  {
+    gp_Pnt aP(theSurf1->Value(aParUS1[i], aParVS1[i]));
+    const Standard_Real aSqDist = SQDistPointSurface(aP, theSurf2->Surface(), theU20, theV20);
+    if(aSqDist > aSQToler)
+      return Standard_False;
+  }
+
+  for(Standard_Integer i = 0; i < aNbItems; i++)
+  {
+    gp_Pnt aP(theSurf2->Value(aParUS2[i], aParVS2[i]));
+    const Standard_Real aSqDist = SQDistPointSurface(aP, theSurf1->Surface(), theU10, theV10);
+    if(aSqDist > aSQToler)
+      return Standard_False;
+  }
+
+  return Standard_True;
+}
+
 //==================================================================================
 // function : Perform
 // purpose  : 
@@ -701,6 +791,10 @@ void IntWalk_PWalking::Perform(const TColStd_Array1OfReal& ParDep,
   Standard_Boolean bTestFirstPoint = Standard_True;
 
   previousPoint.Parameters(Param(1),Param(2),Param(3),Param(4));
+
+  if(IsTangentExtCheck(Caro1, Caro2, Param(1), Param(2), Param(3), Param(4), pasuv))
+    return;
+
   AddAPoint(line,previousPoint);
   //
   IntWalk_StatusDeflection Status = IntWalk_OK;

tests/bugs/modalg_2/bug23732

@@ -10,7 +10,7 @@ restore [locate_data_file bug23732_fx1.brep] b1
 restore [locate_data_file bug23732_fx2.brep] b2
 
 mksurface s1 b1
-mksurface s2 b1
+mksurface s2 b2
 
 intersect result s1 s2
 

tests/bugs/modalg_6/bug26151_1

@@ -0,0 +1,33 @@
+puts "============"
+puts "OCC26151"
+puts "============"
+puts ""
+###############################
+## Wrong result obtained by intersection algorithm.
+###############################
+
+restore [locate_data_file bug26132_shape.brep] q
+
+explode q
+copy q_1 b1
+copy q_2 b2
+
+explode b1 f
+explode b2 
+explode b2_10 f
+
+set log [bopcurves b1_1 b2_10_4 -2d]
+
+#Faces almost coincide. Therefore, there is no point in
+#returning some intersection line.
+#Theoretically, the intersection result is some region (tangent zone).
+
+if { [regexp "has no 3d curve" ${log}] != 1 } {
+   puts "Error : Wrong result obtained by intersection algorithm"
+} else {
+   puts "OK : Good result obtained by intersection algorithm"
+}
+
+smallview
+fit
+xwd $imagedir/${test_image}.png

tests/bugs/modalg_6/bug26151_2

@@ -0,0 +1,33 @@
+puts "============"
+puts "OCC26151"
+puts "============"
+puts ""
+###############################
+## Wrong result obtained by intersection algorithm.
+###############################
+
+restore [locate_data_file bug26132_shape.brep] q
+
+explode q
+copy q_1 b1
+copy q_2 b2
+
+explode b1 f
+explode b2 
+explode b2_11 f
+
+set log [bopcurves b1_1 b2_11_2 -2d]
+
+#Faces almost coincide. Therefore, there is no point in
+#returning some intersection line.
+#Theoretically, the intersection result is some region (tangent zone).
+
+if { [regexp "has no 3d curve" ${log}] != 1 } {
+   puts "Error : Wrong result obtained by intersection algorithm"
+} else {
+   puts "OK : Good result obtained by intersection algorithm"
+}
+
+smallview
+fit
+xwd $imagedir/${test_image}.png

tests/perf/bspline/intersect

@@ -200,7 +200,9 @@ foreach s1 $surfaces {
 # lappend shapes f_$s1
   foreach s2 $surfaces {
     if { $s1 != $s2 } {
-            intersect r $s1 $s2
+      if [catch {intersect r $s1 $s2}] {
+        continue
+      }
     # if { [regexp {a 3d curve} [whatis r]] } {
 #   mkedge e_$i r
 #   lappend shapes e_$i