src/IntPatch/IntPatch_Intersection.cxx

   1 // Created by: Modelization
   2 // Copyright (c) 1999-2012 OPEN CASCADE SAS
   3 //
   4 // The content of this file is subject to the Open CASCADE Technology Public
   5 // License Version 6.5 (the "License"). You may not use the content of this file
   6 // except in compliance with the License. Please obtain a copy of the License
   7 // at http://www.opencascade.org and read it completely before using this file.
   8 //
   9 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
  10 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
  11 //
  12 // The Original Code and all software distributed under the License is
  13 // distributed on an "AS IS" basis, without warranty of any kind, and the
  14 // Initial Developer hereby disclaims all such warranties, including without
  15 // limitation, any warranties of merchantability, fitness for a particular
  16 // purpose or non-infringement. Please see the License for the specific terms
  17 // and conditions governing the rights and limitations under the License.
  18
  19
  20 #include <IntPatch_Intersection.ixx>
  21
  22 #include <IntPatch_ALineToWLine.hxx>
  23 #include <IntPatch_GLine.hxx>
  24 #include <IntPatch_ALine.hxx>
  25 #include <IntPatch_WLine.hxx>
  26 #include <IntPatch_RLine.hxx>
  27 #include <IntPatch_PrmPrmIntersection.hxx>
  28 #include <IntPatch_ImpPrmIntersection.hxx>
  29 #include <IntPatch_ImpImpIntersection.hxx>
  30 #include <IntSurf_Quadric.hxx>
  31
  32 #include <stdio.h>
  33
  34 #define DEBUG 0
  35 static const Standard_Integer aNbPointsInALine = 200;
  36
  37 //======================================================================
  38 // function: SequenceOfLine
  39 //======================================================================
  40 const IntPatch_SequenceOfLine& IntPatch_Intersection::SequenceOfLine() const { return(slin); }
  41
  42 //======================================================================
  43 // function: IntPatch_Intersection
  44 //======================================================================
  45 IntPatch_Intersection::IntPatch_Intersection ()
  46  : done(Standard_False),
  47    //empt, tgte, oppo,
  48    myTolArc(0.0), myTolTang(0.0),
  49    myUVMaxStep(0.0), myFleche(0.0),
  50    myIsStartPnt(Standard_False)
  51    //myU1Start, myV1Start, myU2Start, myV2Start
  52 {
  53 }
  54
  55 //======================================================================
  56 // function: IntPatch_Intersection
  57 //======================================================================
  58 IntPatch_Intersection::IntPatch_Intersection(const Handle(Adaptor3d_HSurface)&  S1,
  59                                              const Handle(Adaptor3d_TopolTool)& D1,
  60                                              const Handle(Adaptor3d_HSurface)&  S2,
  61                                              const Handle(Adaptor3d_TopolTool)& D2,
  62                                              const Standard_Real TolArc,
  63                                              const Standard_Real TolTang)
  64  : done(Standard_False),
  65    //empt, tgte, oppo,
  66    myTolArc(TolArc), myTolTang(TolTang),
  67    myUVMaxStep(0.0), myFleche(0.0),
  68    myIsStartPnt(Standard_False)
  69    //myU1Start, myV1Start, myU2Start, myV2Start
  70 {
  71   if(myTolArc<1e-8) myTolArc=1e-8;
  72   if(myTolTang<1e-8) myTolTang=1e-8;
  73   if(myTolArc>0.5) myTolArc=0.5;
  74   if(myTolTang>0.5) myTolTang=0.5;
  75   Perform(S1,D1,S2,D2,TolArc,TolTang);
  76 }
  77
  78 //======================================================================
  79 // function: IntPatch_Intersection
  80 //======================================================================
  81 IntPatch_Intersection::IntPatch_Intersection(const Handle(Adaptor3d_HSurface)&  S1,
  82                                              const Handle(Adaptor3d_TopolTool)& D1,
  83                                              const Standard_Real TolArc,
  84                                              const Standard_Real TolTang)
  85  : done(Standard_False),
  86    //empt, tgte, oppo,
  87    myTolArc(TolArc), myTolTang(TolTang),
  88    myUVMaxStep(0.0), myFleche(0.0),
  89    myIsStartPnt(Standard_False)
  90    //myU1Start, myV1Start, myU2Start, myV2Start
  91 {
  92   Perform(S1,D1,TolArc,TolTang);
  93 }
  94
  95 //======================================================================
  96 // function: SetTolerances
  97 //======================================================================
  98 void IntPatch_Intersection::SetTolerances(const Standard_Real TolArc,
  99                                           const Standard_Real TolTang,
 100                                           const Standard_Real UVMaxStep,
 101                                           const Standard_Real Fleche)
 102 {
 103   myTolArc     = TolArc;
 104   myTolTang    = TolTang;
 105   myUVMaxStep  = UVMaxStep;
 106   myFleche     = Fleche;
 107   if(myTolArc<1e-8) myTolArc=1e-8;
 108   if(myTolTang<1e-8) myTolTang=1e-8;
 109   if(myTolArc>0.5) myTolArc=0.5;
 110   if(myTolTang>0.5) myTolTang=0.5;
 111   if(myFleche<1.0e-3) myFleche=1e-3;
 112   if(myUVMaxStep<1.0e-3) myUVMaxStep=1e-3;
 113   if(myFleche>10) myFleche=10;
 114   if(myUVMaxStep>0.5) myUVMaxStep=0.5;
 115 }
 116
 117 //======================================================================
 118 // function: Perform
 119 //======================================================================
 120 void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)&  S1,
 121                                     const Handle(Adaptor3d_TopolTool)& D1,
 122                                     const Standard_Real TolArc,
 123                                     const Standard_Real TolTang)
 124 {
 125   myTolArc = TolArc;
 126   myTolTang = TolTang;
 127   if(myFleche == 0.0)  myFleche = 0.01;
 128   if(myUVMaxStep==0.0) myUVMaxStep = 0.01;
 129
 130   done = Standard_True;
 131   spnt.Clear();
 132   slin.Clear();
 133
 134   empt = Standard_True;
 135   tgte = Standard_False;
 136   oppo = Standard_False;
 137
 138   switch (S1->GetType())
 139   {
 140     case GeomAbs_Plane:
 141     case GeomAbs_Cylinder:
 142     case GeomAbs_Sphere:
 143     case GeomAbs_Cone:
 144     case GeomAbs_Torus: break;
 145     default:
 146     {
 147           IntPatch_PrmPrmIntersection interpp;
 148           interpp.Perform(S1,D1,TolArc,TolTang,myFleche,myUVMaxStep);
 149           if (interpp.IsDone())
 150           {
 151             done = Standard_True;
 152             tgte = Standard_False;
 153             empt = interpp.IsEmpty();
 154             const Standard_Integer nblm = interpp.NbLines();
 155             for (Standard_Integer i=1; i<=nblm; i++) slin.Append(interpp.Line(i));
 156           }
 157     }
 158     break;
 159   }
 160 }
 161
 162 /////////////////////////////////////////////////////////////////////////////
 163 //  These several support functions provide methods which can help basic   //
 164 //  algorithm to intersect infinite surfaces of the following types:       //
 165 //                                                                         //
 166 //  a.) SurfaceOfExtrusion;                                                //
 167 //  b.) SurfaceOfRevolution;                                               //
 168 //  c.) OffsetSurface.                                                     //
 169 //                                                                         //
 170 /////////////////////////////////////////////////////////////////////////////
 171 #include <TColgp_Array1OfXYZ.hxx>
 172 #include <TColgp_Array1OfPnt.hxx>
 173 #include <TColgp_SequenceOfPnt.hxx>
 174 #include <Extrema_ExtPS.hxx>
 175 #include <Extrema_POnSurf.hxx>
 176 #include <Geom2d_Curve.hxx>
 177 #include <Geom2dAPI_InterCurveCurve.hxx>
 178 #include <GeomAdaptor.hxx>
 179 #include <GeomAdaptor_HCurve.hxx>
 180 #include <GeomAdaptor_Curve.hxx>
 181 #include <GeomAdaptor_Surface.hxx>
 182 #include <Handle_GeomAdaptor_HSurface.hxx>
 183 #include <Geom_Plane.hxx>
 184 #include <ProjLib_ProjectOnPlane.hxx>
 185 #include <GeomProjLib.hxx>
 186 #include <ElCLib.hxx>
 187 #include <Geom_TrimmedCurve.hxx>
 188 #include <Geom_Surface.hxx>
 189 #include <Geom_SurfaceOfLinearExtrusion.hxx>
 190 #include <Geom_OffsetSurface.hxx>
 191 #include <Geom_SurfaceOfRevolution.hxx>
 192 #include <Geom_RectangularTrimmedSurface.hxx>
 193
 194 //===============================================================
 195 //function: FUN_GetMinMaxXYZPnt
 196 //===============================================================
 197 static void FUN_GetMinMaxXYZPnt( const Handle(Adaptor3d_HSurface)& S,
 198                                  gp_Pnt& pMin, gp_Pnt& pMax )
 199 {
 200   const Standard_Real DU = 0.25 * Abs(S->LastUParameter() - S->FirstUParameter());
 201   const Standard_Real DV = 0.25 * Abs(S->LastVParameter() - S->FirstVParameter());
 202   Standard_Real tMinXYZ = RealLast();
 203   Standard_Real tMaxXYZ = -tMinXYZ;
 204   gp_Pnt PUV, ptMax, ptMin;
 205   for(Standard_Real U = S->FirstUParameter(); U <= S->LastUParameter(); U += DU)
 206   {
 207     for(Standard_Real V = S->FirstVParameter(); V <= S->LastVParameter(); V += DV)
 208         {
 209           S->D0(U,V,PUV);
 210       const Standard_Real cXYZ = PUV.XYZ().Modulus();
 211           if(cXYZ > tMaxXYZ) { tMaxXYZ = cXYZ; ptMax = PUV; }
 212           if(cXYZ < tMinXYZ) { tMinXYZ = cXYZ; ptMin = PUV; }
 213         }
 214   }
 215   pMin = ptMin;
 216   pMax = ptMax;
 217 }
 218 //==========================================================================
 219 //function: FUN_TrimInfSurf
 220 //==========================================================================
 221 static void FUN_TrimInfSurf(const gp_Pnt& Pmin,
 222                             const gp_Pnt& Pmax,
 223                             const Handle(Adaptor3d_HSurface)& InfSurf,
 224                             const Standard_Real& AlternativeTrimPrm,
 225                             Handle(Adaptor3d_HSurface)& TrimS)
 226 {
 227   Standard_Real TP = AlternativeTrimPrm;
 228   Extrema_ExtPS ext1(Pmin, InfSurf->Surface(), 1.e-7, 1.e-7);
 229   Extrema_ExtPS ext2(Pmax, InfSurf->Surface(), 1.e-7, 1.e-7);
 230   if(ext1.IsDone() || ext2.IsDone())
 231   {
 232     Standard_Real Umax = -1.e+100, Umin = 1.e+100, Vmax = -1.e+100, Vmin = 1.e+100, cU, cV;
 233     if(ext1.IsDone())
 234         {
 235       for(Standard_Integer i = 1; i <= ext1.NbExt(); i++)
 236       {
 237             const Extrema_POnSurf & pons = ext1.Point(i);
 238             pons.Parameter(cU,cV);
 239             if(cU > Umax) Umax = cU;
 240             if(cU < Umin) Umin = cU;
 241             if(cV > Vmax) Vmax = cV;
 242             if(cV < Vmin) Vmin = cV;
 243       }
 244         }
 245     if(ext2.IsDone())
 246         {
 247       for(Standard_Integer i = 1; i <= ext2.NbExt(); i++)
 248       {
 249         const Extrema_POnSurf & pons = ext2.Point(i);
 250         pons.Parameter(cU,cV);
 251         if(cU > Umax) Umax = cU;
 252         if(cU < Umin) Umin = cU;
 253         if(cV > Vmax) Vmax = cV;
 254         if(cV < Vmin) Vmin = cV;
 255       }
 256         }
 257     TP = Max(Abs(Umin),Max(Abs(Umax),Max(Abs(Vmin),Abs(Vmax))));
 258   }
 259   if(TP == 0.) { TrimS = InfSurf; return; }
 260   else
 261   {
 262     const Standard_Boolean Uinf = Precision::IsNegativeInfinite(InfSurf->FirstUParameter());
 263     const Standard_Boolean Usup = Precision::IsPositiveInfinite(InfSurf->LastUParameter());
 264     const Standard_Boolean Vinf = Precision::IsNegativeInfinite(InfSurf->FirstVParameter());
 265     const Standard_Boolean Vsup = Precision::IsPositiveInfinite(InfSurf->LastVParameter());
 266     Handle(Adaptor3d_HSurface) TmpSS;
 267     Standard_Integer IsTrimed = 0;
 268     const Standard_Real tp = 1000.0 * TP;
 269     if(Vinf && Vsup) { TrimS = InfSurf->VTrim(-tp, tp, 1.0e-7); IsTrimed = 1; }
 270     if(Vinf && !Vsup){ TrimS = InfSurf->VTrim(-tp, InfSurf->LastVParameter(), 1.0e-7); IsTrimed = 1; }
 271     if(!Vinf && Vsup){ TrimS = InfSurf->VTrim(InfSurf->FirstVParameter(), tp, 1.0e-7); IsTrimed = 1; }
 272     if(IsTrimed)
 273         {
 274           TmpSS = TrimS;
 275           if(Uinf && Usup)  TrimS = TmpSS->UTrim(-tp, tp, 1.0e-7);
 276           if(Uinf && !Usup) TrimS = TmpSS->UTrim(-tp, InfSurf->LastUParameter(), 1.0e-7);
 277           if(!Uinf && Usup) TrimS = TmpSS->UTrim(InfSurf->FirstUParameter(), tp, 1.0e-7);
 278         }
 279     else
 280         {
 281           if(Uinf && Usup)  TrimS = InfSurf->UTrim(-tp, tp, 1.0e-7);
 282           if(Uinf && !Usup) TrimS = InfSurf->UTrim(-tp, InfSurf->LastUParameter(), 1.0e-7);
 283           if(!Uinf && Usup) TrimS = InfSurf->UTrim(InfSurf->FirstUParameter(), tp, 1.0e-7);
 284         }
 285   }
 286 }
 287 //================================================================================
 288 //function: FUN_GetUiso
 289 //================================================================================
 290 static void FUN_GetUiso(const Handle(Geom_Surface)& GS,
 291                         const GeomAbs_SurfaceType&  T,
 292                         const Standard_Real&        FirstV,
 293                         const Standard_Real&        LastV,
 294                         const Standard_Boolean&     IsVC,
 295                         const Standard_Boolean&     IsVP,
 296                         const Standard_Real&        U,
 297                         Handle(Geom_Curve)&         I)
 298 {
 299   if(T !=  GeomAbs_OffsetSurface)
 300   {
 301     Handle(Geom_Curve) gc = GS->UIso(U);
 302     if(IsVP && (FirstV == 0.0 && LastV == (2.*M_PI))) I = gc;
 303     else
 304         {
 305           Handle(Geom_TrimmedCurve) gtc = new Geom_TrimmedCurve(gc,FirstV,LastV);
 306           //szv:I = Handle(Geom_Curve)::DownCast(gtc);
 307           I = gtc;
 308         }
 309   }
 310   else//OffsetSurface
 311   {
 312     const Handle(Geom_OffsetSurface) gos = *(Handle_Geom_OffsetSurface*)&GS;
 313     const Handle(Geom_Surface) bs = gos->BasisSurface();
 314     Handle(Geom_Curve) gcbs = bs->UIso(U);
 315     GeomAdaptor_Curve gac(gcbs);
 316     const GeomAbs_CurveType GACT = gac.GetType();
 317     if(IsVP || IsVC || GACT == GeomAbs_BSplineCurve || GACT == GeomAbs_BezierCurve || Abs(LastV - FirstV) < 1.e+5)
 318         {
 319           Handle(Geom_Curve) gc = gos->UIso(U);
 320           if(IsVP && (FirstV == 0.0 && LastV == (2*M_PI))) I = gc;
 321           else
 322       {
 323             Handle(Geom_TrimmedCurve) gtc = new Geom_TrimmedCurve(gc,FirstV,LastV);
 324             //szv:I = Handle(Geom_Curve)::DownCast(gtc);
 325             I = gtc;
 326           }
 327         }
 328     else//Offset Line, Parab, Hyperb
 329         {
 330           Standard_Real VmTr, VMTr;
 331           if(GACT != GeomAbs_Hyperbola)
 332       {
 333             if(FirstV >= 0. && LastV >= 0.){ VmTr = FirstV; VMTr = ((LastV - FirstV) > 1.e+4) ? (FirstV + 1.e+4) : LastV; }
 334             else if(FirstV < 0. && LastV < 0.){ VMTr = LastV; VmTr = ((FirstV - LastV) < -1.e+4) ? (LastV - 1.e+4) : FirstV; }
 335             else { VmTr = (FirstV < -1.e+4) ? -1.e+4 : FirstV; VMTr = (LastV > 1.e+4) ? 1.e+4 : LastV; }
 336           }
 337           else//Hyperbola
 338           {
 339             if(FirstV >= 0. && LastV >= 0.)
 340                 {
 341                   if(FirstV > 4.) return;
 342                   VmTr = FirstV; VMTr = (LastV > 4.) ? 4. : LastV;
 343                 }
 344             else if(FirstV < 0. && LastV < 0.)
 345                 {
 346                   if(LastV < -4.) return;
 347                   VMTr = LastV; VmTr = (FirstV < -4.) ? -4. : FirstV;
 348                 }
 349             else { VmTr = (FirstV < -4.) ? -4. : FirstV; VMTr = (LastV > 4.) ? 4. : LastV; }
 350           }
 351           //Make trimmed surface
 352           Handle(Geom_RectangularTrimmedSurface) rts = new Geom_RectangularTrimmedSurface(gos,VmTr,VMTr,Standard_True);
 353           I = rts->UIso(U);
 354         }
 355   }
 356 }
 357 //================================================================================
 358 //function: FUN_GetViso
 359 //================================================================================
 360 static void FUN_GetViso(const Handle(Geom_Surface)& GS,
 361                         const GeomAbs_SurfaceType&  T,
 362                         const Standard_Real&        FirstU,
 363                         const Standard_Real&        LastU,
 364                         const Standard_Boolean&     IsUC,
 365                         const Standard_Boolean&     IsUP,
 366                         const Standard_Real&        V,
 367                         Handle(Geom_Curve)&         I)
 368 {
 369   if(T !=  GeomAbs_OffsetSurface)
 370   {
 371     Handle(Geom_Curve) gc = GS->VIso(V);
 372     if(IsUP && (FirstU == 0.0 && LastU == (2*M_PI))) I = gc;
 373     else
 374         {
 375           Handle(Geom_TrimmedCurve) gtc = new Geom_TrimmedCurve(gc,FirstU,LastU);
 376           //szv:I = Handle(Geom_Curve)::DownCast(gtc);
 377           I = gtc;
 378         }
 379   }
 380   else//OffsetSurface
 381   {
 382     const Handle(Geom_OffsetSurface) gos = *(Handle_Geom_OffsetSurface*)&GS;
 383     const Handle(Geom_Surface) bs = gos->BasisSurface();
 384     Handle(Geom_Curve) gcbs = bs->VIso(V);
 385     GeomAdaptor_Curve gac(gcbs);
 386     const GeomAbs_CurveType GACT = gac.GetType();
 387     if(IsUP || IsUC || GACT == GeomAbs_BSplineCurve || GACT == GeomAbs_BezierCurve || Abs(LastU - FirstU) < 1.e+5)
 388         {
 389           Handle(Geom_Curve) gc = gos->VIso(V);
 390           if(IsUP && (FirstU == 0.0 && LastU == (2*M_PI))) I = gc;
 391           else
 392           {
 393             Handle(Geom_TrimmedCurve) gtc = new Geom_TrimmedCurve(gc,FirstU,LastU);
 394             //szv:I = Handle(Geom_Curve)::DownCast(gtc);
 395             I = gtc;
 396           }
 397         }
 398     else//Offset Line, Parab, Hyperb
 399         {
 400           Standard_Real UmTr, UMTr;
 401           if(GACT != GeomAbs_Hyperbola)
 402           {
 403             if(FirstU >= 0. && LastU >= 0.){ UmTr = FirstU; UMTr = ((LastU - FirstU) > 1.e+4) ? (FirstU + 1.e+4) : LastU; }
 404             else if(FirstU < 0. && LastU < 0.){ UMTr = LastU; UmTr = ((FirstU - LastU) < -1.e+4) ? (LastU - 1.e+4) : FirstU; }
 405             else { UmTr = (FirstU < -1.e+4) ? -1.e+4 : FirstU; UMTr = (LastU > 1.e+4) ? 1.e+4 : LastU; }
 406           }
 407           else//Hyperbola
 408           {
 409             if(FirstU >= 0. && LastU >= 0.)
 410                 {
 411                   if(FirstU > 4.) return;
 412                   UmTr = FirstU; UMTr = (LastU > 4.) ? 4. : LastU;
 413                 }
 414             else if(FirstU < 0. && LastU < 0.)
 415                 {
 416                   if(LastU < -4.) return;
 417                   UMTr = LastU; UmTr = (FirstU < -4.) ? -4. : FirstU;
 418                 }
 419             else { UmTr = (FirstU < -4.) ? -4. : FirstU; UMTr = (LastU > 4.) ? 4. : LastU; }
 420             }
 421           //Make trimmed surface
 422           Handle(Geom_RectangularTrimmedSurface) rts = new Geom_RectangularTrimmedSurface(gos,UmTr,UMTr,Standard_True);
 423           I = rts->VIso(V);
 424         }
 425   }
 426 }
 427 //================================================================================
 428 //function: FUN_PL_Intersection
 429 //================================================================================
 430 static void FUN_PL_Intersection(const Handle(Adaptor3d_HSurface)& S1,
 431                                 const GeomAbs_SurfaceType&        T1,
 432                                 const Handle(Adaptor3d_HSurface)& S2,
 433                                 const GeomAbs_SurfaceType&        T2,
 434                                 Standard_Boolean&                 IsOk,
 435                                 TColgp_SequenceOfPnt&             SP,
 436                                 gp_Vec&                           DV)
 437 {
 438   IsOk = Standard_False;
 439   // 1. Check: both surfaces have U(V)isos - lines.
 440   DV = gp_Vec(0.,0.,1.);
 441   Standard_Boolean isoS1isLine[2] = {0, 0};
 442   Standard_Boolean isoS2isLine[2] = {0, 0};
 443   Handle(Geom_Curve) C1, C2;
 444   const GeomAdaptor_Surface & gas1 = *(GeomAdaptor_Surface*)(&(S1->Surface()));
 445   const GeomAdaptor_Surface & gas2 = *(GeomAdaptor_Surface*)(&(S2->Surface()));
 446   const Handle(Geom_Surface) gs1 = gas1.Surface();
 447   const Handle(Geom_Surface) gs2 = gas2.Surface();
 448   Standard_Real MS1[2], MS2[2];
 449   MS1[0] = 0.5 * (S1->LastUParameter() + S1->FirstUParameter());
 450   MS1[1] = 0.5 * (S1->LastVParameter() + S1->FirstVParameter());
 451   MS2[0] = 0.5 * (S2->LastUParameter() + S2->FirstUParameter());
 452   MS2[1] = 0.5 * (S2->LastVParameter() + S2->FirstVParameter());
 453   if(T1 == GeomAbs_SurfaceOfExtrusion) isoS1isLine[0] = Standard_True;
 454   else if(!S1->IsVPeriodic() && !S1->IsVClosed()) {
 455     if(T1 != GeomAbs_OffsetSurface) C1 = gs1->UIso(MS1[0]);
 456     else {
 457       const Handle(Geom_OffsetSurface) gos = *(Handle_Geom_OffsetSurface*)&gs1;
 458       const Handle(Geom_Surface) bs = gos->BasisSurface();
 459       C1 = bs->UIso(MS1[0]);
 460     }
 461     GeomAdaptor_Curve gac(C1);
 462     if(gac.GetType() == GeomAbs_Line) isoS1isLine[0] = Standard_True;
 463   }
 464   if(!S1->IsUPeriodic() && !S1->IsUClosed()) {
 465     if(T1 != GeomAbs_OffsetSurface) C1 = gs1->VIso(MS1[1]);
 466     else {
 467       const Handle(Geom_OffsetSurface) gos = *(Handle_Geom_OffsetSurface*)&gs1;
 468       const Handle(Geom_Surface) bs = gos->BasisSurface();
 469       C1 = bs->VIso(MS1[1]);
 470     }
 471     GeomAdaptor_Curve gac(C1);
 472     if(gac.GetType() == GeomAbs_Line) isoS1isLine[1] = Standard_True;
 473   }
 474   if(T2 == GeomAbs_SurfaceOfExtrusion) isoS2isLine[0] = Standard_True;
 475   else if(!S2->IsVPeriodic() && !S2->IsVClosed()) {
 476     if(T2 != GeomAbs_OffsetSurface) C2 = gs2->UIso(MS2[0]);
 477     else {
 478       const Handle(Geom_OffsetSurface) gos = *(Handle_Geom_OffsetSurface*)&gs2;
 479       const Handle(Geom_Surface) bs = gos->BasisSurface();
 480       C2 = bs->UIso(MS2[0]);
 481     }
 482     GeomAdaptor_Curve gac(C2);
 483     if(gac.GetType() == GeomAbs_Line) isoS2isLine[0] = Standard_True;
 484   }
 485   if(!S2->IsUPeriodic() && !S2->IsUClosed()) {
 486     if(T2 != GeomAbs_OffsetSurface) C2 = gs2->VIso(MS2[1]);
 487     else {
 488       const Handle(Geom_OffsetSurface) gos = *(Handle_Geom_OffsetSurface*)&gs2;
 489       const Handle(Geom_Surface) bs = gos->BasisSurface();
 490       C2 = bs->VIso(MS2[1]);
 491     }
 492     GeomAdaptor_Curve gac(C2);
 493     if(gac.GetType() == GeomAbs_Line) isoS2isLine[1] = Standard_True;
 494   }
 495   Standard_Boolean IsBothLines = ((isoS1isLine[0] || isoS1isLine[1]) &&
 496                                   (isoS2isLine[0] || isoS2isLine[1]));
 497   if(!IsBothLines){
 498     return;
 499   }
 500   // 2. Check: Uiso lines of both surfaces are collinear.
 501   gp_Pnt puvS1, puvS2;
 502   gp_Vec derS1[2], derS2[2];
 503   S1->D1(MS1[0], MS1[1], puvS1, derS1[0], derS1[1]);
 504   S2->D1(MS2[0], MS2[1], puvS2, derS2[0], derS2[1]);
 505   C1.Nullify(); C2.Nullify();
 506   Standard_Integer iso = 0;
 507   if(isoS1isLine[0] && isoS2isLine[0] &&
 508      derS1[1].IsParallel(derS2[1],Precision::Angular())) {
 509     iso = 1;
 510     FUN_GetViso(gs1,T1,S1->FirstUParameter(),S1->LastUParameter(),
 511                 S1->IsUClosed(),S1->IsUPeriodic(),MS1[1],C1);
 512     FUN_GetViso(gs2,T2,S2->FirstUParameter(),S2->LastUParameter(),
 513                 S2->IsUClosed(),S2->IsUPeriodic(),MS2[1],C2);
 514   }
 515   else if(isoS1isLine[0] && isoS2isLine[1] &&
 516           derS1[1].IsParallel(derS2[0],Precision::Angular())) {
 517     iso = 1;
 518     FUN_GetViso(gs1,T1,S1->FirstUParameter(),S1->LastUParameter(),
 519                 S1->IsUClosed(),S1->IsUPeriodic(),MS1[1],C1);
 520     FUN_GetUiso(gs2,T2,S2->FirstVParameter(),S2->LastVParameter(),
 521                 S2->IsVClosed(),S2->IsVPeriodic(),MS2[0],C2);
 522   }
 523   else if(isoS1isLine[1] && isoS2isLine[0] &&
 524           derS1[0].IsParallel(derS2[1],Precision::Angular())) {
 525     iso = 0;
 526     FUN_GetUiso(gs1,T1,S1->FirstVParameter(),S1->LastVParameter(),
 527                 S1->IsVClosed(),S1->IsVPeriodic(),MS1[0],C1);
 528     FUN_GetViso(gs2,T2,S2->FirstUParameter(),S2->LastUParameter(),
 529                 S2->IsUClosed(),S2->IsUPeriodic(),MS2[1],C2);
 530   }
 531   else if(isoS1isLine[1] && isoS2isLine[1] &&
 532           derS1[0].IsParallel(derS2[0],Precision::Angular())) {
 533     iso = 0;
 534     FUN_GetUiso(gs1,T1,S1->FirstVParameter(),S1->LastVParameter(),
 535                 S1->IsVClosed(),S1->IsVPeriodic(),MS1[0],C1);
 536     FUN_GetUiso(gs2,T2,S2->FirstVParameter(),S2->LastVParameter(),
 537                 S2->IsVClosed(),S2->IsVPeriodic(),MS2[0],C2);
 538   }
 539   else {
 540     IsOk = Standard_False;
 541     return;
 542   }
 543   IsOk = Standard_True;
 544   // 3. Make intersections of V(U)isos
 545   if(C1.IsNull() || C2.IsNull()) return;
 546   DV = derS1[iso];
 547   Handle(Geom_Plane) GPln = new Geom_Plane(gp_Pln(puvS1,gp_Dir(DV)));
 548   Handle(Geom_Curve) C1Prj =
 549     GeomProjLib::ProjectOnPlane(C1,GPln,gp_Dir(DV),Standard_True);
 550   Handle(Geom_Curve) C2Prj =
 551     GeomProjLib::ProjectOnPlane(C2,GPln,gp_Dir(DV),Standard_True);
 552   if(C1Prj.IsNull() || C2Prj.IsNull()) return;
 553   Handle(Geom2d_Curve) C1Prj2d =
 554     GeomProjLib::Curve2d(C1Prj,*(Handle_Geom_Surface *)&GPln);
 555   Handle(Geom2d_Curve) C2Prj2d =
 556     GeomProjLib::Curve2d(C2Prj,*(Handle_Geom_Surface *)&GPln);
 557   Geom2dAPI_InterCurveCurve ICC(C1Prj2d,C2Prj2d,1.0e-7);
 558   if(ICC.NbPoints() > 0 )
 559   {
 560     for(Standard_Integer ip = 1; ip <= ICC.NbPoints(); ip++)
 561         {
 562           gp_Pnt2d P = ICC.Point(ip);
 563           gp_Pnt P3d = ElCLib::To3d(gp_Ax2(puvS1,gp_Dir(DV)),P);
 564           SP.Append(P3d);
 565         }
 566   }
 567 }
 568 //================================================================================
 569 //function: FUN_NewFirstLast
 570 //================================================================================
 571 static void FUN_NewFirstLast(const GeomAbs_CurveType& ga_ct,
 572                              const Standard_Real&     Fst,
 573                              const Standard_Real&     Lst,
 574                              const Standard_Real&     TrVal,
 575                              Standard_Real&           NewFst,
 576                              Standard_Real&           NewLst,
 577                              Standard_Boolean&        NeedTr)
 578 {
 579   NewFst = Fst; NewLst = Lst; NeedTr = Standard_False;
 580   switch (ga_ct)
 581   {
 582     case GeomAbs_Line:
 583     case GeomAbs_Parabola:
 584     {
 585       if(Abs(Lst - Fst) > TrVal)
 586           {
 587             if(Fst >= 0. && Lst >= 0.)
 588         {
 589               NewFst = Fst;
 590               NewLst = ((Fst + TrVal) < Lst) ? (Fst + TrVal) : Lst;
 591             }
 592             if(Fst < 0. && Lst < 0.)
 593             {
 594               NewLst = Lst;
 595               NewFst = ((Lst - TrVal) > Fst) ? (Lst - TrVal) : Fst;
 596             }
 597             else
 598             {
 599               NewFst = (Fst < -TrVal) ? -TrVal : Fst;
 600               NewLst = (Lst > TrVal) ? TrVal : Lst;
 601             }
 602             NeedTr = Standard_True;
 603           }
 604           break;
 605     }
 606         case GeomAbs_Hyperbola:
 607     {
 608       if(Abs(Lst - Fst) > 10.)
 609           {
 610             if(Fst >= 0. && Lst >= 0.)
 611             {
 612               if(Fst > 4.) return;
 613               NewFst = Fst;
 614               NewLst = (Lst > 4.) ? 4. : Lst;
 615             }
 616             if(Fst < 0. && Lst < 0.)
 617             {
 618               if(Lst < -4.) return;
 619               NewLst = Lst;
 620               NewFst = (Fst < -4.) ? -4. : Fst;
 621             }
 622             else
 623             {
 624               NewFst = (Fst < -4.) ? -4. : Fst;
 625               NewLst = (Lst > 4.) ? 4. : Lst;
 626             }
 627             NeedTr = Standard_True;
 628           }
 629       break;
 630     }
 631   default:
 632     break;
 633   }
 634 }
 635 //================================================================================
 636 //function: FUN_TrimBothSurf
 637 //================================================================================
 638 static void FUN_TrimBothSurf(const Handle(Adaptor3d_HSurface)& S1,
 639                              const GeomAbs_SurfaceType&        T1,
 640                              const Handle(Adaptor3d_HSurface)& S2,
 641                              const GeomAbs_SurfaceType&        T2,
 642                              const Standard_Real&              TV,
 643                              Handle(Adaptor3d_HSurface)&       NS1,
 644                              Handle(Adaptor3d_HSurface)&       NS2)
 645 {
 646   const GeomAdaptor_Surface & gas1 = *(GeomAdaptor_Surface*)(&(S1->Surface()));
 647   const GeomAdaptor_Surface & gas2 = *(GeomAdaptor_Surface*)(&(S2->Surface()));
 648   const Handle(Geom_Surface) gs1 = gas1.Surface();
 649   const Handle(Geom_Surface) gs2 = gas2.Surface();
 650   const Standard_Real UM1 = 0.5 * (S1->LastUParameter() + S1->FirstUParameter());
 651   const Standard_Real UM2 = 0.5 * (S2->LastUParameter() + S2->FirstUParameter());
 652   const Standard_Real VM1 = 0.5 * (S1->LastVParameter() + S1->FirstVParameter());
 653   const Standard_Real VM2 = 0.5 * (S2->LastVParameter() + S2->FirstVParameter());
 654   Handle(Geom_Curve) visoS1, visoS2, uisoS1, uisoS2;
 655   if(T1 != GeomAbs_OffsetSurface){ visoS1 = gs1->VIso(VM1); uisoS1 = gs1->UIso(UM1); }
 656   else
 657   {
 658     const Handle(Geom_OffsetSurface) gos = *(Handle_Geom_OffsetSurface*)&gs1;
 659     const Handle(Geom_Surface) bs = gos->BasisSurface();
 660     visoS1 = bs->VIso(VM1); uisoS1 = bs->UIso(UM1);
 661   }
 662   if(T2 != GeomAbs_OffsetSurface){ visoS2 = gs2->VIso(VM2); uisoS2 = gs2->UIso(UM2); }
 663   else
 664   {
 665     const Handle(Geom_OffsetSurface) gos = *(Handle_Geom_OffsetSurface*)&gs2;
 666     const Handle(Geom_Surface) bs = gos->BasisSurface();
 667     visoS2 = bs->VIso(VM2); uisoS2 = bs->UIso(UM2);
 668   }
 669   if(uisoS1.IsNull() || uisoS2.IsNull() || visoS1.IsNull() || visoS2.IsNull()){ NS1 = S1; NS2 = S2; return; }
 670   GeomAdaptor_Curve gau1(uisoS1);
 671   GeomAdaptor_Curve gav1(visoS1);
 672   GeomAdaptor_Curve gau2(uisoS2);
 673   GeomAdaptor_Curve gav2(visoS2);
 674   GeomAbs_CurveType GA_U1 = gau1.GetType();
 675   GeomAbs_CurveType GA_V1 = gav1.GetType();
 676   GeomAbs_CurveType GA_U2 = gau2.GetType();
 677   GeomAbs_CurveType GA_V2 = gav2.GetType();
 678   Standard_Boolean TrmU1 = Standard_False;
 679   Standard_Boolean TrmV1 = Standard_False;
 680   Standard_Boolean TrmU2 = Standard_False;
 681   Standard_Boolean TrmV2 = Standard_False;
 682   Standard_Real V1S1,V2S1,U1S1,U2S1, V1S2,V2S2,U1S2,U2S2;
 683   FUN_NewFirstLast(GA_U1,S1->FirstVParameter(),S1->LastVParameter(),TV,V1S1,V2S1,TrmV1);
 684   FUN_NewFirstLast(GA_V1,S1->FirstUParameter(),S1->LastUParameter(),TV,U1S1,U2S1,TrmU1);
 685   FUN_NewFirstLast(GA_U2,S2->FirstVParameter(),S2->LastVParameter(),TV,V1S2,V2S2,TrmV2);
 686   FUN_NewFirstLast(GA_V2,S2->FirstUParameter(),S2->LastUParameter(),TV,U1S2,U2S2,TrmU2);
 687   if(TrmV1) NS1 = S1->VTrim(V1S1, V2S1, 1.0e-7);
 688   if(TrmV2) NS2 = S2->VTrim(V1S2, V2S2, 1.0e-7);
 689   if(TrmU1)
 690   {
 691     if(TrmV1)
 692         {
 693           Handle(Adaptor3d_HSurface) TS = NS1;
 694           NS1 = TS->UTrim(U1S1, U2S1, 1.0e-7);
 695         }
 696     else NS1 = S1->UTrim(U1S1, U2S1, 1.0e-7);
 697   }
 698   if(TrmU2)
 699   {
 700     if(TrmV2)
 701         {
 702           Handle(Adaptor3d_HSurface) TS = NS2;
 703           NS2 = TS->UTrim(U1S2, U2S2, 1.0e-7);
 704         }
 705     else NS2 = S2->UTrim(U1S2, U2S2, 1.0e-7);
 706   }
 707 }
 708
 709 //=======================================================================
 710 //function : Perform
 711 //purpose  :
 712 //=======================================================================
 713 void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)&  theS1,
 714                                     const Handle(Adaptor3d_TopolTool)& theD1,
 715                                     const Handle(Adaptor3d_HSurface)&  theS2,
 716                                     const Handle(Adaptor3d_TopolTool)& theD2,
 717                                     const Standard_Real TolArc,
 718                                     const Standard_Real TolTang,
 719                                     const Standard_Boolean isGeomInt)
 720 {
 721   myTolArc = TolArc;
 722   myTolTang = TolTang;
 723   if(myFleche <= Precision::PConfusion())
 724     myFleche = 0.01;
 725   if(myUVMaxStep <= Precision::PConfusion())
 726     myUVMaxStep = 0.01;
 727
 728   done = Standard_False;
 729   spnt.Clear();
 730   slin.Clear();
 731   empt = Standard_True;
 732   tgte = Standard_False;
 733   oppo = Standard_False;
 734
 735   GeomAbs_SurfaceType typs1 = theS1->GetType();
 736   GeomAbs_SurfaceType typs2 = theS2->GetType();
 737
 738   Standard_Boolean TreatAsBiParametric = Standard_False;
 739   if(typs1 == GeomAbs_Cone)
 740   {
 741     const gp_Cone Con1 = theS1->Cone();
 742     const Standard_Real a1 = Abs(Con1.SemiAngle());
 743     if((a1 < 0.02) || (a1 > 1.55))
 744     {
 745       if(typs2==GeomAbs_Plane)
 746       {
 747         if(a1 < 0.02)
 748         {
 749           const gp_Pln Plan2 = theS2->Plane();
 750           const gp_Dir axec = Con1.Axis().Direction();
 751           const gp_Dir axep = Plan2.Axis().Direction();
 752           const Standard_Real ps = Abs(axec.Dot(axep));
 753           if(ps < 0.015)
 754           {
 755             TreatAsBiParametric = Standard_True;
 756           }
 757         }
 758       }
 759       else
 760         TreatAsBiParametric = Standard_True;
 761     }
 762   }
 763
 764   if(typs2 == GeomAbs_Cone)
 765   {
 766     const gp_Cone Con2 = theS2->Cone();
 767     const Standard_Real a2 = Abs(Con2.SemiAngle());
 768     if((a2 < 0.02) || (a2 > 1.55))
 769     {
 770       if(typs1 == GeomAbs_Plane)
 771       {
 772         if(a2 < 0.02)
 773         {
 774           const gp_Pln Plan1 = theS1->Plane();
 775           const gp_Dir axec = Con2.Axis().Direction();
 776           const gp_Dir axep = Plan1.Axis().Direction();
 777           const Standard_Real ps = Abs(axec.Dot(axep));
 778           if(ps<0.015)
 779           {
 780             TreatAsBiParametric = Standard_True;
 781           }
 782         }
 783       }
 784       else
 785         TreatAsBiParametric = Standard_True;
 786     }
 787
 788     //// modified by jgv, 15.12.02 for OCC565 ////
 789     if (typs1 == GeomAbs_Cone && TreatAsBiParametric)
 790     {
 791       const gp_Cone Con1 = theS1->Cone();
 792       const Standard_Real a1 = Abs(Con1.SemiAngle());
 793       //if collinear, treat as canonical
 794       const gp_Ax1 A1 = Con1.Axis(), A2 = Con2.Axis();
 795       const gp_Lin L1(A1);
 796       if (A1.IsParallel(A2,Precision::Angular()) &&
 797          (L1.Distance(A2.Location()) <= Precision::Confusion()))
 798       {
 799         TreatAsBiParametric = Standard_False;
 800       }
 801       else if (a1 > 1.55 && a2 > 1.55) //quasi-planes: if same domain, treat as canonic
 802       {
 803         const gp_Ax1 A1 = Con1.Axis(), A2 = Con2.Axis();
 804         if (A1.IsParallel(A2,Precision::Angular()))
 805         {
 806           const gp_Pnt Apex1 = Con1.Apex(), Apex2 = Con2.Apex();
 807           const gp_Pln Plan1( Apex1, A1.Direction() );
 808           if (Plan1.Distance( Apex2 ) <= Precision::Confusion())
 809           {
 810             TreatAsBiParametric = Standard_False;
 811           }
 812         }
 813       }
 814     }// if (typs1 == GeomAbs_Cone)    {
 815   }// if(typs2 == GeomAbs_Cone)  {
 816
 817   if(theD1->DomainIsInfinite() || theD2->DomainIsInfinite()) {
 818     TreatAsBiParametric= Standard_False;
 819   }
 820
 821 //  Modified by skv - Mon Sep 26 14:58:30 2005 Begin
 822 //   if(TreatAsBiParametric) { typs1 = typs2 = GeomAbs_BezierSurface; }
 823   if(TreatAsBiParametric)
 824   {
 825     if (typs1 == GeomAbs_Cone && typs2 == GeomAbs_Plane)
 826       typs1 = GeomAbs_BezierSurface; // Using Imp-Prm Intersector
 827     else if (typs1 == GeomAbs_Plane && typs2 == GeomAbs_Cone)
 828       typs2 = GeomAbs_BezierSurface; // Using Imp-Prm Intersector
 829     else {
 830       // Using Prm-Prm Intersector
 831       typs1 = GeomAbs_BezierSurface;
 832       typs2 = GeomAbs_BezierSurface;
 833     }
 834   }
 835 //  Modified by skv - Mon Sep 26 14:58:30 2005 End
 836
 837   // Surface type definition
 838   Standard_Integer ts1 = 0;
 839   switch (typs1)
 840   {
 841     case GeomAbs_Plane:
 842     case GeomAbs_Cylinder:
 843     case GeomAbs_Sphere:
 844     case GeomAbs_Cone: ts1 = 1; break;
 845     default: break;
 846   }
 847
 848   Standard_Integer ts2 = 0;
 849   switch (typs2)
 850   {
 851     case GeomAbs_Plane:
 852     case GeomAbs_Cylinder:
 853     case GeomAbs_Sphere:
 854     case GeomAbs_Cone: ts2 = 1; break;
 855     default: break;
 856   }
 857
 858   // Possible intersection types: 1. ts1 == ts2 == 1 <Geom-Geom>
 859   //                              2. ts1 != ts2      <Geom-Param>
 860   //                              3. ts1 == ts2 == 0 <Param-Param>
 861
 862   // Geom - Geom
 863   if(ts1 == ts2 && ts1 == 1)
 864   {
 865     const Standard_Boolean RestrictLine = Standard_True;
 866     IntSurf_ListOfPntOn2S ListOfPnts;
 867     ListOfPnts.Clear();
 868     if(isGeomInt)
 869     {
 870       GeomGeomPerfom(theS1, theD1, theS2, theD2, TolArc, TolTang, ListOfPnts, RestrictLine, typs1, typs2);
 871     }
 872     else
 873     {
 874       ParamParamPerfom(theS1, theD1, theS2, theD2, TolArc, TolTang, ListOfPnts, RestrictLine, typs1, typs2);
 875     }
 876   }
 877
 878   // Geom - Param
 879   if(ts1 != ts2)
 880   {
 881     GeomParamPerfom(theS1, theD1, theS2, theD2, ts1 == 0, typs1, typs2);
 882   }
 883
 884   // Param - Param
 885   if(ts1 == ts2 && ts1 == 0)
 886   {
 887     const Standard_Boolean RestrictLine = Standard_True;
 888     IntSurf_ListOfPntOn2S ListOfPnts;
 889     ListOfPnts.Clear();
 890
 891     ParamParamPerfom(theS1, theD1, theS2, theD2, TolArc, TolTang, ListOfPnts, RestrictLine, typs1, typs2);
 892   }
 893 }
 894
 895 //=======================================================================
 896 //function : Perform
 897 //purpose  :
 898 //=======================================================================
 899 void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)&  theS1,
 900                                     const Handle(Adaptor3d_TopolTool)& theD1,
 901                                     const Handle(Adaptor3d_HSurface)&  theS2,
 902                                     const Handle(Adaptor3d_TopolTool)& theD2,
 903                                     const Standard_Real TolArc,
 904                                     const Standard_Real TolTang,
 905                                     IntSurf_ListOfPntOn2S& ListOfPnts,
 906                                     const Standard_Boolean RestrictLine,
 907                                     const Standard_Boolean isGeomInt)
 908 {
 909   myTolArc = TolArc;
 910   myTolTang = TolTang;
 911   if(myFleche <= Precision::PConfusion())
 912     myFleche = 0.01;
 913   if(myUVMaxStep <= Precision::PConfusion())
 914     myUVMaxStep = 0.01;
 915
 916   done = Standard_False;
 917   spnt.Clear();
 918   slin.Clear();
 919   empt = Standard_True;
 920   tgte = Standard_False;
 921   oppo = Standard_False;
 922
 923   GeomAbs_SurfaceType typs1 = theS1->GetType();
 924   GeomAbs_SurfaceType typs2 = theS2->GetType();
 925
 926   Standard_Boolean TreatAsBiParametric = Standard_False;
 927   if(typs1 == GeomAbs_Cone)
 928   {
 929     const gp_Cone Con1 = theS1->Cone();
 930     const Standard_Real a1 = Abs(Con1.SemiAngle());
 931     if((a1 < 0.02) || (a1 > 1.55))
 932     {
 933       if(typs2==GeomAbs_Plane)
 934       {
 935         if(a1 < 0.02)
 936         {
 937           const gp_Pln Plan2 = theS2->Plane();
 938           const gp_Dir axec = Con1.Axis().Direction();
 939           const gp_Dir axep = Plan2.Axis().Direction();
 940           const Standard_Real ps = Abs(axec.Dot(axep));
 941           if(ps < 0.015)
 942           {
 943             TreatAsBiParametric = Standard_True;
 944           }
 945         }
 946       }
 947       else
 948         TreatAsBiParametric = Standard_True;
 949     }
 950   }
 951
 952   if(typs2 == GeomAbs_Cone)
 953   {
 954     const gp_Cone Con2 = theS2->Cone();
 955     const Standard_Real a2 = Abs(Con2.SemiAngle());
 956     if((a2 < 0.02) || (a2 > 1.55))
 957     {
 958       if(typs1 == GeomAbs_Plane)
 959       {
 960         if(a2 < 0.02)
 961         {
 962           const gp_Pln Plan1 = theS1->Plane();
 963           const gp_Dir axec = Con2.Axis().Direction();
 964           const gp_Dir axep = Plan1.Axis().Direction();
 965           const Standard_Real ps = Abs(axec.Dot(axep));
 966           if(ps<0.015)
 967           {
 968             TreatAsBiParametric = Standard_True;
 969           }
 970         }
 971       }
 972       else
 973         TreatAsBiParametric = Standard_True;
 974     }
 975
 976     //// modified by jgv, 15.12.02 for OCC565 ////
 977     if (typs1 == GeomAbs_Cone && TreatAsBiParametric)
 978     {
 979       const gp_Cone Con1 = theS1->Cone();
 980       const Standard_Real a1 = Abs(Con1.SemiAngle());
 981       //if collinear, treat as canonical
 982       const gp_Ax1 A1 = Con1.Axis(), A2 = Con2.Axis();
 983       const gp_Lin L1(A1);
 984       if (A1.IsParallel(A2,Precision::Angular()) &&
 985          (L1.Distance(A2.Location()) <= Precision::Confusion()))
 986       {
 987         TreatAsBiParametric = Standard_False;
 988       }
 989       else if (a1 > 1.55 && a2 > 1.55) //quasi-planes: if same domain, treat as canonic
 990       {
 991         const gp_Ax1 A1 = Con1.Axis(), A2 = Con2.Axis();
 992         if (A1.IsParallel(A2,Precision::Angular()))
 993         {
 994           const gp_Pnt Apex1 = Con1.Apex(), Apex2 = Con2.Apex();
 995           const gp_Pln Plan1( Apex1, A1.Direction() );
 996           if (Plan1.Distance( Apex2 ) <= Precision::Confusion())
 997           {
 998             TreatAsBiParametric = Standard_False;
 999           }
1000         }
1001       }
1002     }// if (typs1 == GeomAbs_Cone)    {
1003   }// if(typs2 == GeomAbs_Cone)  {
1004
1005   if(theD1->DomainIsInfinite() || theD2->DomainIsInfinite()) {
1006     TreatAsBiParametric= Standard_False;
1007   }
1008
1009   if(TreatAsBiParametric)
1010   {
1011     // Using Prm-Prm Intersector
1012     typs1 = GeomAbs_BezierSurface;
1013     typs2 = GeomAbs_BezierSurface;
1014   }
1015
1016   // Surface type definition
1017   Standard_Integer ts1 = 0;
1018   switch (typs1)
1019   {
1020     case GeomAbs_Plane:
1021     case GeomAbs_Cylinder:
1022     case GeomAbs_Sphere:
1023     case GeomAbs_Cone: ts1 = 1; break;
1024     default: break;
1025   }
1026
1027   Standard_Integer ts2 = 0;
1028   switch (typs2)
1029   {
1030     case GeomAbs_Plane:
1031     case GeomAbs_Cylinder:
1032     case GeomAbs_Sphere:
1033     case GeomAbs_Cone: ts2 = 1; break;
1034     default: break;
1035   }
1036
1037   // Possible intersection types: 1. ts1 == ts2 == 1 <Geom-Geom>
1038   //                              2. ts1 != ts2      <Geom-Param>
1039   //                              3. ts1 == ts2 == 0 <Param-Param>
1040
1041   if(!isGeomInt)
1042   {
1043     ParamParamPerfom(theS1, theD1, theS2, theD2, TolArc, TolTang, ListOfPnts, RestrictLine, typs1, typs2);
1044   }
1045   else if(ts1 != ts2)
1046   {
1047     GeomParamPerfom(theS1, theD1, theS2, theD2, ts1 == 0, typs1, typs2);
1048   }
1049   else if (ts1 == 0)
1050   {
1051     ParamParamPerfom(theS1, theD1, theS2, theD2, TolArc, TolTang, ListOfPnts, RestrictLine, typs1, typs2);
1052   }
1053   else if(ts1 == 1)
1054   {
1055     GeomGeomPerfom(theS1, theD1, theS2, theD2, TolArc, TolTang, ListOfPnts, RestrictLine, typs1, typs2);
1056   }
1057 }
1058
1059 //=======================================================================
1060 //function : ParamParamPerfom
1061 //purpose  :
1062 //=======================================================================
1063 void IntPatch_Intersection::ParamParamPerfom(const Handle(Adaptor3d_HSurface)&  theS1,
1064                                              const Handle(Adaptor3d_TopolTool)& theD1,
1065                                              const Handle(Adaptor3d_HSurface)&  theS2,
1066                                              const Handle(Adaptor3d_TopolTool)& theD2,
1067                                              const Standard_Real TolArc,
1068                                              const Standard_Real TolTang,
1069                                              IntSurf_ListOfPntOn2S& ListOfPnts,
1070                                              const Standard_Boolean RestrictLine,
1071                                              const GeomAbs_SurfaceType typs1,
1072                                              const GeomAbs_SurfaceType typs2)
1073 {
1074   IntPatch_PrmPrmIntersection interpp;
1075   if(!theD1->DomainIsInfinite() && !theD2->DomainIsInfinite())
1076   {
1077     Standard_Boolean ClearFlag = Standard_True;
1078     if(!ListOfPnts.IsEmpty())
1079     {
1080       interpp.Perform(theS1,theD1,theS2,theD2,TolArc,TolTang,myFleche,myUVMaxStep, ListOfPnts, RestrictLine);
1081       ClearFlag = Standard_False;
1082     }
1083     interpp.Perform(theS1,theD1,theS2,theD2,TolArc,TolTang,myFleche,myUVMaxStep,ClearFlag);   //double call!!!!!!!
1084   }
1085   else if((theD1->DomainIsInfinite()) ^ (theD2->DomainIsInfinite()))
1086   {
1087     gp_Pnt pMaxXYZ, pMinXYZ;
1088     if(theD1->DomainIsInfinite())
1089     {
1090       FUN_GetMinMaxXYZPnt( theS2, pMinXYZ, pMaxXYZ );
1091       const Standard_Real MU = Max(Abs(theS2->FirstUParameter()),Abs(theS2->LastUParameter()));
1092       const Standard_Real MV = Max(Abs(theS2->FirstVParameter()),Abs(theS2->LastVParameter()));
1093       const Standard_Real AP = Max(MU, MV);
1094       Handle(Adaptor3d_HSurface) SS;
1095       FUN_TrimInfSurf(pMinXYZ, pMaxXYZ, theS1, AP, SS);
1096       interpp.Perform(SS,theD1,theS2,theD2,TolArc,TolTang,myFleche,myUVMaxStep);
1097     }
1098     else
1099     {
1100       FUN_GetMinMaxXYZPnt( theS1, pMinXYZ, pMaxXYZ );
1101       const Standard_Real MU = Max(Abs(theS1->FirstUParameter()),Abs(theS1->LastUParameter()));
1102       const Standard_Real MV = Max(Abs(theS1->FirstVParameter()),Abs(theS1->LastVParameter()));
1103       const Standard_Real AP = Max(MU, MV);
1104       Handle(Adaptor3d_HSurface) SS;
1105       FUN_TrimInfSurf(pMinXYZ, pMaxXYZ, theS2, AP, SS);
1106       interpp.Perform(theS1, theD1, SS, theD2,TolArc,TolTang,myFleche,myUVMaxStep);
1107     }
1108   }//(theD1->DomainIsInfinite()) ^ (theD2->DomainIsInfinite())
1109   else
1110   {
1111     if(typs1 == GeomAbs_OtherSurface || typs2 == GeomAbs_OtherSurface)
1112     {
1113       done = Standard_False;
1114       return;
1115     }
1116
1117     Standard_Boolean IsPLInt = Standard_False;
1118     TColgp_SequenceOfPnt sop;
1119     gp_Vec v;
1120     FUN_PL_Intersection(theS1,typs1,theS2,typs2,IsPLInt,sop,v);
1121
1122     if(IsPLInt)
1123     {
1124       if(sop.Length() > 0)
1125       {
1126         for(Standard_Integer ip = 1; ip <= sop.Length(); ip++)
1127         {
1128           gp_Lin lin(sop.Value(ip),gp_Dir(v));
1129           Handle(IntPatch_GLine) gl = new IntPatch_GLine(lin,Standard_False);
1130           slin.Append(*(Handle_IntPatch_Line *)&gl);
1131         }
1132
1133         done = Standard_True;
1134       }
1135       else
1136         done = Standard_False;
1137
1138       return;
1139     }// 'COLLINEAR LINES'
1140     else
1141     {
1142       Handle(Adaptor3d_HSurface) nS1 = theS1;
1143       Handle(Adaptor3d_HSurface) nS2 = theS2;
1144       FUN_TrimBothSurf(theS1,typs1,theS2,typs2,1.e+8,nS1,nS2);
1145       interpp.Perform(nS1,theD1,nS2,theD2,TolArc,TolTang,myFleche,myUVMaxStep);
1146     }// 'NON - COLLINEAR LINES'
1147   }// both domains are infinite
1148
1149   if (interpp.IsDone())
1150   {
1151     done = Standard_True;
1152     tgte = Standard_False;
1153     empt = interpp.IsEmpty();
1154
1155     for(Standard_Integer i = 1; i <= interpp.NbLines(); i++)
1156     {
1157       if(interpp.Line(i)->ArcType() != IntPatch_Walking)
1158         slin.Append(interpp.Line(i));
1159     }
1160
1161     for (Standard_Integer i = 1; i <= interpp.NbLines(); i++)
1162     {
1163       if(interpp.Line(i)->ArcType() == IntPatch_Walking)
1164         slin.Append(interpp.Line(i));
1165     }
1166   }
1167 }
1168
1169 //=======================================================================
1170 ////function : GeomGeomPerfom
1171 //purpose  :
1172 //=======================================================================
1173 void IntPatch_Intersection::GeomGeomPerfom(const Handle(Adaptor3d_HSurface)& theS1,
1174                                            const Handle(Adaptor3d_TopolTool)& theD1,
1175                                            const Handle(Adaptor3d_HSurface)& theS2,
1176                                            const Handle(Adaptor3d_TopolTool)& theD2,
1177                                            const Standard_Real TolArc,
1178                                            const Standard_Real TolTang,
1179                                            IntSurf_ListOfPntOn2S& ListOfPnts,
1180                                            const Standard_Boolean RestrictLine,
1181                                            const GeomAbs_SurfaceType typs1,
1182                                            const GeomAbs_SurfaceType typs2)
1183 {
1184   IntPatch_ImpImpIntersection interii(theS1,theD1,theS2,theD2,myTolArc,myTolTang);
1185   const Standard_Boolean anIS = interii.IsDone();
1186   if (anIS)
1187   {
1188     done = anIS;
1189     empt = interii.IsEmpty();
1190     if (!empt)
1191     {
1192       tgte = interii.TangentFaces();
1193       if (tgte)
1194         oppo = interii.OppositeFaces();
1195
1196       for (Standard_Integer i = 1; i <= interii.NbLines(); i++)
1197       {
1198         const Handle_IntPatch_Line& line = interii.Line(i);
1199         if (line->ArcType() == IntPatch_Analytic)
1200         {
1201           const GeomAbs_SurfaceType typs1 = theS1->GetType();
1202           const GeomAbs_SurfaceType typs2 = theS2->GetType();
1203           IntSurf_Quadric Quad1,Quad2;
1204
1205           switch(typs1)
1206           {
1207           case GeomAbs_Plane:
1208             Quad1.SetValue(theS1->Plane());
1209             break;
1210
1211           case GeomAbs_Cylinder:
1212             Quad1.SetValue(theS1->Cylinder());
1213             break;
1214
1215           case GeomAbs_Sphere:
1216             Quad1.SetValue(theS1->Sphere());
1217             break;
1218
1219           case GeomAbs_Cone:
1220             Quad1.SetValue(theS1->Cone());
1221             break;
1222
1223           default:
1224             break;
1225           }
1226
1227           switch(typs2)
1228           {
1229           case GeomAbs_Plane:
1230             Quad2.SetValue(theS2->Plane());
1231             break;
1232           case GeomAbs_Cylinder:
1233             Quad2.SetValue(theS2->Cylinder());
1234             break;
1235
1236           case GeomAbs_Sphere:
1237             Quad2.SetValue(theS2->Sphere());
1238             break;
1239
1240           case GeomAbs_Cone:
1241             Quad2.SetValue(theS2->Cone());
1242             break;
1243
1244           default:
1245             break;
1246           }
1247
1248           IntPatch_ALineToWLine AToW(Quad1,Quad2,0.01,0.05,aNbPointsInALine);
1249           Handle(IntPatch_Line) wlin=AToW.MakeWLine((*((Handle_IntPatch_ALine *)(&line))));
1250           slin.Append(wlin);
1251         }
1252         else
1253           slin.Append(interii.Line(i));
1254       }
1255
1256       for (Standard_Integer i = 1; i <= interii.NbPnts(); i++)
1257       {
1258         spnt.Append(interii.Point(i));
1259       }
1260     }
1261   }
1262   else
1263     ParamParamPerfom(theS1, theD1, theS2, theD2, TolArc, TolTang, ListOfPnts, RestrictLine, typs1, typs2);
1264 }
1265
1266 //=======================================================================
1267 ////function : GeomParamPerfom
1268 //purpose  :
1269 //=======================================================================
1270 void IntPatch_Intersection::GeomParamPerfom(const Handle(Adaptor3d_HSurface)&  theS1,
1271                                             const Handle(Adaptor3d_TopolTool)& theD1,
1272                                             const Handle(Adaptor3d_HSurface)&  theS2,
1273                                             const Handle(Adaptor3d_TopolTool)& theD2,
1274                                             const Standard_Boolean isNotAnalitical,
1275                                             const GeomAbs_SurfaceType typs1,
1276                                             const GeomAbs_SurfaceType typs2)
1277 {
1278   IntPatch_ImpPrmIntersection interip;
1279   if (myIsStartPnt)
1280   {
1281     if (isNotAnalitical/*ts1 == 0*/)
1282       interip.SetStartPoint(myU1Start,myV1Start);
1283     else
1284       interip.SetStartPoint(myU2Start,myV2Start);
1285   }
1286
1287   if(theD1->DomainIsInfinite() && theD2->DomainIsInfinite())
1288   {
1289     Standard_Boolean IsPLInt = Standard_False;
1290     TColgp_SequenceOfPnt sop;
1291     gp_Vec v;
1292     FUN_PL_Intersection(theS1,typs1,theS2,typs2,IsPLInt,sop,v);
1293
1294     if(IsPLInt)
1295     {
1296       if(sop.Length() > 0)
1297       {
1298         for(Standard_Integer ip = 1; ip <= sop.Length(); ip++)
1299         {
1300           gp_Lin lin(sop.Value(ip),gp_Dir(v));
1301           Handle(IntPatch_GLine) gl = new IntPatch_GLine(lin,Standard_False);
1302           slin.Append(*(Handle_IntPatch_Line *)&gl);
1303         }
1304
1305         done = Standard_True;
1306       }
1307       else
1308         done = Standard_False;
1309
1310       return;
1311     }
1312     else
1313     {
1314       Handle(Adaptor3d_HSurface) nS1 = theS1;
1315       Handle(Adaptor3d_HSurface) nS2 = theS2;
1316       FUN_TrimBothSurf(theS1,typs1,theS2,typs2,1.e+5,nS1,nS2);
1317       interip.Perform(nS1,theD1,nS2,theD2,myTolArc,myTolTang,myFleche,myUVMaxStep);
1318     }
1319   }
1320   else
1321     interip.Perform(theS1,theD1,theS2,theD2,myTolArc,myTolTang,myFleche,myUVMaxStep);
1322
1323   if (interip.IsDone())
1324   {
1325     done = Standard_True;
1326     empt = interip.IsEmpty();
1327
1328     if (!empt)
1329     {
1330       for(Standard_Integer i = 1; i <= interip.NbLines(); i++)
1331       {
1332         if(interip.Line(i)->ArcType() != IntPatch_Walking)
1333           slin.Append(interip.Line(i));
1334       }
1335
1336       for(Standard_Integer i = 1; i <= interip.NbLines(); i++)
1337       {
1338         if(interip.Line(i)->ArcType() == IntPatch_Walking)
1339           slin.Append(interip.Line(i));
1340       }
1341
1342       for (Standard_Integer i = 1; i <= interip.NbPnts(); i++)
1343         spnt.Append(interip.Point(i));
1344     }
1345   }
1346 }
1347
1348
1349 void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)&  S1,
1350                                     const Handle(Adaptor3d_TopolTool)& D1,
1351                                     const Handle(Adaptor3d_HSurface)&  S2,
1352                                     const Handle(Adaptor3d_TopolTool)& D2,
1353                                     const Standard_Real U1,
1354                                     const Standard_Real V1,
1355                                     const Standard_Real U2,
1356                                     const Standard_Real V2,
1357                                     const Standard_Real TolArc,
1358                                     const Standard_Real TolTang)
1359 {
1360   myTolArc = TolArc;
1361   myTolTang = TolTang;
1362   if(myFleche == 0.0) {
1363 #if DEBUG
1364     //cout<<" -- IntPatch_Intersection::myFleche fixe par defaut a 0.01 --"<<endl;
1365     //cout<<" -- Utiliser la Methode SetTolerances( ... ) "<<endl;
1366 #endif
1367     myFleche = 0.01;
1368   }
1369   if(myUVMaxStep==0.0) {
1370 #if DEBUG
1371     //cout<<" -- IntPatch_Intersection::myUVMaxStep fixe par defaut a 0.01 --"<<endl;
1372     //cout<<" -- Utiliser la Methode SetTolerances( ... ) "<<endl;
1373 #endif
1374     myUVMaxStep = 0.01;
1375   }
1376
1377   done = Standard_False;
1378   spnt.Clear();
1379   slin.Clear();
1380
1381   empt = Standard_True;
1382   tgte = Standard_False;
1383   oppo = Standard_False;
1384
1385   const GeomAbs_SurfaceType typs1 = S1->GetType();
1386   const GeomAbs_SurfaceType typs2 = S2->GetType();
1387
1388   if(   typs1==GeomAbs_Plane
1389      || typs1==GeomAbs_Cylinder
1390      || typs1==GeomAbs_Sphere
1391      || typs1==GeomAbs_Cone
1392      || typs2==GeomAbs_Plane
1393      || typs2==GeomAbs_Cylinder
1394      || typs2==GeomAbs_Sphere
1395      || typs2==GeomAbs_Cone)
1396   {
1397     myIsStartPnt = Standard_True;
1398     myU1Start = U1; myV1Start = V1; myU2Start = U2; myV2Start = V2;
1399     Perform(S1,D1,S2,D2,TolArc,TolTang);
1400     myIsStartPnt = Standard_False;
1401   }
1402   else
1403   {
1404     IntPatch_PrmPrmIntersection interpp;
1405     interpp.Perform(S1,D1,S2,D2,U1,V1,U2,V2,TolArc,TolTang,myFleche,myUVMaxStep);
1406     if (interpp.IsDone())
1407         {
1408       done = Standard_True;
1409       tgte = Standard_False;
1410       empt = interpp.IsEmpty();
1411       const Standard_Integer nblm = interpp.NbLines();
1412       Standard_Integer i = 1;
1413       for (; i<=nblm; i++) slin.Append(interpp.Line(i));
1414     }
1415   }
1416 }
1417 //======================================================================
1418 #include <IntPatch_IType.hxx>
1419 #include <IntPatch_LineConstructor.hxx>
1420 #include <Handle_Adaptor2d_HCurve2d.hxx>
1421 #define MAXR 200
1422
1423
1424 //void IntPatch_Intersection__MAJ_R(Handle_Adaptor2d_HCurve2d *R1,
1425 //                                   Handle_Adaptor2d_HCurve2d *R2,
1426 //                                   int *NR1,
1427 //                                   int *NR2,
1428 //                                   Standard_Integer nbR1,
1429 //                                   Standard_Integer nbR2,
1430 //                                   const IntPatch_Point& VTX)
1431 void IntPatch_Intersection__MAJ_R(Handle_Adaptor2d_HCurve2d *,
1432                                      Handle_Adaptor2d_HCurve2d *,
1433                                      int *,
1434                                      int *,
1435                                      Standard_Integer ,
1436                                      Standard_Integer ,
1437                                      const IntPatch_Point& )
1438 {
1439   /*
1440   if(VTX.IsOnDomS1()) {
1441
1442     //-- long unsigned ptr= *((long unsigned *)(((Handle_Standard_Transient *)(&(VTX.ArcOnS1())))));
1443     for(Standard_Integer i=0; i<nbR1;i++) {
1444       if(VTX.ArcOnS1()==R1[i]) {
1445         NR1[i]++;
1446         printf("\n ******************************");
1447         return;
1448       }
1449     }
1450     printf("\n R Pas trouvee  (IntPatch)\n");
1451
1452   }
1453   */
1454 }
1455
1456
1457 //void IntPatch_Intersection::Dump(const Standard_Integer Mode,
1458 void IntPatch_Intersection::Dump(const Standard_Integer ,
1459                                     const Handle(Adaptor3d_HSurface)&  S1,
1460                                     const Handle(Adaptor3d_TopolTool)& D1,
1461                                     const Handle(Adaptor3d_HSurface)&  S2,
1462                                     const Handle(Adaptor3d_TopolTool)& D2) const
1463 {
1464
1465   //-- ----------------------------------------------------------------------
1466   //--  construction de la liste des restrictions & vertex
1467   //--
1468   int NR1[MAXR],NR2[MAXR];
1469   Handle_Adaptor2d_HCurve2d R1[MAXR],R2[MAXR];
1470   Standard_Integer nbR1=0,nbR2=0;
1471   for(D1->Init();D1->More() && nbR1<MAXR; D1->Next()) {
1472     R1[nbR1]=D1->Value();
1473     NR1[nbR1]=0;
1474     nbR1++;
1475   }
1476   for(D2->Init();D2->More() && nbR2<MAXR; D2->Next()) {
1477     R2[nbR2]=D2->Value();
1478     NR2[nbR2]=0;
1479     nbR2++;
1480   }
1481
1482   printf("\nDUMP_INT:  ----empt:%2ud  tgte:%2ud  oppo:%2ud ---------------------------------",empt,tgte,empt);
1483   Standard_Integer i,j,nbr1,nbr2,nbgl,nbgc,nbge,nbgp,nbgh,nbl,nbr,nbg,nbw,nba;
1484   nbl=nbr=nbg=nbw=nba=nbgl=nbge=nbr1=nbr2=nbgc=nbgp=nbgh=0;
1485   nbl=NbLines();
1486   for(i=1;i<=nbl;i++) {
1487     const Handle(IntPatch_Line)& line=Line(i);
1488     const IntPatch_IType IType=line->ArcType();
1489     if(IType == IntPatch_Walking) nbw++;
1490     else     if(IType == IntPatch_Restriction) {
1491       nbr++;
1492       Handle(IntPatch_RLine)& rlin =
1493         *((Handle(IntPatch_RLine) *)&line);
1494       if(rlin->IsArcOnS1()) nbr1++;
1495       if(rlin->IsArcOnS2()) nbr2++;
1496     }
1497     else     if(IType == IntPatch_Analytic) nba++;
1498     else     { nbg++;
1499                if(IType == IntPatch_Lin) nbgl++;
1500                else if(IType == IntPatch_Circle) nbgc++;
1501                else if(IType == IntPatch_Parabola) nbgp++;
1502                else if(IType == IntPatch_Hyperbola) nbgh++;
1503                else if(IType == IntPatch_Ellipse) nbge++;
1504              }
1505   }
1506
1507
1508   printf("\nDUMP_INT:Lines:%2d Wlin:%2d Restr:%2d(On1:%2d On2:%2d) Ana:%2d Geom:%2d(L:%2d C:%2d E:%2d H:%2d P:%2d)",
1509          nbl,nbw,nbr,nbr1,nbr2,nba,nbg,nbgl,nbgc,nbge,nbgh,nbgp);
1510
1511   IntPatch_LineConstructor LineConstructor(2);
1512
1513   Standard_Integer nbllc=0;
1514   nbw=nbr=nbg=nba=0;
1515   Standard_Integer nbva,nbvw,nbvr,nbvg;
1516   nbva=nbvr=nbvw=nbvg=0;
1517   for (j=1; j<=nbl; j++) {
1518     Standard_Integer v,nbvtx;
1519     const Handle(IntPatch_Line)& intersLinej = Line(j);
1520     Standard_Integer NbLines;
1521     LineConstructor.Perform(SequenceOfLine(),intersLinej,S1,D1,S2,D2,1e-7);
1522     NbLines = LineConstructor.NbLines();
1523
1524     for(Standard_Integer k=1;k<=NbLines;k++) {
1525       nbllc++;
1526       const Handle(IntPatch_Line)& LineK = LineConstructor.Line(k);
1527       if (LineK->ArcType() == IntPatch_Analytic) {
1528         Handle(IntPatch_ALine)& alin =
1529           *((Handle(IntPatch_ALine) *)&LineK);
1530         nbvtx=alin->NbVertex();
1531         nbva+=nbvtx;    nba++;
1532         for(v=1;v<=nbvtx;v++) {
1533           IntPatch_Intersection__MAJ_R(R1,R2,NR1,NR2,nbR1,nbR2,alin->Vertex(v));
1534         }
1535       }
1536       else if (LineK->ArcType() == IntPatch_Restriction) {
1537         Handle(IntPatch_RLine)& rlin =
1538           *((Handle(IntPatch_RLine) *)&LineK);
1539         nbvtx=rlin->NbVertex();
1540         nbvr+=nbvtx;    nbr++;
1541         for(v=1;v<=nbvtx;v++) {
1542           IntPatch_Intersection__MAJ_R(R1,R2,NR1,NR2,nbR1,nbR2,rlin->Vertex(v));
1543         }
1544       }
1545       else if (LineK->ArcType() == IntPatch_Walking) {
1546         Handle(IntPatch_WLine)& wlin =
1547           *((Handle(IntPatch_WLine) *)&LineK);
1548         nbvtx=wlin->NbVertex();
1549         nbvw+=nbvtx;    nbw++;
1550         for(v=1;v<=nbvtx;v++) {
1551           IntPatch_Intersection__MAJ_R(R1,R2,NR1,NR2,nbR1,nbR2,wlin->Vertex(v));
1552         }
1553       }
1554       else {
1555         Handle(IntPatch_GLine)& glin =
1556           *((Handle(IntPatch_GLine) *)&LineK);
1557         nbvtx=glin->NbVertex();
1558         nbvg+=nbvtx;    nbg++;
1559         for(v=1;v<=nbvtx;v++) {
1560           IntPatch_Intersection__MAJ_R(R1,R2,NR1,NR2,nbR1,nbR2,glin->Vertex(v));
1561         }
1562       }
1563     }
1564   }
1565   printf("\nDUMP_LC :Lines:%2d WLin:%2d Restr:%2d Ana:%2d Geom:%2d",
1566          nbllc,nbw,nbr,nba,nbg);
1567   printf("\nDUMP_LC :vtx          :%2d     r:%2d    :%2d     :%2d",
1568          nbvw,nbvr,nbva,nbvg);
1569
1570
1571
1572    printf("\n");
1573 }