src/BRepExtrema/BRepExtrema_DistanceSS.cxx

   1 // Created on: 1996-04-22
   2 // Created by: Herve LOUESSARD
   3 // Copyright (c) 1996-1999 Matra Datavision
   4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   5 //
   6 // This file is part of Open CASCADE Technology software library.
   7 //
   8 // This library is free software; you can redistribute it and/or modify it under
   9 // the terms of the GNU Lesser General Public License version 2.1 as published
  10 // by the Free Software Foundation, with special exception defined in the file
  11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  12 // distribution for complete text of the license and disclaimer of any warranty.
  13 //
  14 // Alternatively, this file may be used under the terms of Open CASCADE
  15 // commercial license or contractual agreement.
  16
  17 // Modified: Sergey ZERCHANINOV
  18
  19 #include <BRepExtrema_DistanceSS.hxx>
  20
  21 #include <TopTools_IndexedMapOfShape.hxx>
  22 #include <TopExp.hxx>
  23 #include <gp_Pnt.hxx>
  24 #include <gp_Pnt2d.hxx>
  25 #include <BRep_Tool.hxx>
  26 #include <BRepExtrema_SupportType.hxx>
  27 #include <Standard_Real.hxx>
  28 #include <BRepExtrema_SolutionElem.hxx>
  29 #include <BRepExtrema_SeqOfSolution.hxx>
  30 #include <Standard_Boolean.hxx>
  31 #include <Standard_Integer.hxx>
  32 #include <TopAbs_ShapeEnum.hxx>
  33 #include <TopoDS.hxx>
  34 #include <Bnd_Box.hxx>
  35 #include <BRepExtrema_ExtPC.hxx>
  36 #include <BRepExtrema_ExtPF.hxx>
  37 #include <Extrema_ExtFlag.hxx>
  38 #include <BRepExtrema_ExtCC.hxx>
  39 #include <BRepExtrema_ExtCF.hxx>
  40 #include <BRepExtrema_ExtFF.hxx>
  41 #include <BRepClass_FaceClassifier.hxx>
  42 #include <TopAbs.hxx>
  43 #include <Geom_Curve.hxx>
  44 #include <GeomAbs_Shape.hxx>
  45 #include <GeomAdaptor_Curve.hxx>
  46 #include <TColStd_Array1OfReal.hxx>
  47 #include <BRepBuilderAPI_MakeVertex.hxx>
  48 #include <BRepBuilderAPI_MakeEdge.hxx>
  49 #include <BRepBuilderAPI_MakeFace.hxx>
  50 #include <Geom_Surface.hxx>
  51 #include <GeomAPI_ProjectPointOnSurf.hxx>
  52 #include <GeomAPI_ProjectPointOnCurve.hxx>
  53 #include <Geom_RectangularTrimmedSurface.hxx>
  54 #include <Geom_TrimmedCurve.hxx>
  55 #include <BRepBndLib.hxx>
  56 #include <BRepTools.hxx>
  57 #include <TColgp_Array1OfPnt.hxx>
  58
  59
  60 /*********************************************************************************/
  61
  62 //------------------------------------------------------------------------------
  63 // function: TRI_SOLUTION
  64 //------------------------------------------------------------------------------
  65 static Standard_Boolean TRI_SOLUTION (const BRepExtrema_SeqOfSolution& SeqSol, const gp_Pnt& Pt)
  66 {
  67   const Standard_Integer Nbsol = SeqSol.Length();
  68   for (Standard_Integer i = 1; i <= Nbsol; i++)
  69   {
  70     const Standard_Real dst = SeqSol.Value(i).Point().Distance(Pt);
  71     if (dst <= Precision::Confusion()) return Standard_False;
  72   }
  73   return Standard_True;
  74 }
  75
  76 //------------------------------------------------------------------------------
  77 // function: MIN_SOLUTION
  78 //------------------------------------------------------------------------------
  79 static void MIN_SOLUTION (const BRepExtrema_SeqOfSolution& SeqSol1,
  80                           const BRepExtrema_SeqOfSolution& SeqSol2,
  81                           const Standard_Real DstRef,
  82                           const Standard_Real Eps,
  83                           BRepExtrema_SeqOfSolution& seqSol1,
  84                           BRepExtrema_SeqOfSolution& seqSol2)
  85 {
  86   const Standard_Integer nbSol = SeqSol1.Length();
  87   for (Standard_Integer i = 1; i <= nbSol; i++)
  88   {
  89     const Standard_Real dst1 = SeqSol1.Value(i).Dist();
  90     if (fabs(dst1 - DstRef) < Eps)
  91         {
  92       seqSol1.Append(SeqSol1.Value(i));
  93       seqSol2.Append(SeqSol2.Value(i));
  94         }
  95   }
  96 }
  97
  98 //------------------------------------------------------------------------------
  99 // function: TRIM_INFINIT_EDGE
 100 //------------------------------------------------------------------------------
 101 static void TRIM_INFINIT_EDGE(const TopoDS_Edge& S1, const TopoDS_Edge& S2, TopoDS_Edge& aResEdge,
 102                               Standard_Boolean& bIsTrim1, Standard_Boolean& bIsTrim2)
 103 {
 104   if ( BRep_Tool::Degenerated(S1) || BRep_Tool::Degenerated(S2) )
 105     return;
 106
 107   aResEdge = S2;
 108   Standard_Real aFirst1, aLast1, aFirst2, aLast2;
 109   Handle(Geom_Curve) pCurv1 = BRep_Tool::Curve(S1, aFirst1, aLast1);
 110   Handle(Geom_Curve) pCurv2 = BRep_Tool::Curve(S2, aFirst2, aLast2);
 111
 112   if (Precision::IsInfinite(aFirst1) &&
 113       Precision::IsInfinite(aLast1)  &&
 114       Precision::IsInfinite(aFirst2) &&
 115       Precision::IsInfinite(aLast2))
 116     return;
 117
 118   Standard_Real Umin = 0., Umax = 0.;
 119   Standard_Boolean bUmin, bUmax;
 120   bUmin = bUmax = Standard_False;
 121
 122   Handle(Geom_Curve) pCurv;
 123   if ( !pCurv1.IsNull() && (Precision::IsInfinite(aFirst1) || Precision::IsInfinite(aLast1)) )
 124   {
 125     pCurv = pCurv1;
 126     bIsTrim1 = Standard_True;
 127     if (!Precision::IsInfinite(aFirst1))
 128     {
 129       bUmin = Standard_True;
 130       Umin = aFirst1;
 131     }
 132     else if (!Precision::IsInfinite(aLast1))
 133     {
 134       bUmax = Standard_True;
 135       Umax = aLast1;
 136     }
 137   }
 138   else if ( !pCurv2.IsNull() && (Precision::IsInfinite(aFirst2) || Precision::IsInfinite(aLast2)) )
 139   {
 140     pCurv = pCurv2;
 141     bIsTrim2 = Standard_True;
 142     if (!Precision::IsInfinite(aFirst2))
 143     {
 144       bUmin = Standard_True;
 145       Umin = aFirst2;
 146     }
 147     else if (!Precision::IsInfinite(aLast2))
 148     {
 149       bUmax = Standard_True;
 150       Umax = aLast2;
 151     }
 152   }
 153   if (bIsTrim1 || bIsTrim2)
 154   {
 155     Bnd_Box aEdgeBox;
 156     if (bIsTrim1)
 157       BRepBndLib::Add(S2, aEdgeBox);
 158     if (bIsTrim2)
 159       BRepBndLib::Add(S1, aEdgeBox);
 160     Standard_Real Xmin, Ymin, Zmin, Xmax, Ymax, Zmax;
 161     aEdgeBox.Get(Xmin, Ymin, Zmin, Xmax, Ymax, Zmax);
 162
 163     const gp_Pnt aPnt0(Xmin, Ymin, Zmin);
 164     const gp_Pnt aPnt1(Xmin, Ymax, Zmin);
 165     const gp_Pnt aPnt2(Xmin, Ymax, Zmax);
 166     const gp_Pnt aPnt3(Xmin, Ymin, Zmax);
 167     const gp_Pnt aPnt4(Xmax, Ymax, Zmin);
 168     const gp_Pnt aPnt5(Xmax, Ymax, Zmax);
 169     const gp_Pnt aPnt6(Xmax, Ymin, Zmax);
 170     const gp_Pnt aPnt7(Xmax, Ymin, Zmin);
 171
 172         Standard_Real arrU[8];
 173     GeomAPI_ProjectPointOnCurve aProj(aPnt0, pCurv);
 174     /*szv:aProj.Perform(aPnt0);*/ arrU[0] = aProj.LowerDistanceParameter();
 175     aProj.Perform(aPnt1); arrU[1] = aProj.LowerDistanceParameter();
 176     aProj.Perform(aPnt2); arrU[2] = aProj.LowerDistanceParameter();
 177     aProj.Perform(aPnt3); arrU[3] = aProj.LowerDistanceParameter();
 178     aProj.Perform(aPnt4); arrU[4] = aProj.LowerDistanceParameter();
 179     aProj.Perform(aPnt5); arrU[5] = aProj.LowerDistanceParameter();
 180     aProj.Perform(aPnt6); arrU[6] = aProj.LowerDistanceParameter();
 181     aProj.Perform(aPnt7); arrU[7] = aProj.LowerDistanceParameter();
 182
 183     if (!bUmin)
 184       Umin = arrU[0];
 185
 186     if (!bUmax)
 187       Umax = arrU[0];
 188
 189     Standard_Integer i = 0;
 190     while (i < 8)
 191         {
 192       const Standard_Real aU = arrU[i++];
 193           if (aU < Umin)
 194             Umin = aU;
 195           else if (aU > Umax)
 196             Umax = aU;
 197         }
 198
 199     Standard_Real tol = Precision::Confusion();
 200     if (bIsTrim1)
 201       tol = BRep_Tool::Tolerance(S1);
 202     else if (bIsTrim2)
 203       tol = BRep_Tool::Tolerance(S2);
 204
 205     const Standard_Real EpsU = GeomAdaptor_Curve(pCurv).Resolution(3.*tol);
 206     if (fabs(Umin - Umax) < EpsU)
 207     {
 208       Umin -= EpsU;
 209       Umax += EpsU;
 210     }
 211
 212     Handle(Geom_Curve) result = new Geom_TrimmedCurve(pCurv, Umin, Umax);
 213     aResEdge = BRepBuilderAPI_MakeEdge(result);
 214   }
 215 }
 216
 217 //------------------------------------------------------------------------------
 218 // function: TRIM_INFINIT_FACE
 219 //------------------------------------------------------------------------------
 220 static void TRIM_INFINIT_FACE(const TopoDS_Shape& S1, const TopoDS_Shape& S2,
 221                               TopoDS_Face& aResFace, Standard_Boolean& bIsInfinit)
 222 {
 223   bIsInfinit = Standard_False;
 224
 225   TopAbs_ShapeEnum Type1 = S1.ShapeType();
 226   TopAbs_ShapeEnum Type2 = S2.ShapeType();
 227
 228   TopoDS_Edge aE;
 229   TopoDS_Face aF;
 230
 231   if (Type1 == TopAbs_EDGE && Type2 == TopAbs_FACE)
 232   {
 233     aE = TopoDS::Edge(S1);
 234     if ( BRep_Tool::Degenerated(aE) )
 235       return;
 236     aF = TopoDS::Face(S2);
 237   }
 238   else if (Type2 == TopAbs_EDGE && Type1 == TopAbs_FACE)
 239   {
 240     aE = TopoDS::Edge(S2);
 241     if ( BRep_Tool::Degenerated(aE) )
 242       return;
 243     aF = TopoDS::Face(S1);
 244   }
 245   else
 246   {
 247     bIsInfinit = Standard_False;
 248     return;
 249   }
 250
 251   aResFace = aF;
 252   Handle(Geom_Surface) pSurf = BRep_Tool::Surface(aF);
 253
 254   const Standard_Boolean bRestrict = BRep_Tool::NaturalRestriction(aF);
 255
 256   Standard_Real U1, V1, U2, V2;
 257   Standard_Real Umin = RealLast(), Umax = RealFirst(), Vmin = RealLast(), Vmax = RealFirst();
 258   Standard_Boolean bUmin, bUmax, bVmin, bVmax;
 259   bUmin = bUmax = bVmin = bVmax = Standard_False;
 260   Standard_Boolean bIsTrim = Standard_False;
 261
 262   if (bRestrict)
 263   {
 264     pSurf->Bounds(U1, U2, V1, V2);
 265     if (Precision::IsInfinite(U1))
 266       bIsTrim = Standard_True;
 267     else
 268     {
 269       Umin = U1;
 270       bUmin = Standard_True;
 271     }
 272
 273     if (Precision::IsInfinite(U2))
 274       bIsTrim = Standard_True;
 275     else
 276     {
 277       Umax = U2;
 278       bUmax = Standard_True;
 279     }
 280
 281     if (Precision::IsInfinite(V1))
 282       bIsTrim = Standard_True;
 283     else
 284         {
 285       Vmin = V1;
 286       bVmin = Standard_True;
 287         }
 288
 289     if (Precision::IsInfinite(V2))
 290       bIsTrim = Standard_True;
 291     else
 292         {
 293       Vmax = V2;
 294       bVmax = Standard_True;
 295     }
 296   }
 297   else
 298   {
 299     BRepTools::UVBounds(aF, U1, U2, V1, V2);
 300     if (Precision::IsInfinite(U1) &&
 301         Precision::IsInfinite(U2) &&
 302         Precision::IsInfinite(V1) &&
 303         Precision::IsInfinite(V2))
 304       bIsTrim = Standard_True;
 305   }
 306
 307   if (bIsTrim)
 308   {
 309     Bnd_Box aEdgeBox;
 310     BRepBndLib::Add(aE, aEdgeBox);
 311
 312     if(aEdgeBox.IsWhole())
 313       return;
 314
 315     Standard_Real Xmin, Ymin, Zmin, Xmax, Ymax, Zmax;
 316     aEdgeBox.Get(Xmin, Ymin, Zmin, Xmax, Ymax, Zmax);
 317
 318     const gp_Pnt aPnt0(Xmin, Ymin, Zmin);
 319     const gp_Pnt aPnt1(Xmin, Ymax, Zmin);
 320     const gp_Pnt aPnt2(Xmin, Ymax, Zmax);
 321     const gp_Pnt aPnt3(Xmin, Ymin, Zmax);
 322     const gp_Pnt aPnt4(Xmax, Ymax, Zmin);
 323     const gp_Pnt aPnt5(Xmax, Ymax, Zmax);
 324     const gp_Pnt aPnt6(Xmax, Ymin, Zmax);
 325     const gp_Pnt aPnt7(Xmax, Ymin, Zmin);
 326
 327     Standard_Real arrU[8], arrV[8];
 328     GeomAPI_ProjectPointOnSurf aProj(aPnt0, pSurf);
 329     /*szv:aProj.Perform(aPnt0);*/ if (aProj.IsDone()) aProj.LowerDistanceParameters(arrU[0],arrV[0]);
 330     aProj.Perform(aPnt1); if (aProj.IsDone()) aProj.LowerDistanceParameters(arrU[1],arrV[1]);
 331     aProj.Perform(aPnt2); if (aProj.IsDone()) aProj.LowerDistanceParameters(arrU[2],arrV[2]);
 332     aProj.Perform(aPnt3); if (aProj.IsDone()) aProj.LowerDistanceParameters(arrU[3],arrV[3]);
 333     aProj.Perform(aPnt4); if (aProj.IsDone()) aProj.LowerDistanceParameters(arrU[4],arrV[4]);
 334     aProj.Perform(aPnt5); if (aProj.IsDone()) aProj.LowerDistanceParameters(arrU[5],arrV[5]);
 335     aProj.Perform(aPnt6); if (aProj.IsDone()) aProj.LowerDistanceParameters(arrU[6],arrV[6]);
 336     aProj.Perform(aPnt7); if (aProj.IsDone()) aProj.LowerDistanceParameters(arrU[7],arrV[7]);
 337
 338     if (!bUmin)
 339       Umin = arrU[0];
 340     if (!bUmax)
 341       Umax = arrU[0];
 342     if (!bVmin)
 343       Vmin = arrV[0];
 344     if (!bVmax)
 345       Vmax = arrV[0];
 346
 347     Standard_Integer i = 0;
 348     while (i < 8)
 349         {
 350       const Standard_Real aU = arrU[i];
 351           if (aU < Umin)
 352             Umin = aU;
 353           else if (aU > Umax)
 354             Umax = aU;
 355
 356       const Standard_Real aV = arrV[i];
 357           if (aV < Vmin)
 358             Vmin = aV;
 359           else if (aV > Vmax)
 360             Vmax = aV;
 361
 362       i++;
 363         }
 364
 365     GeomAdaptor_Surface aGAS(pSurf);
 366     const Standard_Real tol = BRep_Tool::Tolerance(aF);
 367
 368     const Standard_Real EpsU = aGAS.UResolution(3.*tol);
 369     if (fabs(Umin - Umax) < EpsU)
 370     {
 371       Umin -= EpsU;
 372       Umax += EpsU;
 373     }
 374
 375     const Standard_Real EpsV = aGAS.VResolution(3.*tol);
 376     if (fabs(Vmin - Vmax) < EpsV)
 377     {
 378       Vmin -= EpsV;
 379       Vmax += EpsV;
 380     }
 381
 382     Handle(Geom_Surface) result = new Geom_RectangularTrimmedSurface(pSurf, Umin, Umax, Vmin, Vmax);
 383     aResFace = BRepBuilderAPI_MakeFace(result, Precision::Confusion());
 384
 385     bIsInfinit = Standard_True;
 386   }
 387   else
 388     bIsInfinit = Standard_False;
 389 }
 390
 391 //------------------------------------------------------------------------------
 392 // static function: PERFORM_C0
 393 //------------------------------------------------------------------------------
 394 static void PERFORM_C0(const TopoDS_Edge &S1, const TopoDS_Edge &S2,
 395                        BRepExtrema_SeqOfSolution& SeqSol1,
 396                        BRepExtrema_SeqOfSolution& SeqSol2,
 397                        const Standard_Real DstRef,
 398                        Standard_Real& mDstRef,
 399                        const Standard_Real Eps)
 400 {
 401   if ( BRep_Tool::Degenerated(S1) || BRep_Tool::Degenerated(S2) )
 402     return;
 403
 404   Standard_Integer iE;
 405   for (iE = 0; iE < 2; iE++)
 406   {
 407     TopoDS_Edge E, Eother;
 408     if (iE == 0)
 409         {
 410           E      = S1;
 411           Eother = S2;
 412         }
 413     else
 414         {
 415           E      = S2;
 416           Eother = S1;
 417         }
 418
 419     Standard_Real aFirst, aLast;
 420     Handle(Geom_Curve) pCurv = BRep_Tool::Curve(E, aFirst, aLast);
 421
 422     Standard_Real aFOther, aLOther;
 423     Handle(Geom_Curve) pCurvOther = BRep_Tool::Curve(Eother, aFOther, aLOther);
 424
 425     if (pCurv->Continuity() == GeomAbs_C0)
 426         {
 427       const Standard_Real epsP = Precision::PConfusion();
 428
 429       GeomAdaptor_Curve aAdaptorCurve(pCurv, aFirst, aLast);
 430       const Standard_Integer nbIntervals = aAdaptorCurve.NbIntervals(GeomAbs_C1);
 431
 432       TColStd_Array1OfReal arrInter(1,1+nbIntervals);
 433       aAdaptorCurve.Intervals(arrInter, GeomAbs_C1);
 434
 435       GeomAdaptor_Curve aAdaptorCurveOther(pCurvOther, aFOther, aLOther);
 436       const Standard_Integer nbIntervalsOther = aAdaptorCurveOther.NbIntervals(GeomAbs_C1);
 437       TColStd_Array1OfReal arrInterOther(1,1+nbIntervalsOther);
 438       aAdaptorCurveOther.Intervals(arrInterOther, GeomAbs_C1);
 439
 440       Standard_Real Udeb,Ufin;
 441       BRep_Tool::Range(Eother,Udeb,Ufin);
 442
 443       gp_Pnt P1,Pt;
 444       Standard_Integer i, ii;
 445       BRepClass_FaceClassifier classifier;
 446       for (i = 1; i <= arrInter.Length(); i++)
 447       {
 448         const Standard_Real aParameter = arrInter(i);
 449         const gp_Pnt aPnt = aAdaptorCurve.Value(aParameter);
 450         const TopoDS_Vertex V1 = BRepBuilderAPI_MakeVertex(aPnt);
 451
 452         BRepExtrema_ExtPC Ext(V1,Eother);
 453         const Standard_Integer NbExtrema = Ext.IsDone()? Ext.NbExt() : 0;
 454         if ( NbExtrema > 0 )
 455                 {
 456           // Search minimum distance dstmin
 457           Standard_Real Dstmin = Ext.SquareDistance(1);
 458           for (ii = 2; ii <= NbExtrema; ii++)
 459           {
 460             const Standard_Real sDst = Ext.SquareDistance(ii);
 461             if (sDst<Dstmin)
 462               Dstmin=sDst;
 463           }
 464           Dstmin = sqrt(Dstmin);
 465
 466           if ((Dstmin < DstRef - Eps) || (fabs(Dstmin-DstRef) < Eps))
 467             for (ii = 1; ii <= NbExtrema; ii++)
 468             {
 469               if (fabs(Dstmin-sqrt(Ext.SquareDistance(ii)))<Eps)
 470               {
 471                 Pt=Ext.Point(ii);
 472                 if (TRI_SOLUTION(SeqSol2,Pt))
 473                 {
 474                   // Check if the parameter does not correspond to a vertex
 475                   const Standard_Real t = Ext.Parameter(ii);
 476                   if ((fabs(t-Udeb)>=epsP)&&(fabs(t-Ufin)>epsP))
 477                   {
 478                     if (mDstRef > Dstmin)
 479                       mDstRef=Dstmin;
 480                     const BRepExtrema_SolutionElem Sol1(Dstmin,aPnt,BRepExtrema_IsOnEdge,E,aParameter);
 481                     const BRepExtrema_SolutionElem Sol2(Dstmin,Pt,BRepExtrema_IsOnEdge,Eother,t);
 482                     SeqSol1.Append(iE == 0 ? Sol1 : Sol2);
 483                     SeqSol2.Append(iE == 0 ? Sol2 : Sol1);
 484                   }
 485                 }
 486               }
 487             }
 488         }
 489         for (Standard_Integer i2 = 1; i2<=arrInterOther.Length(); i2++)
 490         {
 491           const Standard_Real aParameterOther = arrInterOther(i2);
 492           const gp_Pnt aPntOther = aAdaptorCurveOther.Value(aParameterOther);
 493           const Standard_Real Dst = aPnt.Distance(aPntOther);
 494           if ((Dst < DstRef - Eps) || (fabs(Dst-DstRef) < Eps))
 495           {
 496             if (mDstRef > Dst)
 497               mDstRef=Dst;
 498             const BRepExtrema_SolutionElem Sol1(Dst,aPnt,BRepExtrema_IsOnEdge,E,aParameter);
 499             const BRepExtrema_SolutionElem Sol2(Dst,aPntOther,BRepExtrema_IsOnEdge,Eother,aParameterOther);
 500             SeqSol1.Append(iE == 0 ? Sol1 : Sol2);
 501             SeqSol2.Append(iE == 0 ? Sol2 : Sol1);
 502           }
 503         }
 504       }
 505     }
 506   }
 507 }
 508
 509 /*********************************************************************************/
 510
 511 void BRepExtrema_DistanceSS::Perform(const TopoDS_Shape& S1, const TopoDS_Shape& S2,
 512                                      const Bnd_Box& B1, const Bnd_Box& B2)
 513 {
 514   SeqSolShape1.Clear();
 515   SeqSolShape2.Clear();
 516   myModif=Standard_False;
 517
 518   switch (S1.ShapeType())
 519   {
 520     case TopAbs_VERTEX :
 521     {
 522       TopoDS_Vertex V1 = TopoDS::Vertex(S1);
 523       switch (S2.ShapeType())
 524       {
 525         case TopAbs_VERTEX :
 526         {
 527           TopoDS_Vertex V2 = TopoDS::Vertex(S2);
 528           Perform( V1, V2 );
 529           break;
 530         }
 531         case TopAbs_EDGE :
 532         {
 533           TopoDS_Edge E2 = TopoDS::Edge(S2);
 534           Perform( V1, E2, B1, B2 );
 535           break;
 536         }
 537         case TopAbs_FACE :
 538         {
 539           TopoDS_Face F2 = TopoDS::Face(S2);
 540           Perform( V1, F2, B1, B2 );
 541           break;
 542         }
 543         default:
 544           break;
 545       }
 546       break;
 547     }
 548
 549     case TopAbs_EDGE :
 550     {
 551       TopoDS_Edge E1 = TopoDS::Edge(S1);
 552       switch (S2.ShapeType())
 553       {
 554         case TopAbs_VERTEX :
 555         {
 556           TopoDS_Vertex V2 = TopoDS::Vertex(S2);
 557           Perform( E1, V2, B1, B2 );
 558           break;
 559         }
 560         case TopAbs_EDGE :
 561         {
 562           TopoDS_Edge E2 = TopoDS::Edge(S2);
 563           TopoDS_Edge aTrimEdge;
 564           Standard_Boolean bIsTrim1 = Standard_False;
 565           Standard_Boolean bIsTrim2 = Standard_False;
 566           TRIM_INFINIT_EDGE( E1, E2, aTrimEdge, bIsTrim1, bIsTrim2 );
 567           if (bIsTrim1)
 568             E1 = aTrimEdge;
 569           if (bIsTrim2)
 570             E2 = aTrimEdge;
 571           Perform( E1, E2, B1, B2 );
 572           break;
 573         }
 574         case TopAbs_FACE :
 575         {
 576           TopoDS_Face F2 = TopoDS::Face(S2);
 577           TopoDS_Face aTrimFace;
 578           Standard_Boolean bIsInfinit;
 579           TRIM_INFINIT_FACE( E1, F2, aTrimFace, bIsInfinit );
 580           if (bIsInfinit)
 581             F2 = aTrimFace;
 582           Perform( E1, F2, B1, B2 );
 583           break;
 584         }
 585         default:
 586           break;
 587       }
 588       break;
 589     }
 590
 591     case TopAbs_FACE :
 592     {
 593       TopoDS_Face F1 = TopoDS::Face(S1);
 594       switch (S2.ShapeType())
 595       {
 596         case TopAbs_VERTEX :
 597         {
 598           TopoDS_Vertex V2 = TopoDS::Vertex(S2);
 599           Perform( F1, V2, B1, B2 );
 600           break;
 601         }
 602         case TopAbs_EDGE :
 603         {
 604           TopoDS_Edge E2 = TopoDS::Edge(S2);
 605           TopoDS_Face aTrimFace;
 606           Standard_Boolean bIsInfinit;
 607           TRIM_INFINIT_FACE( F1, E2, aTrimFace, bIsInfinit );
 608           if (bIsInfinit)
 609             F1 = aTrimFace;
 610           Perform( F1, E2, B1, B2 );
 611           break;
 612         }
 613         case TopAbs_FACE :
 614         {
 615           TopoDS_Face F2 = TopoDS::Face(S2);
 616           Perform( F1, F2, B1, B2 );
 617           break;
 618         }
 619         default:
 620           break;
 621       }
 622       break;
 623     }
 624     default:
 625       break;
 626   }
 627 }
 628
 629 /*********************************************************************************/
 630
 631 void BRepExtrema_DistanceSS::Perform(const TopoDS_Vertex& S1, const TopoDS_Vertex& S2)
 632 {
 633   const gp_Pnt P1 = BRep_Tool::Pnt(S1);
 634   const gp_Pnt P2 = BRep_Tool::Pnt(S2);
 635
 636   const Standard_Real Dst = P1.Distance(P2);
 637   if ((Dst < myDstRef - myEps) || (fabs(Dst-myDstRef) < myEps))
 638   {
 639     if (myDstRef > Dst)
 640       myDstRef=Dst;
 641     myModif=Standard_True;
 642     const BRepExtrema_SolutionElem Sol1(Dst,P1,BRepExtrema_IsVertex,S1);
 643     const BRepExtrema_SolutionElem Sol2(Dst,P2,BRepExtrema_IsVertex,S2);
 644     SeqSolShape1.Append(Sol1);
 645     SeqSolShape2.Append(Sol2);
 646   }
 647 }
 648
 649 /*********************************************************************************/
 650
 651 void BRepExtrema_DistanceSS::Perform(const TopoDS_Vertex& S1, const TopoDS_Edge& S2,
 652                                      const Bnd_Box& B1, const Bnd_Box& B2)
 653 {
 654   if (BRep_Tool::Degenerated(S2))
 655     return;
 656
 657   const Standard_Real Dst=B1.Distance(B2);
 658   if ((Dst < myDstRef - myEps) || (fabs(Dst-myDstRef) < myEps))
 659   {
 660     BRepExtrema_ExtPC Ext(S1,S2);
 661     const Standard_Integer NbExtrema = Ext.IsDone()? Ext.NbExt() : 0;
 662     if ( NbExtrema > 0 )
 663     {
 664       // Search minimum distance Dstmin
 665       Standard_Integer i;
 666       Standard_Real Dstmin = Ext.SquareDistance(1);
 667       for (i = 2; i <= NbExtrema; i++)
 668       {
 669         const Standard_Real sDst = Ext.SquareDistance(i);
 670         if (sDst<Dstmin)
 671           Dstmin=sDst;
 672           }
 673       Dstmin = sqrt(Dstmin);
 674       if ((Dstmin < myDstRef - myEps) || (fabs(Dstmin-myDstRef) < myEps))
 675       {
 676         Standard_Real Udeb,Ufin;
 677         BRep_Tool::Range(S2,Udeb,Ufin);
 678
 679         gp_Pnt Pt,P1=BRep_Tool::Pnt(S1);
 680         const Standard_Real epsP=Precision::PConfusion();
 681
 682         for (i = 1; i <= NbExtrema; i++)
 683         {
 684           if (fabs(Dstmin-sqrt(Ext.SquareDistance(i)))<myEps)
 685           {
 686             Pt=Ext.Point(i);
 687             if (TRI_SOLUTION(SeqSolShape2,Pt))
 688             {
 689               // Check if the parameter does not correspond to a vertex
 690               const Standard_Real t = Ext.Parameter(i);
 691               if ( (fabs(t-Udeb)>=epsP) && (fabs(t-Ufin)>epsP) )
 692               {
 693                 if (myDstRef > Dstmin)
 694                   myDstRef=Dstmin;
 695                 myModif=Standard_True;
 696                 const BRepExtrema_SolutionElem Sol1(Dstmin,P1,BRepExtrema_IsVertex,S1);
 697                 const BRepExtrema_SolutionElem Sol2(Dstmin,Pt,BRepExtrema_IsOnEdge,S2,t);
 698                 SeqSolShape1.Append(Sol1);
 699                 SeqSolShape2.Append(Sol2);
 700               }
 701             }
 702           }
 703         }
 704       }
 705     }
 706   }
 707 }
 708
 709 void BRepExtrema_DistanceSS::Perform(const TopoDS_Edge& S1,const TopoDS_Vertex& S2,
 710                                      const Bnd_Box& B1,const Bnd_Box& B2)
 711 {
 712   if (BRep_Tool::Degenerated(S1))
 713     return;
 714
 715   const Standard_Real Dst=B1.Distance(B2);
 716   if ((Dst < myDstRef - myEps) || (fabs(Dst-myDstRef) < myEps))
 717   {
 718     BRepExtrema_ExtPC Ext(S2,S1);
 719     const Standard_Integer NbExtrema = Ext.IsDone()? Ext.NbExt() : 0;
 720     if ( NbExtrema > 0 )
 721     {
 722       // Search minimum distance Dstmin
 723       Standard_Integer i;
 724       Standard_Real Dstmin = Ext.SquareDistance(1);
 725       for (i = 2; i <= NbExtrema; i++)
 726       {
 727         const Standard_Real sDst = Ext.SquareDistance(i);
 728         if (sDst<Dstmin)
 729           Dstmin=sDst;
 730           }
 731       Dstmin = sqrt(Dstmin);
 732       if ((Dstmin < myDstRef - myEps) || (fabs(Dstmin-myDstRef) < myEps))
 733       {
 734         Standard_Real Udeb,Ufin;
 735         BRep_Tool::Range(S1,Udeb,Ufin);
 736
 737         gp_Pnt Pt, P2 = BRep_Tool::Pnt(S2);
 738         const Standard_Real epsP=Precision::PConfusion();
 739
 740         for (i = 1; i <= NbExtrema; i++)
 741         {
 742           if (fabs(Dstmin-sqrt(Ext.SquareDistance(i)))<myEps)
 743           {
 744             Pt=Ext.Point(i);
 745             if (TRI_SOLUTION(SeqSolShape1,Pt))
 746             {
 747               // Check if the parameter does not correspond to a vertex
 748               const Standard_Real t = Ext.Parameter(i);
 749               if ( (fabs(t-Udeb)>=epsP) && (fabs(t-Ufin)>epsP) )
 750               {
 751                 if (myDstRef > Dstmin)
 752                   myDstRef=Dstmin;
 753                 myModif=Standard_True;
 754                 const BRepExtrema_SolutionElem Sol1(Dstmin,Pt,BRepExtrema_IsOnEdge,S1,t);
 755                 const BRepExtrema_SolutionElem Sol2(Dstmin,P2,BRepExtrema_IsVertex,S2);
 756                 SeqSolShape1.Append(Sol1);
 757                 SeqSolShape2.Append(Sol2);
 758               }
 759             }
 760           }
 761         }
 762       }
 763     }
 764   }
 765 }
 766
 767 /*********************************************************************************/
 768
 769 void BRepExtrema_DistanceSS::Perform(const TopoDS_Vertex& S1, const TopoDS_Face& S2,
 770                                      const Bnd_Box& B1, const Bnd_Box& B2)
 771 {
 772   const Standard_Real Dst=B1.Distance(B2);
 773   if ((Dst < myDstRef - myEps) || (fabs(Dst-myDstRef) < myEps))
 774   {
 775     BRepExtrema_ExtPF Ext(S1,S2,myFlag,myAlgo);
 776     const Standard_Integer NbExtrema = Ext.IsDone()? Ext.NbExt() : 0;
 777     if ( NbExtrema > 0 )
 778     {
 779       // Search minimum distance Dstmin
 780       Standard_Integer i;
 781       Standard_Real Dstmin = Ext.SquareDistance(1);
 782       for (i = 2; i <= NbExtrema; i++)
 783       {
 784         const Standard_Real sDst = Ext.SquareDistance(i);
 785         if (sDst<Dstmin)
 786           Dstmin=sDst;
 787       }
 788       Dstmin = sqrt(Dstmin);
 789       if ((Dstmin < myDstRef - myEps) || (fabs(Dstmin-myDstRef) < myEps))
 790       {
 791         Standard_Real U,V;
 792         gp_Pnt Pt,P1=BRep_Tool::Pnt(S1);
 793         BRepClass_FaceClassifier classifier;
 794         const Standard_Real tol = BRep_Tool::Tolerance(S2);
 795
 796         for (i = 1; i <= NbExtrema; i++)
 797         {
 798           if (fabs(Dstmin-sqrt(Ext.SquareDistance(i)))<myEps)
 799           {
 800             Pt=Ext.Point(i);
 801             if (TRI_SOLUTION(SeqSolShape2,Pt))
 802             {
 803               // Check if the parameter does not correspond to a vertex
 804               Ext.Parameter(i,U,V);
 805               const gp_Pnt2d PUV(U,V);
 806               classifier.Perform(S2,PUV,tol);
 807               if (classifier.State()==TopAbs_IN)
 808               {
 809                 if (myDstRef > Dstmin)
 810                   myDstRef=Dstmin;
 811                 myModif=Standard_True;
 812                 const BRepExtrema_SolutionElem Sol1(Dstmin,P1,BRepExtrema_IsVertex,S1);
 813                 const BRepExtrema_SolutionElem Sol2(Dstmin,Pt,BRepExtrema_IsInFace,S2,U,V);
 814                 SeqSolShape1.Append(Sol1);
 815                 SeqSolShape2.Append(Sol2);
 816               }
 817             }
 818           }
 819         }
 820       }
 821     }
 822   }
 823 }
 824
 825 void BRepExtrema_DistanceSS::Perform(const TopoDS_Face& S1, const TopoDS_Vertex& S2,
 826                                      const Bnd_Box& B1, const Bnd_Box& B2)
 827 {
 828   const Standard_Real Dst=B1.Distance(B2);
 829   if ((Dst < myDstRef - myEps) || (fabs(Dst-myDstRef) < myEps))
 830   {
 831     BRepExtrema_ExtPF Ext(S2,S1,myFlag,myAlgo);
 832     const Standard_Integer NbExtrema = Ext.IsDone()? Ext.NbExt() : 0;
 833     if ( NbExtrema > 0 )
 834     {
 835       // Search minimum distance Dstmin
 836       Standard_Integer i;
 837       Standard_Real Dstmin = Ext.SquareDistance(1);
 838       for (i = 2; i <= NbExtrema; i++)
 839       {
 840         const Standard_Real sDst = Ext.SquareDistance(i);
 841         if (sDst<Dstmin)
 842           Dstmin=sDst;
 843       }
 844       Dstmin = sqrt(Dstmin);
 845       if ((Dstmin < myDstRef - myEps) || (fabs(Dstmin-myDstRef) < myEps))
 846       {
 847         Standard_Real U,V;
 848         gp_Pnt Pt,P2=BRep_Tool::Pnt(S2);
 849         BRepClass_FaceClassifier classifier;
 850         const Standard_Real tol = BRep_Tool::Tolerance(S1);
 851
 852         for (i = 1; i <= NbExtrema; i++)
 853         {
 854           if (fabs(Dstmin-sqrt(Ext.SquareDistance(i)))<myEps)
 855           {
 856             Pt=Ext.Point(i);
 857             if (TRI_SOLUTION(SeqSolShape1,Pt))
 858             {
 859               // Check if the parameter does not correspond to a vertex
 860               Ext.Parameter(i,U,V);
 861               const gp_Pnt2d PUV(U,V);
 862               classifier.Perform(S1,PUV,tol);
 863               if (classifier.State()==TopAbs_IN)
 864               {
 865                 if (myDstRef > Dstmin)
 866                   myDstRef=Dstmin;
 867                 myModif=Standard_True;
 868                 const BRepExtrema_SolutionElem Sol1(Dstmin,Pt,BRepExtrema_IsInFace,S1,U,V);
 869                 const BRepExtrema_SolutionElem Sol2(Dstmin,P2,BRepExtrema_IsVertex,S2);
 870                 SeqSolShape1.Append(Sol1);
 871                 SeqSolShape2.Append(Sol2);
 872               }
 873             }
 874           }
 875         }
 876       }
 877     }
 878   }
 879 }
 880
 881 /*********************************************************************************/
 882
 883 void BRepExtrema_DistanceSS::Perform(const TopoDS_Edge& S1, const TopoDS_Edge& S2,
 884                                      const Bnd_Box& B1, const Bnd_Box& B2)
 885 {
 886   if (BRep_Tool::Degenerated(S1) || BRep_Tool::Degenerated(S2))
 887     return;
 888
 889   const Standard_Real Dst=B1.Distance(B2);
 890   if ((Dst < myDstRef - myEps) || (fabs(Dst-myDstRef) < myEps))
 891   {
 892     const Standard_Real DstRef = myDstRef;
 893
 894     BRepExtrema_ExtCC Ext(S1,S2);
 895         const Standard_Integer NbExtrema = Ext.IsDone()? (Ext.IsParallel()? 0 : Ext.NbExt()) : 0;
 896     if ( NbExtrema > 0 )
 897     {
 898       // Search minimum distance Dstmin
 899       Standard_Integer i;
 900       Standard_Real Dstmin = Ext.SquareDistance(1);
 901       for (i = 2; i <= NbExtrema; i++)
 902       {
 903         const Standard_Real sDst = Ext.SquareDistance(i);
 904         if (sDst<Dstmin)
 905           Dstmin=sDst;
 906           }
 907       Dstmin = sqrt(Dstmin);
 908       if ((Dstmin < myDstRef - myEps) || (fabs(Dstmin-myDstRef) < myEps))
 909       {
 910         Standard_Real Udeb1,Ufin1,Udeb2,Ufin2;
 911         BRep_Tool::Range(S1,Udeb1,Ufin1);
 912         BRep_Tool::Range(S2,Udeb2,Ufin2);
 913
 914         gp_Pnt Pt1,Pt2;
 915         const Standard_Real epsP=Precision::PConfusion();
 916
 917         for (i=1;i<=NbExtrema;i++)
 918         {
 919           if (fabs(Dstmin-sqrt(Ext.SquareDistance(i)))<myEps)
 920           {
 921             Pt1=Ext.PointOnE1(i);
 922             Pt2=Ext.PointOnE2(i);
 923             if (TRI_SOLUTION(SeqSolShape1,Pt1) || TRI_SOLUTION(SeqSolShape2,Pt2))
 924             {
 925               // Check if the parameters do not correspond to a vertex
 926               const Standard_Real t1 = Ext.ParameterOnE1(i);
 927               const Standard_Real t2 = Ext.ParameterOnE2(i);
 928               if ((fabs(t1-Udeb1)>=epsP)&&(fabs(t1-Ufin1)>epsP)&&(fabs(t2-Udeb2)>=epsP)&&(fabs(t2-Ufin2)>epsP))
 929               {
 930                 if (myDstRef > Dstmin)
 931                   myDstRef=Dstmin;
 932                 myModif=Standard_True;
 933                 const BRepExtrema_SolutionElem Sol1(Dstmin,Pt1,BRepExtrema_IsOnEdge,S1,t1);
 934                 const BRepExtrema_SolutionElem Sol2(Dstmin,Pt2,BRepExtrema_IsOnEdge,S2,t2);
 935                 SeqSolShape1.Append(Sol1);
 936                 SeqSolShape2.Append(Sol2);
 937               }
 938             }
 939           }
 940         }
 941       }
 942     }
 943
 944     BRepExtrema_SeqOfSolution SeqSolution1;
 945     BRepExtrema_SeqOfSolution SeqSolution2;
 946
 947     PERFORM_C0(S1, S2, SeqSolution1, SeqSolution2, DstRef, myDstRef, myEps);
 948
 949     BRepExtrema_SeqOfSolution seqSol1;
 950     BRepExtrema_SeqOfSolution seqSol2;
 951
 952     if (SeqSolution1.Length() > 0 && SeqSolution2.Length() > 0)
 953       MIN_SOLUTION(SeqSolution1, SeqSolution2, myDstRef, myEps, seqSol1, seqSol2);
 954
 955     if (!seqSol1.IsEmpty() && !seqSol2.IsEmpty())
 956     {
 957       SeqSolShape1.Append(seqSol1);
 958       SeqSolShape2.Append(seqSol2);
 959       myModif = Standard_True;
 960     }
 961   }
 962 }
 963
 964 /*********************************************************************************/
 965
 966 void BRepExtrema_DistanceSS::Perform(const TopoDS_Edge& S1, const TopoDS_Face& S2,
 967                                      const Bnd_Box& B1, const Bnd_Box& B2)
 968 {
 969   if (BRep_Tool::Degenerated(S1))
 970     return;
 971
 972   const Standard_Real Dst=B1.Distance(B2);
 973   if ((Dst < myDstRef - myEps) || (fabs(Dst-myDstRef) < myEps))
 974   {
 975     BRepClass_FaceClassifier classifier;
 976
 977     BRepExtrema_ExtCF Ext(S1,S2);
 978         const Standard_Integer NbExtrema = Ext.IsDone()? (Ext.IsParallel()? 0 : Ext.NbExt()) : 0;
 979     if ( NbExtrema > 0 )
 980     {
 981       // Search minimum distance Dstmin
 982       Standard_Integer i;
 983       Standard_Real Dstmin = Ext.SquareDistance(1);
 984       for (i = 2; i <= NbExtrema; i++)
 985       {
 986         const Standard_Real sDst = Ext.SquareDistance(i);
 987         if (sDst<Dstmin)
 988           Dstmin=sDst;
 989       }
 990       Dstmin = sqrt(Dstmin);
 991       if ((Dstmin < myDstRef - myEps) || (fabs(Dstmin-myDstRef) < myEps))
 992       {
 993         Standard_Real Udeb,Ufin,U,V;
 994         BRep_Tool::Range(S1,Udeb,Ufin);
 995         const Standard_Real tol=BRep_Tool::Tolerance(S2);
 996
 997         gp_Pnt Pt1,Pt2;
 998         const Standard_Real epsP=Precision::PConfusion();
 999
1000         for (i = 1; i <= NbExtrema; i++)
1001         {
1002           if (fabs(Dstmin-sqrt(Ext.SquareDistance(i)))<myEps)
1003           {
1004             Pt1=Ext.PointOnEdge(i);
1005             Pt2=Ext.PointOnFace(i);
1006             if (TRI_SOLUTION(SeqSolShape1,Pt1) || TRI_SOLUTION(SeqSolShape2,Pt2))
1007             {
1008               // Check if the parameter does not correspond to a vertex
1009               const Standard_Real t1 = Ext.ParameterOnEdge(i);
1010               if ((fabs(t1-Udeb)>=epsP)&&(fabs(t1-Ufin)>epsP))
1011               {
1012                 Ext.ParameterOnFace(i,U,V);
1013                 const gp_Pnt2d PUV(U,V);
1014                 classifier.Perform(S2,PUV,tol);
1015                 if (classifier.State()==TopAbs_IN)
1016                 {
1017                   if (myDstRef > Dstmin)
1018                     myDstRef=Dstmin;
1019                   myModif=Standard_True;
1020                   const BRepExtrema_SolutionElem Sol1(Dstmin,Pt1,BRepExtrema_IsOnEdge,S1,t1);
1021                   const BRepExtrema_SolutionElem Sol2(Dstmin,Pt2,BRepExtrema_IsInFace,S2,U,V);
1022                   SeqSolShape1.Append(Sol1);
1023                   SeqSolShape2.Append(Sol2);
1024                 }
1025               }
1026             }
1027           }
1028         }
1029       }
1030     }
1031
1032     Standard_Real aFirst, aLast;
1033     Handle(Geom_Curve) pCurv = BRep_Tool::Curve(S1, aFirst, aLast);
1034     if (pCurv->Continuity() == GeomAbs_C0)
1035     {
1036       BRepExtrema_SeqOfSolution SeqSolution1;
1037       BRepExtrema_SeqOfSolution SeqSolution2;
1038
1039       GeomAdaptor_Curve aAdaptorCurve(pCurv, aFirst, aLast);
1040       const Standard_Integer nbIntervals = aAdaptorCurve.NbIntervals(GeomAbs_C1);
1041
1042       TColStd_Array1OfReal arrInter(1,1+nbIntervals);
1043       aAdaptorCurve.Intervals(arrInter, GeomAbs_C1);
1044
1045       gp_Pnt Pt;
1046       Standard_Real U,V;
1047       const Standard_Real tol = BRep_Tool::Tolerance(S2);
1048
1049       Standard_Integer i;
1050       for (i = 1; i <= arrInter.Length(); i++)
1051       {
1052         const Standard_Real aParameter = arrInter(i);
1053         gp_Pnt aPnt = aAdaptorCurve.Value(aParameter);
1054         TopoDS_Vertex V1 = BRepBuilderAPI_MakeVertex(aPnt);
1055
1056         BRepExtrema_ExtPF ExtPF(V1,S2);
1057         const Standard_Integer NbExtremaPF = ExtPF.IsDone()? ExtPF.NbExt() : 0;
1058         if (NbExtremaPF > 0 )
1059         {
1060           // Search minimum distance Dstmin
1061           Standard_Integer ii;
1062           Standard_Real Dstmin = ExtPF.SquareDistance(1);
1063           for (ii = 2; ii <= NbExtremaPF; ii++)
1064           {
1065             const Standard_Real sDst = ExtPF.SquareDistance(ii);
1066             if (sDst<Dstmin)
1067               Dstmin=sDst;
1068           }
1069           Dstmin = sqrt(Dstmin);
1070
1071           if ((Dstmin < myDstRef - myEps) || (fabs(Dstmin-myDstRef) < myEps))
1072           {
1073             for (ii = 1; ii <= NbExtremaPF; ii++)
1074             {
1075               if (fabs(Dstmin-sqrt(ExtPF.SquareDistance(ii)))<myEps)
1076               {
1077                 // Check if the parameter does not correspond to a vertex
1078                 ExtPF.Parameter(ii,U,V);
1079                 const gp_Pnt2d PUV(U,V);
1080                                 classifier.Perform(S2,PUV,tol);
1081                 if (classifier.State()==TopAbs_IN)
1082                 {
1083                   if (myDstRef > Dstmin)
1084                     myDstRef=Dstmin;
1085                   myModif=Standard_True;
1086                   const BRepExtrema_SolutionElem Sol1(Dstmin,aPnt,BRepExtrema_IsOnEdge,S1,aParameter);
1087                   const BRepExtrema_SolutionElem Sol2(Dstmin,ExtPF.Point(ii),BRepExtrema_IsInFace,S2,U,V);
1088                   SeqSolution1.Append(Sol1);
1089                   SeqSolution2.Append(Sol2);
1090                 }
1091               }
1092             }
1093           }
1094         }
1095       }
1096
1097       BRepExtrema_SeqOfSolution seqSol1;
1098       BRepExtrema_SeqOfSolution seqSol2;
1099       if (SeqSolution1.Length() > 0 && SeqSolution2.Length() > 0)
1100         MIN_SOLUTION(SeqSolution1, SeqSolution2, myDstRef, myEps, seqSol1, seqSol2);
1101
1102       if (!seqSol1.IsEmpty() && !seqSol2.IsEmpty())
1103       {
1104         SeqSolShape1.Append(seqSol1);
1105         SeqSolShape2.Append(seqSol2);
1106       }
1107     }
1108   }
1109 }
1110
1111 void BRepExtrema_DistanceSS::Perform(const TopoDS_Face& S1, const TopoDS_Edge& S2,
1112                                      const Bnd_Box& B1, const Bnd_Box& B2)
1113 {
1114   if (BRep_Tool::Degenerated(S2))
1115     return;
1116
1117   const Standard_Real Dst=B1.Distance(B2);
1118   if ((Dst < myDstRef - myEps) || (fabs(Dst-myDstRef) < myEps))
1119   {
1120     BRepClass_FaceClassifier classifier;
1121
1122     BRepExtrema_ExtCF Ext(S2,S1);
1123         const Standard_Integer NbExtrema = Ext.IsDone()? (Ext.IsParallel()? 0 : Ext.NbExt()) : 0;
1124     if ( NbExtrema > 0 )
1125     {
1126       // Search minimum distance Dstmin
1127       Standard_Integer i;
1128       Standard_Real Dstmin = Ext.SquareDistance(1);
1129       for (i = 2; i <= NbExtrema; i++)
1130       {
1131         const Standard_Real sDst = Ext.SquareDistance(i);
1132         if (sDst<Dstmin)
1133           Dstmin=sDst;
1134       }
1135       Dstmin = sqrt(Dstmin);
1136       if ((Dstmin < myDstRef - myEps) || (fabs(Dstmin-myDstRef) < myEps))
1137       {
1138         Standard_Real Udeb,Ufin,U,V;
1139         BRep_Tool::Range(S2,Udeb,Ufin);
1140         const Standard_Real tol=BRep_Tool::Tolerance(S1);
1141
1142         gp_Pnt Pt1,Pt2;
1143         const Standard_Real epsP=Precision::PConfusion();
1144
1145         for (i = 1; i <= NbExtrema; i++)
1146         {
1147           if (fabs(Dstmin-sqrt(Ext.SquareDistance(i)))<myEps)
1148           {
1149             Pt1=Ext.PointOnEdge(i);
1150             Pt2=Ext.PointOnFace(i);
1151             if (TRI_SOLUTION(SeqSolShape1,Pt1) || TRI_SOLUTION(SeqSolShape2,Pt2))
1152             {
1153               // Check if the parameter does not correspond to a vertex
1154               const Standard_Real t1 = Ext.ParameterOnEdge(i);
1155               if ((fabs(t1-Udeb)>=epsP)&&(fabs(t1-Ufin)>epsP))
1156               {
1157                 Ext.ParameterOnFace(i,U,V);
1158                 const gp_Pnt2d PUV(U,V);
1159                 classifier.Perform(S1,PUV,tol);
1160                 if (classifier.State()==TopAbs_IN)
1161                 {
1162                   if (myDstRef > Dstmin)
1163                     myDstRef=Dstmin;
1164                   myModif=Standard_True;
1165                   const BRepExtrema_SolutionElem Sol2(Dstmin,Pt1,BRepExtrema_IsOnEdge,S2,t1);
1166                   const BRepExtrema_SolutionElem Sol1(Dstmin,Pt2,BRepExtrema_IsInFace,S1,U,V);
1167                   SeqSolShape1.Append(Sol1);
1168                   SeqSolShape2.Append(Sol2);
1169                 }
1170               }
1171             }
1172           }
1173         }
1174       }
1175     }
1176
1177     Standard_Real aFirst, aLast;
1178     Handle(Geom_Curve) pCurv = BRep_Tool::Curve(S2, aFirst, aLast);
1179     if (pCurv->Continuity() == GeomAbs_C0)
1180     {
1181       BRepExtrema_SeqOfSolution SeqSolution1;
1182       BRepExtrema_SeqOfSolution SeqSolution2;
1183
1184       GeomAdaptor_Curve aAdaptorCurve(pCurv, aFirst, aLast);
1185       const Standard_Integer nbIntervals = aAdaptorCurve.NbIntervals(GeomAbs_C1);
1186
1187       TColStd_Array1OfReal arrInter(1,1+nbIntervals);
1188       aAdaptorCurve.Intervals(arrInter, GeomAbs_C1);
1189
1190       gp_Pnt Pt;
1191       Standard_Real U,V;
1192       const Standard_Real tol = BRep_Tool::Tolerance(S1);
1193
1194       Standard_Integer i;
1195       for (i = 1; i <= arrInter.Length(); i++)
1196       {
1197         const Standard_Real aParameter = arrInter(i);
1198         gp_Pnt aPnt = aAdaptorCurve.Value(aParameter);
1199         TopoDS_Vertex V1 = BRepBuilderAPI_MakeVertex(aPnt);
1200
1201         BRepExtrema_ExtPF ExtPF(V1,S1);
1202         const Standard_Integer NbExtremaPF = ExtPF.IsDone()? ExtPF.NbExt() : 0;
1203         if (NbExtremaPF > 0 )
1204         {
1205           // Search minimum distance Dstmin
1206           Standard_Integer ii;
1207           Standard_Real Dstmin = ExtPF.SquareDistance(1);
1208           for (ii = 2; ii <= NbExtremaPF; ii++)
1209           {
1210             const Standard_Real sDst = ExtPF.SquareDistance(ii);
1211             if (sDst<Dstmin)
1212               Dstmin=sDst;
1213           }
1214           Dstmin = sqrt(Dstmin);
1215
1216           if ((Dstmin < myDstRef - myEps) || (fabs(Dstmin-myDstRef) < myEps))
1217           {
1218             for (ii = 1; ii <= NbExtremaPF; ii++)
1219             {
1220               if (fabs(Dstmin-sqrt(ExtPF.SquareDistance(ii)))<myEps)
1221               {
1222                 // Check if the parameter does not correspond to a vertex
1223                 ExtPF.Parameter(ii,U,V);
1224                 const gp_Pnt2d PUV(U,V);
1225                                 classifier.Perform(S1,PUV,tol);
1226                 if (classifier.State()==TopAbs_IN)
1227                 {
1228                   if (myDstRef > Dstmin)
1229                     myDstRef=Dstmin;
1230                   myModif=Standard_True;
1231                   const BRepExtrema_SolutionElem Sol2(Dstmin,aPnt,BRepExtrema_IsOnEdge,S2,aParameter);
1232                   const BRepExtrema_SolutionElem Sol1(Dstmin,ExtPF.Point(ii),BRepExtrema_IsInFace,S1,U,V);
1233                   SeqSolution1.Append(Sol1);
1234                   SeqSolution2.Append(Sol2);
1235                 }
1236               }
1237             }
1238           }
1239         }
1240       }
1241
1242       BRepExtrema_SeqOfSolution seqSol1;
1243       BRepExtrema_SeqOfSolution seqSol2;
1244       if (SeqSolution1.Length() > 0 && SeqSolution2.Length() > 0)
1245         MIN_SOLUTION(SeqSolution1, SeqSolution2, myDstRef, myEps, seqSol1, seqSol2);
1246
1247       if (!seqSol1.IsEmpty() && !seqSol2.IsEmpty())
1248       {
1249         SeqSolShape1.Append(seqSol1);
1250         SeqSolShape2.Append(seqSol2);
1251       }
1252     }
1253   }
1254 }
1255
1256 /*********************************************************************************/
1257
1258 void BRepExtrema_DistanceSS::Perform(const TopoDS_Face& S1, const TopoDS_Face& S2,
1259                                      const Bnd_Box& B1, const Bnd_Box& B2)
1260 {
1261   const Standard_Real Dst=B1.Distance(B2);
1262   if ((Dst < myDstRef - myEps) || (fabs(Dst-myDstRef) < myEps))
1263   {
1264     BRepExtrema_ExtFF Ext(S1,S2);
1265         const Standard_Integer NbExtrema = Ext.IsDone()? (Ext.IsParallel()? 0 : Ext.NbExt()) : 0;
1266     if ( NbExtrema > 0 )
1267     {
1268       // Search minimum distance Dstmin
1269       Standard_Integer i;
1270       Standard_Real Dstmin = Ext.SquareDistance(1);
1271       for (i = 2; i <= NbExtrema; i++)
1272       {
1273         const Standard_Real sDst = Ext.SquareDistance(i);
1274         if (sDst<Dstmin)
1275           Dstmin=sDst;
1276       }
1277       Dstmin = sqrt(Dstmin);
1278       if ((Dstmin < myDstRef - myEps) || (fabs(Dstmin-myDstRef) < myEps))
1279       {
1280         const Standard_Real tol1=BRep_Tool::Tolerance(S1);
1281         const Standard_Real tol2=BRep_Tool::Tolerance(S2);
1282
1283         gp_Pnt Pt1,Pt2;
1284         gp_Pnt2d PUV;
1285         Standard_Real U1,V1,U2,V2;
1286         BRepClass_FaceClassifier classifier;
1287
1288         for (i = 1; i <= NbExtrema; i++)
1289         {
1290           if (fabs(Dstmin-sqrt(Ext.SquareDistance(i)))<myEps)
1291           {
1292             Pt1=Ext.PointOnFace1(i);
1293             Pt2=Ext.PointOnFace2(i);
1294             if (TRI_SOLUTION(SeqSolShape1,Pt1) || TRI_SOLUTION(SeqSolShape2,Pt2))
1295             {
1296               // Check if the parameter does not correspond to a vertex
1297               Ext.ParameterOnFace1(i,U1,V1);
1298               PUV.SetCoord(U1,V1);
1299               classifier.Perform(S1,PUV,tol1);
1300               if (classifier.State()==TopAbs_IN)
1301               {
1302                 Ext.ParameterOnFace2(i,U2,V2);
1303                 PUV.SetCoord(U2,V2);
1304                 classifier.Perform(S2,PUV,tol2);
1305                 if (classifier.State()==TopAbs_IN)
1306                 {
1307                   if (myDstRef > Dstmin)
1308                     myDstRef=Dstmin;
1309                   myModif=Standard_True;
1310                   const BRepExtrema_SolutionElem Sol1(Dstmin,Pt1,BRepExtrema_IsInFace,S1,U1,V1);
1311                   const BRepExtrema_SolutionElem Sol2(Dstmin,Pt2,BRepExtrema_IsInFace,S2,U2,V2);
1312                   SeqSolShape1.Append(Sol1);
1313                   SeqSolShape2.Append(Sol2);
1314                 }
1315               }
1316             }
1317           }
1318         }
1319       }
1320     }
1321   }
1322 }
1323
1324 /*********************************************************************************/