src/IntPatch/IntPatch_Intersection.cxx

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