0024889: Geom2dAPI_InterCurveCurve produces result with parameter outside the curve...

1. DRAW-command for testing was created (see QABugs_19.cxx)
2. Alignments were changed in other files.

Main Changes are into IntCurve_IntConicConic_1.cxx file (variable isOutOfRange was added).
If found intersection point is out of range, minimal distance between corresponding ends of interval is taken. If this distance is less than tolerance, this point replaces found intersection point. Otherwise, found intersection point is ignored.
Modified QA command OCC24889 and added test case bugs/modalg_5/bug24889

diff --git a/src/IntCurve/IntCurve_IntConicConic_1.cxx b/src/IntCurve/IntCurve_IntConicConic_1.cxx
index ecd46142fba8a0f1fbed24ce33e9b10b9f2d059e..825d0ff2b845c12cca83a7d13f13de80e7ec3ae5 100644 (file)
--- a/src/IntCurve/IntCurve_IntConicConic_1.cxx
+++ b/src/IntCurve/IntCurve_IntConicConic_1.cxx
@@ -691,15 +691,16 @@ void IntCurve_IntConicConic::Perform(const gp_Circ2d& Circle1
   gp_Circ2d Circle2=_Circle2;
   IntRes2d_Domain  DomainCirc2=_DomainCirc2;
   Standard_Boolean IndirectCircles=Standard_False;
-  if(Circle1.IsDirect() != _Circle2.IsDirect()) { 
+  if(Circle1.IsDirect() != _Circle2.IsDirect())
+  { 
     IndirectCircles=Standard_True;
     Circle2=_Circle2.Reversed();
     DomainCirc2.SetValues(_DomainCirc2.LastPoint(),
-                         PIpPI-_DomainCirc2.LastParameter(),
-                         _DomainCirc2.LastTolerance(),
-                         _DomainCirc2.FirstPoint(),
-                         PIpPI-_DomainCirc2.FirstParameter(),
-                         _DomainCirc2.FirstTolerance());
+      PIpPI-_DomainCirc2.LastParameter(),
+      _DomainCirc2.LastTolerance(),
+      _DomainCirc2.FirstPoint(),
+      PIpPI-_DomainCirc2.FirstParameter(),
+      _DomainCirc2.FirstTolerance());
     DomainCirc2.SetEquivalentParameters(0.0,PIpPI);
   }
   
@@ -720,21 +721,31 @@ void IntCurve_IntConicConic::Perform(const gp_Circ2d& Circle1
   Standard_Real deltat = C1Domain.Bsup-C1Domain.Binf;
   if(deltat>=PIpPI) { deltat=PIpPI-1e-14; } 
   
-  while(C1Domain.Binf >= PIpPI) C1Domain.Binf-=PIpPI;
-  while(C1Domain.Binf <  0.0)   C1Domain.Binf+=PIpPI;
+  while(C1Domain.Binf >= PIpPI)
+    C1Domain.Binf-=PIpPI;
+  while(C1Domain.Binf <  0.0)
+    C1Domain.Binf+=PIpPI;
+
   C1Domain.Bsup=C1Domain.Binf+deltat;
 
   PeriodicInterval C2Domain(DomainCirc2); 
   deltat = C2Domain.Bsup-C2Domain.Binf;
-  if(deltat>=PIpPI) { deltat=PIpPI-1e-14; } 
+  if(deltat>=PIpPI)
+  {
+    deltat=PIpPI-1e-14;
+  } 
+
+  while(C2Domain.Binf >= PIpPI)
+    C2Domain.Binf-=PIpPI;
+  while(C2Domain.Binf <  0.0)
+    C2Domain.Binf+=PIpPI;
 
-  while(C2Domain.Binf >= PIpPI) C2Domain.Binf-=PIpPI;
-  while(C2Domain.Binf <  0.0)   C2Domain.Binf+=PIpPI;
   C2Domain.Bsup=C2Domain.Binf+deltat;
 
   Standard_Boolean IdentCircles=Standard_False;
 
-  if(nbsol>2) {       
+  if(nbsol>2)
+  {
     //-- Les 2 cercles sont confondus a Tol pres
     C1_Int1.SetValues(0,PIpPI);
     C1_Int2.SetNull(); 
@@ -788,7 +799,8 @@ void IntCurve_IntConicConic::Perform(const gp_Circ2d& Circle1
   //----------------------------------------------------------------------
   //----------- Traitement du second intervalle Geometrique   C1_Int2 ----
   //----------------------------------------------------------------------
-  if(nbsol==2) {
+  if(nbsol==2)
+  {
     C1DomainAndRes=C1Domain.FirstIntersection(C1_Int2);
     
     ProjectOnC2AndIntersectWithC2Domain(Circle1,Circle2
@@ -819,14 +831,17 @@ void IntCurve_IntConicConic::Perform(const gp_Circ2d& Circle1
   Standard_Real Tol2=Tol+Tol;     //---- Pour eviter de toujours retourner
                                   //des segments
   Standard_Integer i ;
-  if(Tol < (1e-10)) Tol2 = 1e-10; 
-  for( i=0; i<NbSolTotal ; i++) { 
-    if(((R1 * SolutionC1[i].Length()))<=Tol2 
-       && ((R2 * SolutionC2[i].Length()))<=Tol2) {
-      
+  if(Tol < (1e-10))
+    Tol2 = 1e-10; 
+
+  for( i=0; i<NbSolTotal ; i++)
+  { 
+    if(((R1 * SolutionC1[i].Length()) <=Tol2) && 
+              ((R2 * SolutionC2[i].Length())<=Tol2))
+    {
       Standard_Real t=(SolutionC1[i].Binf+SolutionC1[i].Bsup)*0.5;
       SolutionC1[i].Binf=SolutionC1[i].Bsup=t;
-      
+
       t=(SolutionC2[i].Binf+SolutionC2[i].Bsup)*0.5;
       SolutionC2[i].Binf=SolutionC2[i].Bsup=t;
     }
@@ -842,21 +857,91 @@ void IntCurve_IntConicConic::Perform(const gp_Circ2d& Circle1
   IntRes2d_Transition T1a,T1b,T2a,T2b;
   IntRes2d_Position Pos1a,Pos1b,Pos2a,Pos2b;
 
-  Standard_Boolean Opposite=((Circle1.Location().SquareDistance(Circle2.Location()))
-                  >(R1*R1+R2*R2))? Standard_True : Standard_False;
+  Standard_Boolean Opposite = 
+    ((Circle1.Location().SquareDistance(Circle2.Location())) > (R1*R1+R2*R2)) ? 
+          Standard_True : Standard_False;
 
   //if(Circle1.IsDirect()) { cout<<" C1 Direct"<<endl; } else { cout<<" C1 INDirect"<<endl; }
   //if(Circle2.IsDirect()) { cout<<" C2 Direct"<<endl; } else { cout<<" C2 INDirect"<<endl; }
 
-  for(i=0; i<NbSolTotal; i++) {
+  for(i=0; i<NbSolTotal; i++)
+  {
     Standard_Real C2inf=(Opposite)? SolutionC2[i].Bsup : SolutionC2[i].Binf;
     Standard_Real C2sup=(Opposite)? SolutionC2[i].Binf : SolutionC2[i].Bsup;
+    Standard_Real C1tinf = SolutionC1[i].Binf, C2tinf = C2inf;
+    Standard_Real C1inf=NormalizeOnCircleDomain(C1tinf,DomainCirc1);
+                  C2inf=NormalizeOnCircleDomain(C2tinf,DomainCirc2);
+
+    Standard_Boolean isOutOfRange = Standard_False;
+    if(C1inf < DomainCirc1.FirstParameter())
+    {
+      if(C1tinf < DomainCirc1.FirstParameter())
+      {
+        C1inf = DomainCirc1.FirstParameter();
+        isOutOfRange = Standard_True;
+      }
+      else
+      {
+        C1inf = C1tinf;
+      }
+    }
 
-    Standard_Real C1inf=NormalizeOnCircleDomain(SolutionC1[i].Binf,DomainCirc1);
-    C2inf=NormalizeOnCircleDomain(C2inf,DomainCirc2);
+    if(C1inf > DomainCirc1.LastParameter())
+    {
+      if(C1tinf > DomainCirc1.LastParameter())
+      {
+        C1inf = DomainCirc1.LastParameter();
+        isOutOfRange = Standard_True;
+      }
+      else
+      {
+        C1inf = C1tinf;
+      }
+    }
+    
+    if(C2inf < DomainCirc2.FirstParameter())
+    {
+      if(C2tinf < DomainCirc2.FirstParameter())
+      {
+        C2inf = DomainCirc2.FirstParameter();
+        isOutOfRange = Standard_True;
+      }
+      else
+      {
+        C2inf = C2tinf;
+      }
+    }
 
-    if(IndirectCircles) { 
-      
+    if(C2inf > DomainCirc2.LastParameter())
+    {
+      if(C2tinf > DomainCirc2.LastParameter())
+      {
+        C2inf = DomainCirc2.LastParameter();
+        isOutOfRange = Standard_True;
+      }
+      else
+      {
+        C2inf = C2tinf;
+      }
+    }
+
+    if(isOutOfRange)
+    {
+      gp_Pnt2d aP1, aP2;
+      gp_Vec2d aV11, aV12;
+      gp_Vec2d aV21, aV22;
+
+      ElCLib::CircleD2(C1inf,Axis2C1,R1,aP1,aV11,aV12); 
+      ElCLib::CircleD2(C2inf,Axis2C2,R2,aP2,aV21,aV22);
+
+      if(aP1.SquareDistance(aP2) > Tol2*Tol2)
+      {//there are not any solutions in given parametric range.
+        continue;
+      }
+    }
+
+    if(IndirectCircles)
+    { 
       ElCLib::CircleD2(C1inf,Axis2C1,R1,P1a,Tan1,Norm1); 
       ElCLib::CircleD2(C2inf,Axis2C2,R2,P2a,Tan2,Norm2);
       Tan2.Reverse();
@@ -868,47 +953,52 @@ void IntCurve_IntConicConic::Perform(const gp_Circ2d& Circle1
       
       IntRes2d_IntersectionPoint NewPoint1(P1a,C1inf,PIpPI-C2inf,T1a,T2a,Standard_False);
       
-      if((SolutionC1[i].Length()>0.0 ) || (SolutionC2[i].Length() >0.0)) {
-       //-- On traite un intervalle non reduit a un point
-       Standard_Real C1sup=NormalizeOnCircleDomain(SolutionC1[i].Bsup,DomainCirc1);
-       if(C1sup<C1inf) C1sup+=PIpPI;
-       C2sup=NormalizeOnCircleDomain(C2sup,DomainCirc2);
-       
-       ElCLib::CircleD2(C1sup,Axis2C1,R1,P1b,Tan1,Norm1); 
-       ElCLib::CircleD2(C2sup,Axis2C2,R2,P2b,Tan2,Norm2);
-       Tan2.Reverse();
-
-       IntImpParGen::DeterminePosition(Pos1b,DomainCirc1,P1b,C1sup);
-       IntImpParGen::DeterminePosition(Pos2b,_DomainCirc2,P2b,PIpPI-C2sup);
-       Determine_Transition_LC(Pos1b,Tan1,Norm1,T1b , Pos2b,Tan2,Norm2,T2b, Tol);
-       
-       //--------------------------------------------------
-       
-       if(Opposite) {
-         if(nbsol!=3) { 
-           if(C2inf<C2sup) C2inf+=PIpPI;
-         }
-       }
-       else {
-         if(nbsol!=3) { 
-           if(C2sup<C2inf) C2sup+=PIpPI;
-         }
-       }
-       
-       IntRes2d_IntersectionPoint NewPoint2(P1b,C1sup,PIpPI-C2sup,T1b,T2b,Standard_False);
-       IntRes2d_IntersectionSegment NewSeg(NewPoint1,NewPoint2,
-                                           (Opposite==Standard_True)? Standard_False : Standard_True,
-                                           Standard_False);
-       Append(NewSeg);
-       
+      if((SolutionC1[i].Length()>0.0 ) || (SolutionC2[i].Length() >0.0))
+      {
+        //-- On traite un intervalle non reduit a un point
+        Standard_Real C1sup=NormalizeOnCircleDomain(SolutionC1[i].Bsup,DomainCirc1);
+        if(C1sup<C1inf) C1sup+=PIpPI;
+        C2sup=NormalizeOnCircleDomain(C2sup,DomainCirc2);
+
+        ElCLib::CircleD2(C1sup,Axis2C1,R1,P1b,Tan1,Norm1); 
+        ElCLib::CircleD2(C2sup,Axis2C2,R2,P2b,Tan2,Norm2);
+        Tan2.Reverse();
+
+        IntImpParGen::DeterminePosition(Pos1b,DomainCirc1,P1b,C1sup);
+        IntImpParGen::DeterminePosition(Pos2b,_DomainCirc2,P2b,PIpPI-C2sup);
+        Determine_Transition_LC(Pos1b,Tan1,Norm1,T1b , Pos2b,Tan2,Norm2,T2b, Tol);
+
+        //--------------------------------------------------
+
+        if(Opposite)
+        {
+          if(nbsol!=3)
+          {
+            if(C2inf<C2sup)
+              C2inf+=PIpPI;
+          }
+        }
+        else
+        {
+          if(nbsol!=3)
+          {
+            if(C2sup<C2inf) C2sup+=PIpPI;
+          }
+        }
+
+        IntRes2d_IntersectionPoint NewPoint2(P1b,C1sup,PIpPI-C2sup,T1b,T2b,Standard_False);
+        IntRes2d_IntersectionSegment NewSeg(NewPoint1,NewPoint2,
+          (Opposite==Standard_True)? Standard_False : Standard_True,
+          Standard_False);
+        Append(NewSeg);
       }
-      else {
-       Append(NewPoint1);
+      else
+      {
+        Append(NewPoint1);
       }
-      
     }
-    else { 
-      
+    else
+    { 
       ElCLib::CircleD2(C1inf,Axis2C1,R1,P1a,Tan1,Norm1); 
       ElCLib::CircleD2(C2inf,Axis2C2,R2,P2a,Tan2,Norm2);
       
@@ -919,39 +1009,46 @@ void IntCurve_IntConicConic::Perform(const gp_Circ2d& Circle1
       
       IntRes2d_IntersectionPoint NewPoint1(P1a,C1inf,C2inf,T1a,T2a,Standard_False);
       
-      if((SolutionC1[i].Length()>0.0 ) || (SolutionC2[i].Length() >0.0)) {
-       //-- On traite un intervalle non reduit a un point
-       Standard_Real C1sup=NormalizeOnCircleDomain(SolutionC1[i].Bsup,DomainCirc1);
-       if(C1sup<C1inf) C1sup+=PIpPI;
-       C2sup=NormalizeOnCircleDomain(C2sup,DomainCirc2);
-       
-       ElCLib::CircleD2(C1sup,Axis2C1,R1,P1b,Tan1,Norm1); 
-       ElCLib::CircleD2(C2sup,Axis2C2,R2,P2b,Tan2,Norm2);
-       
-       IntImpParGen::DeterminePosition(Pos1b,DomainCirc1,P1b,C1sup);
-       IntImpParGen::DeterminePosition(Pos2b,DomainCirc2,P2b,C2sup);
-       Determine_Transition_LC(Pos1b,Tan1,Norm1,T1b , Pos2b,Tan2,Norm2,T2b, Tol);
-       
-       //--------------------------------------------------
-       
-       if(Opposite) {
-         if(nbsol!=3) { 
-           if(C2inf<C2sup) C2inf+=PIpPI;
-         }
-       }
-       else {
-         if(nbsol!=3) { 
-           if(C2sup<C2inf) C2sup+=PIpPI;
-         }
-       }
-       
-       IntRes2d_IntersectionPoint NewPoint2(P1b,C1sup,C2sup,T1b,T2b,Standard_False);
-       IntRes2d_IntersectionSegment NewSeg(NewPoint1,NewPoint2,Opposite,Standard_False);
-       Append(NewSeg);
-       
+      if((SolutionC1[i].Length()>0.0 ) || (SolutionC2[i].Length() >0.0))
+      {
+        //-- On traite un intervalle non reduit a un point
+        Standard_Real C1sup=NormalizeOnCircleDomain(SolutionC1[i].Bsup,DomainCirc1);
+        if(C1sup<C1inf) C1sup+=PIpPI;
+        C2sup=NormalizeOnCircleDomain(C2sup,DomainCirc2);
+
+        ElCLib::CircleD2(C1sup,Axis2C1,R1,P1b,Tan1,Norm1); 
+        ElCLib::CircleD2(C2sup,Axis2C2,R2,P2b,Tan2,Norm2);
+
+        IntImpParGen::DeterminePosition(Pos1b,DomainCirc1,P1b,C1sup);
+        IntImpParGen::DeterminePosition(Pos2b,DomainCirc2,P2b,C2sup);
+        Determine_Transition_LC(Pos1b,Tan1,Norm1,T1b , Pos2b,Tan2,Norm2,T2b, Tol);
+
+        //--------------------------------------------------
+
+        if(Opposite)
+        {
+          if(nbsol!=3)
+          {
+            if(C2inf<C2sup)
+              C2inf+=PIpPI;
+          }
+        }
+        else
+        {
+          if(nbsol!=3)
+          { 
+            if(C2sup<C2inf)
+              C2sup+=PIpPI;
+          }
+        }
+
+        IntRes2d_IntersectionPoint NewPoint2(P1b,C1sup,C2sup,T1b,T2b,Standard_False);
+        IntRes2d_IntersectionSegment NewSeg(NewPoint1,NewPoint2,Opposite,Standard_False);
+        Append(NewSeg);
       }
-      else {
-       Append(NewPoint1);
+      else
+      {
+        Append(NewPoint1);
       }
     }
   }

diff --git a/src/IntCurve/IntCurve_IntCurveCurveGen.gxx b/src/IntCurve/IntCurve_IntCurveCurveGen.gxx
index 256bd2416e43a9fbdefff9a7da2317cdfa885a66..c882ed98e17949f6b12367dcbe918dd616796468 100644 (file)
--- a/src/IntCurve/IntCurve_IntCurveCurveGen.gxx
+++ b/src/IntCurve/IntCurve_IntCurveCurveGen.gxx
@@ -231,572 +231,749 @@ void IntCurve_IntCurveCurveGen::InternalPerform (const TheCurve& C1,
                                                 const IntRes2d_Domain& D2,
                                                 const Standard_Real TolConf,
                                                 const Standard_Real Tol,
-                                                const Standard_Boolean Composite) {
+                                                const Standard_Boolean Composite)
+{
 
   GeomAbs_CurveType typ1 = TheCurveTool::GetType(C1);
   GeomAbs_CurveType typ2 = TheCurveTool::GetType(C2);
 
 
-  switch (typ1) {
-
+  switch (typ1)
+  {
   case GeomAbs_Line:
+    switch (typ2)
     {
-      switch (typ2) {
+    case GeomAbs_Line:
+      {
+        intconiconi.SetReversedParameters(Standard_False);
+        intconiconi.Perform(TheCurveTool::Line(C1),D1,
+          TheCurveTool::Line(C2),D2,TolConf,Tol);
+        if(Composite)
+        {
+          this->Append(intconiconi,
+            param1inf,
+            param1sup,
+            param2inf,
+            param2sup);
+        }
+        else
+        {
+          this->SetValues(intconiconi);
+        }
+      }
+      break;
 
-      case GeomAbs_Line:
-       {
-         intconiconi.SetReversedParameters(Standard_False);
-         intconiconi.Perform(TheCurveTool::Line(C1),D1,
-                             TheCurveTool::Line(C2),D2,TolConf,Tol);
-         if(Composite)    { this->Append(intconiconi,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconiconi); }
-       }
-       break;
+    case GeomAbs_Circle:
+      {
+        intconiconi.SetReversedParameters(Standard_False);
+        intconiconi.Perform(TheCurveTool::Line(C1),D1,
+          TheCurveTool::Circle(C2),D2,TolConf,Tol);
+        if(Composite)
+        {
+          this->Append(intconiconi,
+            param1inf,
+            param1sup,
+            param2inf,
+            param2sup);
+        }
+        else
+        {
+          this->SetValues(intconiconi);
+        }
+      }
+      break;
 
-      case GeomAbs_Circle:
-       {
-         intconiconi.SetReversedParameters(Standard_False);
-         intconiconi.Perform(TheCurveTool::Line(C1),D1,
-                             TheCurveTool::Circle(C2),D2,TolConf,Tol);
-         if(Composite)    { this->Append(intconiconi,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconiconi); }
-       }
-       break;
+    case GeomAbs_Ellipse:
+      {
+        intconiconi.SetReversedParameters(Standard_False);
+        intconiconi.Perform(TheCurveTool::Line(C1),D1,
+          TheCurveTool::Ellipse(C2),D2,TolConf,Tol);
+        if(Composite)
+        {
+          this->Append(intconiconi,
+            param1inf,
+            param1sup,
+            param2inf,
+            param2sup);
+        }
+        else
+        {
+          this->SetValues(intconiconi);
+        }
+      }
+      break;
 
-      case GeomAbs_Ellipse:
-       {
-         intconiconi.SetReversedParameters(Standard_False);
-         intconiconi.Perform(TheCurveTool::Line(C1),D1,
-                             TheCurveTool::Ellipse(C2),D2,TolConf,Tol);
-         if(Composite)    { this->Append(intconiconi,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconiconi); }
-       }
-       break;
+    case GeomAbs_Parabola:
+      {
+        intconiconi.SetReversedParameters(Standard_False);
+        intconiconi.Perform(TheCurveTool::Line(C1),D1,
+          TheCurveTool::Parabola(C2),D2,TolConf,Tol);
+        if(Composite)
+        {
+          this->Append(intconiconi,
+            param1inf,
+            param1sup,
+            param2inf,
+            param2sup);
+        }
+        else
+        {
+          this->SetValues(intconiconi);
+        }
+      }
+      break;
 
-      case GeomAbs_Parabola:
-       {
-         intconiconi.SetReversedParameters(Standard_False);
-         intconiconi.Perform(TheCurveTool::Line(C1),D1,
-                             TheCurveTool::Parabola(C2),D2,TolConf,Tol);
-         if(Composite)    { this->Append(intconiconi,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconiconi); }
-       }
-       break;
+    case GeomAbs_Hyperbola:
+      {
+        intconiconi.SetReversedParameters(Standard_False);
+        intconiconi.Perform(TheCurveTool::Line(C1),D1,
+          TheCurveTool::Hyperbola(C2),D2,TolConf,Tol);
+        if(Composite)
+        {
+          this->Append(intconiconi,
+            param1inf,
+            param1sup,
+            param2inf,
+            param2sup);
+        }
+        else
+        {
+          this->SetValues(intconiconi);
+        }
+      }
 
-      case GeomAbs_Hyperbola:
-       {
-         intconiconi.SetReversedParameters(Standard_False);
-         intconiconi.Perform(TheCurveTool::Line(C1),D1,
-                             TheCurveTool::Hyperbola(C2),D2,TolConf,Tol);
-         if(Composite)    { this->Append(intconiconi,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconiconi); }
-       }
-       break;
+      break;
 
-      case GeomAbs_BezierCurve:
-      case GeomAbs_BSplineCurve:
-      case GeomAbs_OtherCurve: 
-       {
-         intconicurv.SetReversedParameters(Standard_False);
-         intconicurv.Perform(TheCurveTool::Line(C1),D1,
-                             C2,D2,TolConf,Tol);
-         if(Composite)    { this->Append(intconicurv,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconicurv); }
-       }
-       break;
+    case GeomAbs_BezierCurve:
+    case GeomAbs_BSplineCurve:
+    case GeomAbs_OtherCurve: 
+      {
+        intconicurv.SetReversedParameters(Standard_False);
+        intconicurv.Perform(TheCurveTool::Line(C1),D1,
+          C2,D2,TolConf,Tol);
+        if(Composite)
+        {
+          this->Append(intconicurv,
+            param1inf,
+            param1sup,
+            param2inf,
+            param2sup);
+        }
+        else
+        {
+          this->SetValues(intconicurv);
+        }
       }
+      break;
+    }
     break;  
-      
-
-    case GeomAbs_Circle:
-      
-      switch (typ2) {
-       
-      case GeomAbs_Line:
-       {
-         intconiconi.SetReversedParameters(Standard_True);
-         intconiconi.Perform(TheCurveTool::Line(C2),D2,
-                             TheCurveTool::Circle(C1),D1,TolConf,Tol);
-         if(Composite)    { this->Append(intconiconi,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconiconi); }
-       }
-       break;
 
-      case GeomAbs_Circle:
-       {
-         intconiconi.SetReversedParameters(Standard_False);
-         intconiconi.Perform(TheCurveTool::Circle(C1),D1,
-                             TheCurveTool::Circle(C2),D2,TolConf,Tol);
-         if(Composite)    { this->Append(intconiconi,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconiconi); }
-       }
-       break;
+  case GeomAbs_Circle:
+    switch (typ2)
+    {
+    case GeomAbs_Line:
+      {
+        intconiconi.SetReversedParameters(Standard_True);
+        intconiconi.Perform(TheCurveTool::Line(C2),D2,
+          TheCurveTool::Circle(C1),D1,TolConf,Tol);
+        if(Composite)
+        {
+          this->Append(intconiconi,
+            param1inf,
+            param1sup,
+            param2inf,
+            param2sup);
+        }
+        else
+        {
+          this->SetValues(intconiconi);
+        }
+      }
+      break;
 
-      case GeomAbs_Ellipse:
-       {
-         intconiconi.SetReversedParameters(Standard_False);
-         intconiconi.Perform(TheCurveTool::Circle(C1),D1,
-                             TheCurveTool::Ellipse(C2),D2,TolConf,Tol);
-         if(Composite)    { this->Append(intconiconi,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconiconi); }
-       }
-       break;
+    case GeomAbs_Circle:
+      {
+        intconiconi.SetReversedParameters(Standard_False);
+        intconiconi.Perform(TheCurveTool::Circle(C1),D1,
+          TheCurveTool::Circle(C2),D2,TolConf,Tol);
+        if(Composite)
+        {
+          this->Append(intconiconi,
+          param1inf,
+          param1sup,
+          param2inf,
+          param2sup);
+        }
+        else
+        {
+          this->SetValues(intconiconi);
+        }
+      }
+      break;
 
-      case GeomAbs_Parabola:
-       {
-         intconiconi.SetReversedParameters(Standard_False);
-         intconiconi.Perform(TheCurveTool::Circle(C1),D1,
-                             TheCurveTool::Parabola(C2),D2,TolConf,Tol);
-         if(Composite)    { this->Append(intconiconi,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconiconi); }
-       }
-       break;
+    case GeomAbs_Ellipse:
+      {
+        intconiconi.SetReversedParameters(Standard_False);
+        intconiconi.Perform(TheCurveTool::Circle(C1),D1,
+          TheCurveTool::Ellipse(C2),D2,TolConf,Tol);
+        if(Composite)
+        {
+          this->Append(intconiconi,
+            param1inf,
+            param1sup,
+            param2inf,
+            param2sup);
+        }
+        else
+        {
+          this->SetValues(intconiconi);
+        }
+      }
+      break;
 
-      case GeomAbs_Hyperbola:
-       {
-         intconiconi.SetReversedParameters(Standard_False);
-         intconiconi.Perform(TheCurveTool::Circle(C1),D1,
-                             TheCurveTool::Hyperbola(C2),D2,TolConf,Tol);
-         if(Composite)    { this->Append(intconiconi,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconiconi); }
-       }
-       break;
+    case GeomAbs_Parabola:
+      {
+        intconiconi.SetReversedParameters(Standard_False);
+        intconiconi.Perform(TheCurveTool::Circle(C1),D1,
+          TheCurveTool::Parabola(C2),D2,TolConf,Tol);
+        if(Composite)
+        {
+          this->Append(intconiconi,
+            param1inf,
+            param1sup,
+            param2inf,
+            param2sup);
+        }
+        else
+        {
+          this->SetValues(intconiconi);
+        }
+      }
+      break;
 
-      case GeomAbs_BezierCurve:
-      case GeomAbs_BSplineCurve:
-      case GeomAbs_OtherCurve:
-       {
-         intconicurv.SetReversedParameters(Standard_False);
-         intconicurv.Perform(TheCurveTool::Circle(C1),D1,
-                             C2,D2,TolConf,Tol);
-         if(Composite)    { this->Append(intconicurv,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconicurv); }
-       }
-       break;
+    case GeomAbs_Hyperbola:
+      {
+        intconiconi.SetReversedParameters(Standard_False);
+        intconiconi.Perform(TheCurveTool::Circle(C1),D1,
+          TheCurveTool::Hyperbola(C2),D2,TolConf,Tol);
+        if(Composite)
+        {
+          this->Append(intconiconi,
+            param1inf,
+            param1sup,
+            param2inf,
+            param2sup);
+        }
+        else
+        {
+          this->SetValues(intconiconi);
+        }
+      }
+      break;
 
+    case GeomAbs_BezierCurve:
+    case GeomAbs_BSplineCurve:
+    case GeomAbs_OtherCurve:
+      {
+        intconicurv.SetReversedParameters(Standard_False);
+        intconicurv.Perform(TheCurveTool::Circle(C1),D1,
+          C2,D2,TolConf,Tol);
+        if(Composite)
+        {
+          this->Append(intconicurv,
+            param1inf,
+            param1sup,
+            param2inf,
+            param2sup);  }
+        else
+        {
+          this->SetValues(intconicurv);
+        }
       }
+
+      break;
+    }
     break;
 
-    case GeomAbs_Ellipse:
-      
-      switch (typ2) {
-       
+  case GeomAbs_Ellipse:
+    switch (typ2)
+    {
       case GeomAbs_Line:
-       {
-         intconiconi.SetReversedParameters(Standard_True);
-         intconiconi.Perform(TheCurveTool::Line(C2),D2,
-                             TheCurveTool::Ellipse(C1),D1,TolConf,Tol);
-         if(Composite)    { this->Append(intconiconi,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconiconi); }
-       }
-       break;
+        {
+          intconiconi.SetReversedParameters(Standard_True);
+          intconiconi.Perform(TheCurveTool::Line(C2),D2,
+                              TheCurveTool::Ellipse(C1),D1,
+                              TolConf,Tol);
+
+          if(Composite)
+          {
+            this->Append(intconiconi,
+              param1inf,
+              param1sup,
+              param2inf,
+              param2sup);
+          }
+          else
+          {
+            this->SetValues(intconiconi);
+          }
+        }
+        break;
 
       case GeomAbs_Circle:
-       {
-         intconiconi.SetReversedParameters(Standard_True);
-         intconiconi.Perform(TheCurveTool::Circle(C2),D2,
-                             TheCurveTool::Ellipse(C1),D1,TolConf,Tol);
-         if(Composite)    { this->Append(intconiconi,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconiconi); }
-       }
-       break;
+        {
+          intconiconi.SetReversedParameters(Standard_True);
+
+          intconiconi.Perform(TheCurveTool::Circle(C2),D2,
+            TheCurveTool::Ellipse(C1),D1,TolConf,Tol);
+          if(Composite)
+          {
+            this->Append(intconiconi,
+              param1inf,
+              param1sup,
+              param2inf,
+              param2sup);
+          }
+          else
+          {
+            this->SetValues(intconiconi);
+          }
+        }
+        break;
 
       case GeomAbs_Ellipse:
-       {
-         intconiconi.SetReversedParameters(Standard_False);
-         intconiconi.Perform(TheCurveTool::Ellipse(C1),D1,
-                             TheCurveTool::Ellipse(C2),D2,TolConf,Tol);
-         if(Composite)    { this->Append(intconiconi,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconiconi); }
-       }
-       break;
+        {
+          intconiconi.SetReversedParameters(Standard_False);
+          intconiconi.Perform(TheCurveTool::Ellipse(C1),D1,
+            TheCurveTool::Ellipse(C2),D2,TolConf,Tol);
+          if(Composite)
+          {
+            this->Append(intconiconi,
+              param1inf,
+              param1sup,
+              param2inf,
+              param2sup);
+          }
+          else
+          {
+            this->SetValues(intconiconi);
+          }
+        }
+        break;
 
       case GeomAbs_Parabola:
-       {
-         intconiconi.SetReversedParameters(Standard_False);
-         intconiconi.Perform(TheCurveTool::Ellipse(C1),D1,
-                             TheCurveTool::Parabola(C2),D2,TolConf,Tol);
-         if(Composite)    { this->Append(intconiconi,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconiconi); }
-       }
-       break;
+        {
+          intconiconi.SetReversedParameters(Standard_False);
+          intconiconi.Perform(TheCurveTool::Ellipse(C1),D1,
+            TheCurveTool::Parabola(C2),D2,TolConf,Tol);
+          if(Composite)
+          {
+            this->Append(intconiconi,
+              param1inf,
+              param1sup,
+              param2inf,
+              param2sup);
+          }
+          else
+          {
+            this->SetValues(intconiconi);
+          }
+        }
+        break;
 
       case GeomAbs_Hyperbola:
-       {
-         intconiconi.SetReversedParameters(Standard_False);
-         intconiconi.Perform(TheCurveTool::Ellipse(C1),D1,
-                             TheCurveTool::Hyperbola(C2),D2,
-                             TolConf,Tol);
-         if(Composite)    { this->Append(intconiconi,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconiconi); }
-       }
-       break;
+        {
+          intconiconi.SetReversedParameters(Standard_False);
+          intconiconi.Perform(TheCurveTool::Ellipse(C1),D1,
+            TheCurveTool::Hyperbola(C2),D2,
+            TolConf,Tol);
+          if(Composite)
+          {
+            this->Append(intconiconi,
+              param1inf,
+              param1sup,
+              param2inf,
+              param2sup);
+          }
+          else
+          {
+            this->SetValues(intconiconi);
+          }
+        }
+        break;
 
       case GeomAbs_BezierCurve:
       case GeomAbs_BSplineCurve:
       case GeomAbs_OtherCurve:
-       {
-         intconicurv.SetReversedParameters(Standard_False);
-         intconicurv.Perform(TheCurveTool::Ellipse(C1),D1,
-                             C2,D2,TolConf,Tol);
-         if(Composite)    { this->Append(intconicurv,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconicurv); }
-       }
-       break;
-      }
+        {
+          intconicurv.SetReversedParameters(Standard_False);
+          intconicurv.Perform(TheCurveTool::Ellipse(C1),D1,
+            C2,D2,TolConf,Tol);
+          if(Composite)
+          {
+            this->Append(intconicurv,
+              param1inf,
+              param1sup,
+              param2inf,
+              param2sup);
+          }
+          else
+          {
+            this->SetValues(intconicurv);
+          }
+        }
+        break;
+    }
     break;
 
+  case GeomAbs_Parabola:
+    switch (typ2)
+    {
+    case GeomAbs_Line:
+      {
+        intconiconi.SetReversedParameters(Standard_True);
+        intconiconi.Perform(TheCurveTool::Line(C2),D2,
+          TheCurveTool::Parabola(C1),D1,TolConf,Tol);
+        if(Composite)
+        {
+          this->Append(intconiconi,
+            param1inf,
+            param1sup,
+            param2inf,
+            param2sup);
+        }
+        else
+        {
+          this->SetValues(intconiconi);
+        }
+      }
+      break;
 
-    case GeomAbs_Parabola:
-      
-      switch (typ2) {
-       
-      case GeomAbs_Line:
-       {
-         intconiconi.SetReversedParameters(Standard_True);
-         intconiconi.Perform(TheCurveTool::Line(C2),D2,
-                             TheCurveTool::Parabola(C1),D1,TolConf,Tol);
-         if(Composite)    { this->Append(intconiconi,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconiconi); }
-       }
-       break;
-
-      case GeomAbs_Circle:
-       {
-         intconiconi.SetReversedParameters(Standard_True);
-         intconiconi.Perform(TheCurveTool::Circle(C2),D2,
-                             TheCurveTool::Parabola(C1),D1,TolConf,Tol);
-         if(Composite)    { this->Append(intconiconi,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconiconi); }
-       }
-       break;
-
-      case GeomAbs_Ellipse:
-       {
-         intconiconi.SetReversedParameters(Standard_True);
-         intconiconi.Perform(TheCurveTool::Ellipse(C2),D2,
-                             TheCurveTool::Parabola(C1),D1,TolConf,Tol);
-         if(Composite)    { this->Append(intconiconi,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconiconi); }
-       }
-       break;
-
-      case GeomAbs_Parabola:
-       {
-         intconiconi.SetReversedParameters(Standard_False);
-         intconiconi.Perform(TheCurveTool::Parabola(C1),D1,
-                             TheCurveTool::Parabola(C2),D2,TolConf,Tol);
-         if(Composite)    { this->Append(intconiconi,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconiconi); }
-       }
-       break;
-
-      case GeomAbs_Hyperbola:
-       {
-         intconiconi.SetReversedParameters(Standard_False);
-         intconiconi.Perform(TheCurveTool::Parabola(C1),D1,
-                             TheCurveTool::Hyperbola(C2),D2,
-                             TolConf,Tol);
-         if(Composite)    { this->Append(intconiconi,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconiconi); }
-       }
-       break;
+    case GeomAbs_Circle:
+      {
+        intconiconi.SetReversedParameters(Standard_True);
+        intconiconi.Perform(TheCurveTool::Circle(C2),D2,
+          TheCurveTool::Parabola(C1),D1,TolConf,Tol);
+        if(Composite)
+        { this->Append(intconiconi,
+        param1inf,
+        param1sup,
+        param2inf,
+        param2sup);
+        }
+        else
+        {
+          this->SetValues(intconiconi);
+        }
+      }
+      break;
 
-      case GeomAbs_BezierCurve:
-      case GeomAbs_BSplineCurve:
-      case GeomAbs_OtherCurve:
-       {
-         intconicurv.SetReversedParameters(Standard_False);
-         intconicurv.Perform(TheCurveTool::Parabola(C1),D1,
-                             C2,D2,TolConf,Tol);
-         if(Composite)    { this->Append(intconicurv,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconicurv); }
-       }
-       break;
+    case GeomAbs_Ellipse:
+      {
+        intconiconi.SetReversedParameters(Standard_True);
+        intconiconi.Perform(TheCurveTool::Ellipse(C2),D2,
+          TheCurveTool::Parabola(C1),D1,TolConf,Tol);
+        if(Composite)
+        {
+          this->Append(intconiconi,
+            param1inf,
+            param1sup,
+            param2inf,
+            param2sup);
+        }
+        else
+        {
+          this->SetValues(intconiconi);
+        }
       }
-    break;
+      break;
 
+    case GeomAbs_Parabola:
+      {
+        intconiconi.SetReversedParameters(Standard_False);
+        intconiconi.Perform(TheCurveTool::Parabola(C1),D1,
+          TheCurveTool::Parabola(C2),D2,TolConf,Tol);
+        if(Composite)
+        {
+          this->Append(intconiconi,
+            param1inf,
+            param1sup,
+            param2inf,
+            param2sup);
+        }
+        else
+        {
+          this->SetValues(intconiconi);
+        }
+      }
+      break;
 
     case GeomAbs_Hyperbola:
-      
-      switch (typ2) {
-       
-      case GeomAbs_Line:
-       {
-         intconiconi.SetReversedParameters(Standard_True);
-         intconiconi.Perform(TheCurveTool::Line(C2),D2,
-                             TheCurveTool::Hyperbola(C1),D1,TolConf,Tol);
-         if(Composite)    { this->Append(intconiconi,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconiconi); }
-       }
-       break;
+      {
+        intconiconi.SetReversedParameters(Standard_False);
+        intconiconi.Perform(TheCurveTool::Parabola(C1),D1,
+          TheCurveTool::Hyperbola(C2),D2,
+          TolConf,Tol);
+        if(Composite)
+        {
+          this->Append(intconiconi,
+            param1inf,
+            param1sup,
+            param2inf,
+            param2sup);
+        }
+        else
+        {
+          this->SetValues(intconiconi);
+        }
+      }
+      break;
 
-      case GeomAbs_Circle:
-       {
-         intconiconi.SetReversedParameters(Standard_True);
-         intconiconi.Perform(TheCurveTool::Circle(C2),D2,
-                             TheCurveTool::Hyperbola(C1),D1,TolConf,Tol);
-         if(Composite)    { this->Append(intconiconi,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconiconi); }
-       }
-       break;
+    case GeomAbs_BezierCurve:
+    case GeomAbs_BSplineCurve:
+    case GeomAbs_OtherCurve:
+      {
+        intconicurv.SetReversedParameters(Standard_False);
+        intconicurv.Perform(TheCurveTool::Parabola(C1),D1,
+          C2,D2,TolConf,Tol);
+        if(Composite)
+        {
+          this->Append(intconicurv,
+            param1inf,
+            param1sup,
+            param2inf,
+            param2sup);
+        }
+        else
+        {
+          this->SetValues(intconicurv);
+        }
+      }
+      break;
+    }
+    break;
 
-      case GeomAbs_Ellipse:
-       {
-         intconiconi.SetReversedParameters(Standard_True);
-         intconiconi.Perform(TheCurveTool::Ellipse(C2),D2,
-                             TheCurveTool::Hyperbola(C1),D1,TolConf,Tol);
-         if(Composite)    { this->Append(intconiconi,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconiconi); }
-       }
-       break;
+  case GeomAbs_Hyperbola:
+    switch (typ2)
+    {
+    case GeomAbs_Line:
+      {
+        intconiconi.SetReversedParameters(Standard_True);
+        intconiconi.Perform(TheCurveTool::Line(C2),D2,
+          TheCurveTool::Hyperbola(C1),D1,TolConf,Tol);
+        if(Composite)
+        {
+          this->Append(intconiconi,
+            param1inf,
+            param1sup,
+            param2inf,
+            param2sup);
+        }
+        else
+        {
+          this->SetValues(intconiconi);
+        }
+      }
+      break;
 
-      case GeomAbs_Parabola:
-       {
-         intconiconi.SetReversedParameters(Standard_True);
-         intconiconi.Perform(TheCurveTool::Parabola(C2),D2,
-                             TheCurveTool::Hyperbola(C1),D1,TolConf,Tol);
-         if(Composite)    { this->Append(intconiconi,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconiconi); }
-       }
-       break;
+    case GeomAbs_Circle:
+      {
+        intconiconi.SetReversedParameters(Standard_True);
+        intconiconi.Perform(TheCurveTool::Circle(C2),D2,
+          TheCurveTool::Hyperbola(C1),D1,TolConf,Tol);
+        if(Composite)    { this->Append(intconiconi,
+          param1inf,
+          param1sup,
+          param2inf,
+          param2sup);  }
+        else             { this->SetValues(intconiconi); }
+      }
+      break;
 
-      case GeomAbs_Hyperbola:
-       {
-         intconiconi.SetReversedParameters(Standard_False);
-         intconiconi.Perform(TheCurveTool::Hyperbola(C1),D1,
-                             TheCurveTool::Hyperbola(C2),D2,
-                             TolConf,Tol);
-         if(Composite)    { this->Append(intconiconi,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconiconi); }
-       }
-       break;
+    case GeomAbs_Ellipse:
+      {
+        intconiconi.SetReversedParameters(Standard_True);
+        intconiconi.Perform(TheCurveTool::Ellipse(C2),D2,
+          TheCurveTool::Hyperbola(C1),D1,TolConf,Tol);
+        if(Composite)    { this->Append(intconiconi,
+          param1inf,
+          param1sup,
+          param2inf,
+          param2sup);  }
+        else             { this->SetValues(intconiconi); }
+      }
+      break;
 
-      case GeomAbs_BezierCurve:
-      case GeomAbs_BSplineCurve:
-      case GeomAbs_OtherCurve:
-       {
-         intconicurv.SetReversedParameters(Standard_False);
-         intconicurv.Perform(TheCurveTool::Hyperbola(C1),D1,
-                             C2,D2,TolConf,Tol);
-         if(Composite)    { this->Append(intconicurv,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconicurv); }
-       }
-       break;
+    case GeomAbs_Parabola:
+      {
+        intconiconi.SetReversedParameters(Standard_True);
+        intconiconi.Perform(TheCurveTool::Parabola(C2),D2,
+          TheCurveTool::Hyperbola(C1),D1,TolConf,Tol);
+        if(Composite)    { this->Append(intconiconi,
+          param1inf,
+          param1sup,
+          param2inf,
+          param2sup);  }
+        else             { this->SetValues(intconiconi); }
       }
-    break;
+      break;
 
+    case GeomAbs_Hyperbola:
+      {
+        intconiconi.SetReversedParameters(Standard_False);
+        intconiconi.Perform(TheCurveTool::Hyperbola(C1),D1,
+          TheCurveTool::Hyperbola(C2),D2,
+          TolConf,Tol);
+        if(Composite)    { this->Append(intconiconi,
+          param1inf,
+          param1sup,
+          param2inf,
+          param2sup);  }
+        else             { this->SetValues(intconiconi); }
+      }
+      break;
 
     case GeomAbs_BezierCurve:
     case GeomAbs_BSplineCurve:
     case GeomAbs_OtherCurve:
-      
-      switch (typ2) {
-       
-      case GeomAbs_Line:
-       {
-         intconicurv.SetReversedParameters(Standard_True);
-         intconicurv.Perform(TheCurveTool::Line(C2),D2,  C1,D1,TolConf,Tol);
-         if(Composite)    { this->Append(intconicurv,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconicurv); }
-       }
-       break;
+      {
+        intconicurv.SetReversedParameters(Standard_False);
+        intconicurv.Perform(TheCurveTool::Hyperbola(C1),D1,
+          C2,D2,TolConf,Tol);
+        if(Composite)    { this->Append(intconicurv,
+          param1inf,
+          param1sup,
+          param2inf,
+          param2sup);  }
+        else             { this->SetValues(intconicurv); }
+      }
+      break;
+    }
+    break;
 
-      case GeomAbs_Circle:
-       {
-         intconicurv.SetReversedParameters(Standard_True);
-         intconicurv.Perform(TheCurveTool::Circle(C2),D2, C1,D1,TolConf,Tol);
-         if(Composite)    { this->Append(intconicurv,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconicurv); }
-       }
-       break;
+  case GeomAbs_BezierCurve:
+  case GeomAbs_BSplineCurve:
+  case GeomAbs_OtherCurve:
+    switch (typ2)
+    {
+    case GeomAbs_Line:
+      {
+        intconicurv.SetReversedParameters(Standard_True);
+        intconicurv.Perform(TheCurveTool::Line(C2),D2,  C1,D1,TolConf,Tol);
+        if(Composite)
+        {
+          this->Append(intconicurv,
+            param1inf,
+            param1sup,
+            param2inf,
+            param2sup);
+        }
+        else
+        {
+          this->SetValues(intconicurv);
+        }
+      }
+      break;
 
-      case GeomAbs_Ellipse:
-       {
-         intconicurv.SetReversedParameters(Standard_True);
-         intconicurv.Perform(TheCurveTool::Ellipse(C2),D2, C1,D1,TolConf,Tol);
-         if(Composite)    { this->Append(intconicurv,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconicurv); }
-       }
-       break;
+    case GeomAbs_Circle:
+      {
+        intconicurv.SetReversedParameters(Standard_True);
+        intconicurv.Perform(TheCurveTool::Circle(C2),D2, C1,D1,TolConf,Tol);
+        if(Composite)
+        {
+          this->Append(intconicurv,
+            param1inf,
+            param1sup,
+            param2inf,
+            param2sup);
+        }
+        else
+        {
+          this->SetValues(intconicurv);
+        }
+      }
+      break;
 
-      case GeomAbs_Parabola:
-       {
-         intconicurv.SetReversedParameters(Standard_True);
-         intconicurv.Perform(TheCurveTool::Parabola(C2),D2,C1,D1,TolConf,Tol);
-         if(Composite)    { this->Append(intconicurv,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconicurv); }
-       }
-       break;
+    case GeomAbs_Ellipse:
+      {
+        intconicurv.SetReversedParameters(Standard_True);
+        intconicurv.Perform(TheCurveTool::Ellipse(C2),D2, C1,D1,TolConf,Tol);
+        if(Composite)
+        {
+          this->Append(intconicurv,
+            param1inf,
+            param1sup,
+            param2inf,
+            param2sup);
+        }
+        else
+        {
+          this->SetValues(intconicurv);
+        }
+      }
+      break;
 
-      case GeomAbs_Hyperbola:
-       {
-         intconicurv.SetReversedParameters(Standard_True);
-         intconicurv.Perform(TheCurveTool::Hyperbola(C2),D2,C1,D1,
-                             TolConf,Tol); 
-         if(Composite)    { this->Append(intconicurv,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intconicurv); }
-       }
-       break;
+    case GeomAbs_Parabola:
+      {
+        intconicurv.SetReversedParameters(Standard_True);
+        intconicurv.Perform(TheCurveTool::Parabola(C2),D2,C1,D1,TolConf,Tol);
+        if(Composite)
+        {
+          this->Append(intconicurv,
+            param1inf,
+            param1sup,
+            param2inf,
+            param2sup);
+        }
+        else
+        {
+          this->SetValues(intconicurv);
+        }
+      }
+      break;
 
-      case GeomAbs_BezierCurve:
-      case GeomAbs_BSplineCurve:
-      case GeomAbs_OtherCurve:
-       {
-         intcurvcurv.SetReversedParameters(Standard_False);    
-         intcurvcurv.Perform(C1,D1, C2,D2,TolConf,Tol);
-         if(Composite)    { this->Append(intcurvcurv,
-                                         param1inf,
-                                         param1sup,
-                                         param2inf,
-                                         param2sup);  }
-         else             { this->SetValues(intcurvcurv); }
-         done = Standard_True;
-       }
-       break;
+    case GeomAbs_Hyperbola:
+      {
+        intconicurv.SetReversedParameters(Standard_True);
+        intconicurv.Perform(TheCurveTool::Hyperbola(C2),D2,C1,D1,
+          TolConf,Tol); 
+        if(Composite)
+        {
+          this->Append(intconicurv,
+            param1inf,
+            param1sup,
+            param2inf,
+            param2sup);
+        }
+        else
+        {
+          this->SetValues(intconicurv);
+        }
+      }
+      break;
+
+    case GeomAbs_BezierCurve:
+    case GeomAbs_BSplineCurve:
+    case GeomAbs_OtherCurve:
+      {
+        intcurvcurv.SetReversedParameters(Standard_False);    
+        intcurvcurv.Perform(C1,D1, C2,D2,TolConf,Tol);
+        if(Composite)
+        {
+          this->Append(intcurvcurv,
+            param1inf,
+            param1sup,
+            param2inf,
+            param2sup);  }
+        else
+        {
+          this->SetValues(intcurvcurv);
+        }
+        done = Standard_True;
       }
       break;
     }
+    break;
   }
 }
 

diff --git a/src/QABugs/QABugs_19.cxx b/src/QABugs/QABugs_19.cxx
index 88861205332d0fa88e06a83acf1183f051bdc76f..110efd98f07d2047e46416c50078b012ad696933 100755 (executable)
--- a/src/QABugs/QABugs_19.cxx
+++ b/src/QABugs/QABugs_19.cxx
@@ -2268,6 +2268,59 @@ static Standard_Integer OCC24834 (Draw_Interpretor& di, Standard_Integer n, cons
   return 0;
 }
 
+
+#include <Geom2dAPI_InterCurveCurve.hxx>
+#include <IntRes2d_IntersectionPoint.hxx>
+//=======================================================================
+//function : OCC24889
+//purpose  : 
+//=======================================================================
+static Standard_Integer OCC24889 (Draw_Interpretor& theDI,
+                                  Standard_Integer /*theNArg*/,
+                                  const char** /*theArgs*/)
+{
+ // Curves
+  Handle( Geom2d_Circle ) aCircle1 = new Geom2d_Circle(
+    gp_Ax22d( gp_Pnt2d( 25, -25 ), gp_Dir2d( 1, 0 ), gp_Dir2d( -0, 1 ) ), 155 );
+
+  Handle( Geom2d_Circle ) aCircle2 = new Geom2d_Circle(
+    gp_Ax22d( gp_Pnt2d( 25, 25 ), gp_Dir2d( 1, 0 ), gp_Dir2d( -0, 1 ) ), 155 );
+
+  Handle( Geom2d_TrimmedCurve ) aTrim[2] = {
+    new Geom2d_TrimmedCurve( aCircle1, 1.57079632679490, 2.97959469729228 ),
+    new Geom2d_TrimmedCurve( aCircle2, 3.30359060633978, 4.71238898038469 )
+  };
+
+  DrawTrSurf::Set("c_1", aTrim[0]);
+  DrawTrSurf::Set("c_2", aTrim[1]);
+
+  // Intersection
+  const Standard_Real aTol = Precision::Confusion();
+  Geom2dAPI_InterCurveCurve aIntTool( aTrim[0], aTrim[1], aTol );
+
+  const IntRes2d_IntersectionPoint& aIntPnt =
+    aIntTool.Intersector().Point( 1 );
+
+  gp_Pnt2d aIntRes = aIntTool.Point( 1 );
+  Standard_Real aPar[2] = {
+    aIntPnt.ParamOnFirst(),
+    aIntPnt.ParamOnSecond()
+  };
+
+  //theDI.precision( 5 );
+  theDI << "Int point: X = " << aIntRes.X() << "; Y = " << aIntRes.Y() << "\n";
+  for (int i = 0; i < 2; ++i)
+  {
+    theDI << "Curve " << i << ": FirstParam = " << aTrim[i]->FirstParameter() <<
+      "; LastParam = " << aTrim[i]->LastParameter() <<
+      "; IntParameter = " << aPar[i] << "\n";
+  }
+
+  return 0;
+}
+
+
+
 void QABugs::Commands_19(Draw_Interpretor& theCommands) {
   const char *group = "QABugs";
 
@@ -2309,6 +2362,7 @@ void QABugs::Commands_19(Draw_Interpretor& theCommands) {
   theCommands.Add ("OCC24565", "OCC24565 FileNameIGS FileNameSTOR", __FILE__, OCC24565, group);
   theCommands.Add ("OCC24755", "OCC24755", __FILE__, OCC24755, group);
   theCommands.Add ("OCC24834", "OCC24834", __FILE__, OCC24834, group);
+  theCommands.Add ("OCC24889", "OCC24889", __FILE__, OCC24889, group);
   theCommands.Add ("OCC23951", "OCC23951", __FILE__, OCC23951, group);
   theCommands.Add ("OCC24931", "OCC24931", __FILE__, OCC24931, group);
   return;

diff --git a/tests/bugs/modalg_5/bug24889 b/tests/bugs/modalg_5/bug24889
new file mode 100644 (file)
index 0000000..86850df
--- /dev/null
+++ b/tests/bugs/modalg_5/bug24889
@@ -0,0 +1,38 @@
+puts "=========="
+puts "OCC24889"
+puts "=========="
+puts ""
+#####################################################################################
+# Geom2dAPI_InterCurveCurve produces result with parameter outside the curve limits
+#####################################################################################
+
+pload QAcommands
+
+set info [OCC24889]
+regexp {Curve 0: +FirstParam += +([-0-9.+eE]+); +LastParam += +([-0-9.+eE]+); +IntParameter += +([-0-9.+eE]+)} $info full first1 last1 intp1
+regexp {Curve 1: +FirstParam += +([-0-9.+eE]+); +LastParam += +([-0-9.+eE]+); +IntParameter += +([-0-9.+eE]+)} $info full first2 last2 intp2
+
+if { $intp1 >= $first1 && $intp1 <= $last1 } {
+  puts "OK: IntParameter1 inside the curve limits"
+} else {
+  puts "Error: IntParameter1 outside the curve limits"
+}
+
+if { $intp2 >= $first2 && $intp2 <= $last2 } {
+  puts "OK: IntParameter2 inside the curve limits"
+} else {
+  puts "Error: IntParameter2 outside the curve limits"
+}
+
+2dcvalue c_1 $intp1 xx1 yy1
+2dcvalue c_2 $intp2 xx2 yy2
+
+dump xx1 yy1
+dump xx2 yy2
+
+set dist_val [dval (xx1-xx2)*(xx1-xx2)+(yy1-yy2)*(yy1-yy2)]
+if { $dist_val < 1.0e-14 } {
+  puts "OK: point distance is good"
+} else {
+  puts "Error: point distance is wrong"
+}