src/BRepTools/BRepTools_NurbsConvertModification.cxx

   1 // Created on: 1996-07-12
   2 // Created by: Stagiaire Mary FABIEN
   3 // Copyright (c) 1996-1999 Matra Datavision
   4 // Copyright (c) 1999-2012 OPEN CASCADE SAS
   5 //
   6 // The content of this file is subject to the Open CASCADE Technology Public
   7 // License Version 6.5 (the "License"). You may not use the content of this file
   8 // except in compliance with the License. Please obtain a copy of the License
   9 // at http://www.opencascade.org and read it completely before using this file.
  10 //
  11 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
  12 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
  13 //
  14 // The Original Code and all software distributed under the License is
  15 // distributed on an "AS IS" basis, without warranty of any kind, and the
  16 // Initial Developer hereby disclaims all such warranties, including without
  17 // limitation, any warranties of merchantability, fitness for a particular
  18 // purpose or non-infringement. Please see the License for the specific terms
  19 // and conditions governing the rights and limitations under the License.
  20
  21
  22
  23 #include <BRepTools_NurbsConvertModification.ixx>
  24
  25 #include <BRepTools.hxx>
  26 #include <Standard_NoSuchObject.hxx>
  27 #include <Geom_TrimmedCurve.hxx>
  28 #include <Geom2d_TrimmedCurve.hxx>
  29 #include <Geom_RectangularTrimmedSurface.hxx>
  30 #include <Geom_BSplineSurface.hxx>
  31 #include <Geom_BSplineCurve.hxx>
  32 #include <Geom_BezierSurface.hxx>
  33 #include <Geom_BezierCurve.hxx>
  34 #include <Geom2d_BSplineCurve.hxx>
  35 #include <GeomConvert.hxx>
  36 #include <Geom2dConvert.hxx>
  37 #include <Geom_Plane.hxx>
  38 #include <Geom_Line.hxx>
  39 #include <Geom2dAdaptor_Curve.hxx>
  40 #include <GeomAdaptor_Curve.hxx>
  41 #include <GeomAdaptor_Surface.hxx>
  42 #include <Geom2dAdaptor_HCurve.hxx>
  43 #include <Geom2dAdaptor_HCurve.hxx>
  44 #include <GeomAdaptor_HCurve.hxx>
  45 #include <GeomAdaptor_HSurface.hxx>
  46
  47 #include <BSplCLib.hxx>
  48 #include <Approx_SameParameter.hxx>
  49 #include <BRep_Tool.hxx>
  50 #include <Extrema_LocateExtPC.hxx>
  51 #include <OSD_Chronometer.hxx>
  52 #include <gp_GTrsf2d.hxx>
  53 #include <gp_TrsfForm.hxx>
  54 #include <TopAbs.hxx>
  55 #include <TopoDS.hxx>
  56 #include <TopTools_ListIteratorOfListOfShape.hxx>
  57 #include <TColStd_ListIteratorOfListOfTransient.hxx>
  58 #include <ProjLib_ComputeApprox.hxx>
  59 #include <ProjLib_ComputeApproxOnPolarSurface.hxx>
  60 #include <ElSLib.hxx>
  61 #include <BSplCLib.hxx>
  62 #include <Geom_Circle.hxx>
  63 #include <Geom_Ellipse.hxx>
  64 #include <Geom_CylindricalSurface.hxx>
  65
  66 #include <TColStd_Array1OfReal.hxx>
  67 #include <BRep_TEdge.hxx>
  68 #include <BRep_GCurve.hxx>
  69 #include <BRep_ListIteratorOfListOfCurveRepresentation.hxx>
  70
  71 static void GeomLib_ChangeUBounds(Handle(Geom_BSplineSurface)& aSurface,
  72                                   const Standard_Real newU1,
  73                                   const Standard_Real newU2)
  74 {
  75   TColStd_Array1OfReal  knots(1,aSurface->NbUKnots()) ;
  76   aSurface->UKnots(knots) ;
  77   BSplCLib::Reparametrize(newU1,
  78                           newU2,
  79                           knots) ;
  80   aSurface->SetUKnots(knots) ;
  81 }
  82 static void GeomLib_ChangeVBounds(Handle(Geom_BSplineSurface)& aSurface,
  83           const Standard_Real newV1,
  84           const Standard_Real newV2)
  85 {
  86   TColStd_Array1OfReal  knots(1,aSurface->NbVKnots()) ;
  87   aSurface->VKnots(knots) ;
  88   BSplCLib::Reparametrize(newV1,
  89                           newV2,
  90                           knots) ;
  91   aSurface->SetVKnots(knots) ;
  92 }
  93
  94 //=======================================================================
  95 //function : BRepTools_NurbsConvertModification
  96 //purpose  :
  97 //=======================================================================
  98
  99 BRepTools_NurbsConvertModification::BRepTools_NurbsConvertModification()
 100 {
 101 }
 102
 103
 104
 105 //=======================================================================
 106 //function : NewSurface
 107 //purpose  :
 108 //=======================================================================
 109
 110 Standard_Boolean BRepTools_NurbsConvertModification::NewSurface
 111       (const TopoDS_Face& F,
 112        Handle(Geom_Surface)& S,
 113        TopLoc_Location& L,
 114        Standard_Real& Tol,
 115        Standard_Boolean& RevWires,
 116        Standard_Boolean& RevFace)
 117 {
 118   Standard_Real U1, U2, curvU1, curvU2, surfU1, surfU2, UTol;
 119   Standard_Real V1, V2, curvV1, curvV2, surfV1, surfV2, VTol;
 120   RevWires = Standard_False;
 121   RevFace = Standard_False;
 122   Handle(Geom_Surface) SS = BRep_Tool::Surface(F,L);
 123   Handle(Standard_Type) TheTypeSS = SS->DynamicType();
 124   if ((TheTypeSS == STANDARD_TYPE(Geom_BSplineSurface)) ||
 125       (TheTypeSS == STANDARD_TYPE(Geom_BezierSurface))) {
 126     return Standard_False;
 127   }
 128   S = SS;
 129   BRepTools::UVBounds(F,curvU1,curvU2,curvV1,curvV2);
 130   Tol = BRep_Tool::Tolerance(F);
 131   Standard_Real TolPar = 0.1*Tol;
 132   Standard_Boolean IsUp = S->IsUPeriodic(), IsVp = S->IsVPeriodic();
 133   //OCC466(apo)->
 134   U1 = curvU1;  U2 = curvU2;
 135   V1 = curvV1;  V2 = curvV2;
 136   SS->Bounds(surfU1,surfU2,surfV1,surfV2);
 137
 138   if (Abs(U1 - surfU1) <= TolPar)
 139     U1 = surfU1;
 140   if (Abs(U2 - surfU2) <= TolPar)
 141     U2 = surfU2;
 142   if (Abs(V1 - surfV1) <= TolPar)
 143     V1 = surfV1;
 144   if (Abs(V2 - surfV2) <= TolPar)
 145     V2 = surfV2;
 146
 147   if(!IsUp){
 148     U1 = Max(surfU1,curvU1);
 149     U2 = Min(surfU2,curvU2);
 150   }
 151   if(!IsVp){
 152     V1 = Max(surfV1,curvV1);
 153     V2 = Min(surfV2,curvV2);
 154   }
 155   //<-OCC466(apo)
 156
 157   if (IsUp)
 158   {
 159     Standard_Real Up = S->UPeriod();
 160     if (U2 - U1 > Up)
 161       U2 = U1 + Up;
 162   }
 163   if (IsVp)
 164   {
 165     Standard_Real Vp = S->VPeriod();
 166     if (V2 - V1 > Vp)
 167       V2 = V1 + Vp;
 168   }
 169
 170   /*
 171   if(IsUp && IsVp) {
 172     Standard_Real dU = Abs(U2 - U1), dV = Abs(V2 - V1);
 173     Standard_Real Up = S->UPeriod(), Vp = S->VPeriod();
 174     if(Abs(dU - Up) <= TolPar && U2 <= Up) {
 175       if(Abs(dV - Vp) <= TolPar && V2 <= Vp) { }
 176       else {
 177         SS = new Geom_RectangularTrimmedSurface(S, V1+1e-9, V2-1e-9, Standard_False);
 178       }
 179     }
 180     else {
 181       if(Abs(dV - Vp) <= TolPar && V2 <= Vp)
 182         SS = new Geom_RectangularTrimmedSurface(S, U1+1e-9, U2-1e-9, Standard_True);
 183       else
 184         SS = new Geom_RectangularTrimmedSurface(S, U1+1e-9, U2-1e-9, V1+1e-9, V2-1e-9);
 185     }
 186   }
 187
 188   if(IsUp && !IsVp) {
 189     Standard_Real dU = Abs(U2 - U1);
 190     Standard_Real Up = S->UPeriod();
 191     if(Abs(dU - Up) <= TolPar && U2 <= Up)
 192       SS = new Geom_RectangularTrimmedSurface(S, V1+1e-9, V2-1e-9, Standard_False);
 193     else
 194       SS = new Geom_RectangularTrimmedSurface(S, U1+1e-9, U2-1e-9, V1+1e-9, V2-1e-9);
 195   }
 196
 197   if(!IsUp && IsVp) {
 198     Standard_Real dV = Abs(V2 - V1);
 199     Standard_Real Vp = S->VPeriod();
 200     if(Abs(dV - Vp) <= TolPar && V2 <= Vp)
 201       SS = new Geom_RectangularTrimmedSurface(S, U1+1e-9, U2-1e-9, Standard_True);
 202     else
 203       SS = new Geom_RectangularTrimmedSurface(S, U1+1e-9, U2-1e-9, V1+1e-9, V2-1e-9);
 204   }
 205
 206   if(!IsUp && !IsVp) {
 207     SS = new Geom_RectangularTrimmedSurface(S, U1+1e-9, U2-1e-9, V1+1e-9, V2-1e-9);
 208   }
 209   */
 210
 211   if (Abs(surfU1-U1) > Tol || Abs(surfU2-U2) > Tol ||
 212       Abs(surfV1-V1) > Tol || Abs(surfV2-V2) > Tol)
 213     SS = new Geom_RectangularTrimmedSurface(S, U1, U2, V1, V2);
 214   SS->Bounds(surfU1,surfU2,surfV1,surfV2);
 215
 216   S = GeomConvert::SurfaceToBSplineSurface(SS);
 217   Handle(Geom_BSplineSurface) BS = Handle(Geom_BSplineSurface)::DownCast(S) ;
 218   BS->Resolution(Tol, UTol, VTol) ;
 219
 220   //
 221   // on recadre les bornes de S  sinon les anciennes PCurves sont aux fraises
 222   //
 223
 224   if (Abs(curvU1-surfU1) > UTol && !BS->IsUPeriodic()) {
 225     GeomLib_ChangeUBounds(BS, U1,U2) ;
 226   }
 227   if (Abs(curvV1-surfV1) > VTol && !BS->IsVPeriodic()) {
 228     GeomLib_ChangeVBounds(BS, V1, V2) ;
 229   }
 230
 231   return Standard_True;
 232 }
 233
 234 static Standard_Boolean IsConvert(const TopoDS_Edge& E)
 235 {
 236   Standard_Boolean isConvert = Standard_False;
 237   Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*)&E.TShape());
 238   // iterate on pcurves
 239   BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
 240   for ( ; itcr.More() && !isConvert; itcr.Next() ) {
 241     Handle(BRep_GCurve) GC = Handle(BRep_GCurve)::DownCast(itcr.Value());
 242     if ( GC.IsNull() || ! GC->IsCurveOnSurface() ) continue;
 243     Handle(Geom_Surface) aSurface = GC->Surface();
 244     Handle(Geom2d_Curve) aCurve2d = GC->PCurve();
 245     isConvert =((!aSurface->IsKind(STANDARD_TYPE(Geom_BSplineSurface)) &&
 246                 !aSurface->IsKind(STANDARD_TYPE(Geom_BezierSurface))) ||
 247                (!aCurve2d->IsKind(STANDARD_TYPE(Geom2d_BSplineCurve)) &&
 248                !aCurve2d->IsKind(STANDARD_TYPE(Geom2d_BezierCurve))));
 249
 250   }
 251   return isConvert;
 252
 253 }
 254
 255 //=======================================================================
 256 //function : NewCurve
 257 //purpose  :
 258 //=======================================================================
 259
 260 Standard_Boolean BRepTools_NurbsConvertModification::NewCurve
 261 (const TopoDS_Edge& E,
 262  Handle(Geom_Curve)& C,
 263  TopLoc_Location& L,
 264  Standard_Real& Tol)
 265 {
 266
 267   Tol = BRep_Tool::Tolerance(E);
 268   if(BRep_Tool::Degenerated(E)) {
 269     C.Nullify();
 270     L.Identity();
 271     return Standard_True;
 272   }
 273   Standard_Real f, l;
 274
 275   Handle(Geom_Curve) Caux = BRep_Tool::Curve(E, L, f, l);
 276
 277   if ( Caux.IsNull()) {
 278     L.Identity();
 279     return Standard_False;
 280   }
 281   Handle(Standard_Type) TheType = Caux->DynamicType();
 282   if ((TheType == STANDARD_TYPE(Geom_BSplineCurve)) ||
 283       (TheType == STANDARD_TYPE(Geom_BezierCurve))) {
 284     if(IsConvert(E)) {
 285       C = Handle(Geom_Curve)::DownCast(Caux->Copy());
 286       return Standard_True;
 287     }
 288     return Standard_False;
 289   }
 290
 291   C = Caux;
 292
 293   Standard_Real TolPar = Tol *.1;
 294
 295   if(C->IsPeriodic()) {
 296     Standard_Real p = C->Period();
 297     Standard_Real d = Abs(l - f);
 298     if(Abs(d - p) <= TolPar && l <= p) {}
 299     else
 300       C = new Geom_TrimmedCurve(C, f, l);
 301   }
 302   else
 303     C = new Geom_TrimmedCurve(C, f, l);
 304
 305 //modif WOK++ portage hp (fbi du 14/03/97)
 306 //  gp_Trsf trsf(L);
 307 //  gp_Trsf trsf = L.Transformation();
 308
 309 //  C = GeomConvert::CurveToBSplineCurve(C,Convert_QuasiAngular);
 310
 311   C = GeomConvert::CurveToBSplineCurve(C);
 312
 313   Standard_Real fnew = C->FirstParameter(), lnew = C->LastParameter(), UTol;
 314
 315   Handle(Geom_BSplineCurve) BC = Handle(Geom_BSplineCurve)::DownCast(C) ;
 316
 317   if(!BC->IsPeriodic()) {
 318     BC->Resolution(Tol, UTol) ;
 319     if(Abs(f - fnew) > UTol || Abs(l - lnew) > UTol) {
 320       TColStd_Array1OfReal  knots(1,BC->NbKnots()) ;
 321       BC->Knots(knots) ;
 322       BSplCLib::Reparametrize(f, l, knots) ;
 323       BC->SetKnots(knots) ;
 324     }
 325   }
 326
 327   if(!myMap.Contains(Caux)) {
 328     myMap.Add(Caux,C);
 329   }
 330   return Standard_True ;
 331 }
 332
 333 //=======================================================================
 334 //function : NewPoint
 335 //purpose  :
 336 //=======================================================================
 337
 338 Standard_Boolean BRepTools_NurbsConvertModification::NewPoint
 339 //(const TopoDS_Vertex& V,
 340 (const TopoDS_Vertex& ,
 341 // gp_Pnt& P,
 342  gp_Pnt& ,
 343 // Standard_Real& Tol)
 344  Standard_Real& )
 345 {
 346   return Standard_False;
 347 }
 348
 349
 350 //=======================================================================
 351 //function : NewCurve2d
 352 //purpose  :
 353 //=======================================================================
 354
 355 Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
 356 (const TopoDS_Edge& E,
 357  const TopoDS_Face& F,
 358  const TopoDS_Edge& newE,
 359  const TopoDS_Face& newF,
 360  Handle(Geom2d_Curve)& Curve2d,
 361  Standard_Real& Tol)
 362 {
 363
 364   Tol = BRep_Tool::Tolerance(E);
 365   Standard_Real f2d,l2d;
 366   Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(E,F,f2d,l2d);
 367   Standard_Real f3d,l3d;
 368   TopLoc_Location Loc;
 369   Handle(Geom_Curve) C3d = BRep_Tool::Curve(E, Loc, f3d,l3d);
 370   Standard_Boolean isConvert2d = ((!C3d.IsNull() && !C3d->IsKind(STANDARD_TYPE(Geom_BSplineCurve)) &&
 371     !C3d->IsKind(STANDARD_TYPE(Geom_BezierCurve))) ||
 372     IsConvert(E));
 373
 374   if(BRep_Tool::Degenerated(E)) {
 375     //Curve2d = C2d;
 376     if(!C2d->IsKind(STANDARD_TYPE(Geom2d_TrimmedCurve)))
 377     {
 378       Handle(Geom2d_TrimmedCurve) aTrimC = new Geom2d_TrimmedCurve(C2d,f2d,l2d);
 379       C2d = aTrimC;
 380     }
 381     Curve2d = Geom2dConvert::CurveToBSplineCurve(C2d);
 382     return Standard_True;
 383   }
 384   if(!BRepTools::IsReallyClosed(E,F)) {
 385     Handle(Standard_Type) TheTypeC2d = C2d->DynamicType();
 386
 387     if(TheTypeC2d == STANDARD_TYPE(Geom2d_TrimmedCurve)) {
 388       Handle(Geom2d_TrimmedCurve) TC = Handle(Geom2d_TrimmedCurve)::DownCast(C2d);
 389       C2d = TC->BasisCurve();
 390     }
 391
 392     Standard_Real fc = C2d->FirstParameter(), lc = C2d->LastParameter();
 393
 394     if(!C2d->IsPeriodic()) {
 395       if(fc - f2d > Precision::PConfusion()) f2d = fc;
 396       if(l2d - lc > Precision::PConfusion()) l2d = lc;
 397     }
 398
 399     C2d = new Geom2d_TrimmedCurve(C2d, f2d, l2d);
 400
 401     Geom2dAdaptor_Curve   G2dAC(C2d, f2d, l2d);
 402     Handle(Geom2dAdaptor_HCurve) G2dAHC = new Geom2dAdaptor_HCurve(G2dAC);
 403
 404     TopLoc_Location Loc;
 405     Handle(Geom_Curve) C3d = BRep_Tool::Curve(E, Loc, f3d,l3d);
 406     if(!newE.IsNull()) {
 407       C3d = BRep_Tool::Curve(newE, f3d, l3d);
 408     }
 409     else {
 410       C3d = BRep_Tool::Curve(E,f3d,l3d);
 411     }
 412     GeomAdaptor_Curve   G3dAC(C3d, f3d, l3d);
 413     Handle(GeomAdaptor_HCurve) G3dAHC = new GeomAdaptor_HCurve(G3dAC);
 414
 415     Standard_Real Uinf, Usup, Vinf, Vsup, u = 0, v = 0;
 416     Handle(Geom_Surface) S = BRep_Tool::Surface(F);
 417     Handle(Standard_Type) myT = S->DynamicType();
 418     if(myT != STANDARD_TYPE(Geom_Plane)) {
 419       if(newF.IsNull()) {
 420         Handle(Standard_Type) st = C2d->DynamicType();
 421         if ((st == STANDARD_TYPE(Geom2d_BSplineCurve)) ||
 422             (st == STANDARD_TYPE(Geom2d_BezierCurve))) {
 423           if(isConvert2d) {
 424             Curve2d = Handle(Geom2d_Curve)::DownCast(C2d->Copy());
 425             return Standard_True;
 426           }
 427           return Standard_False;
 428               }
 429             }
 430             else {
 431         S = BRep_Tool::Surface(newF);
 432
 433       }
 434       S->Bounds(Uinf, Usup, Vinf, Vsup);
 435       //Uinf -= 1e-9; Usup += 1e-9; Vinf -= 1e-9; Vsup += 1e-9;
 436       u = (Usup - Uinf)*0.1;
 437       v = (Vsup - Vinf)*0.1;
 438       if(S->IsUPeriodic()) {
 439         Standard_Real uperiod = S->UPeriod();
 440         if(uperiod < (Usup+2*u-Uinf)) {
 441           if(uperiod <= (Usup-Uinf))  {
 442             u = 0;
 443           }
 444           else {
 445             u = (uperiod-(Usup-Uinf))*0.5;
 446           }
 447         }
 448       }
 449       if(S->IsVPeriodic()) {
 450         Standard_Real vperiod = S->VPeriod();
 451         if(vperiod < (Vsup+2*v-Vinf)) {
 452           if(vperiod <= (Vsup-Vinf)) {
 453             v = 0;
 454           }
 455           else {
 456             v = (vperiod-(Vsup-Vinf))*0.5;
 457           }
 458         }
 459       }
 460     }
 461     else {
 462       S = BRep_Tool::Surface(F);// Si S est un plan, pas de changement de parametrisation
 463       GeomAdaptor_Surface GAS(S);
 464       Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(GAS);
 465       ProjLib_ComputeApprox ProjOnCurve(G3dAHC,GAHS,Tol);
 466       if(ProjOnCurve.BSpline().IsNull()) {
 467         Curve2d = Geom2dConvert::CurveToBSplineCurve(ProjOnCurve.Bezier());
 468         return Standard_True;
 469       }
 470       Curve2d = ProjOnCurve.BSpline();
 471       return Standard_True;
 472     }
 473     GeomAdaptor_Surface GAS(S,Uinf-u,Usup+u,Vinf-v,Vsup+v);
 474
 475     Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(GAS);
 476
 477     ProjLib_ComputeApproxOnPolarSurface ProjOnCurve(G2dAHC,G3dAHC,GAHS,Tol);
 478
 479     if(ProjOnCurve.IsDone()) {
 480       Curve2d = ProjOnCurve.BSpline();
 481
 482       return Standard_True;
 483     }
 484     else {
 485       Curve2d = Geom2dConvert::CurveToBSplineCurve(C2d);
 486       return Standard_True;
 487     }
 488   }
 489   else  {
 490     TopTools_ListIteratorOfListOfShape itled;
 491     TColStd_ListIteratorOfListOfTransient itlcu;
 492
 493     for (itled.Initialize(myled), itlcu.Initialize(mylcu);
 494           itled.More(); // itlcu.More()
 495           itled.Next(),itlcu.Next())
 496     {
 497       if (itled.Value().IsSame(E)) {
 498         // deja traitee
 499         break;
 500       }
 501     }
 502     if (!itled.More()) { // on stocke l`edge et la curve2d
 503       Handle(Geom2d_Curve) C2dBis;
 504       Standard_Real f3d,l3d,f2dBis,l2dBis;
 505       C2d = new Geom2d_TrimmedCurve(C2d, f2d, l2d);
 506       Geom2dAdaptor_Curve G2dAC(C2d, f2d, l2d);
 507       Handle(Geom2dAdaptor_HCurve) G2dAHC = new Geom2dAdaptor_HCurve(G2dAC);
 508       TopoDS_Edge ERevers = E;
 509       ERevers.Reverse();
 510 //      TopoDS_Edge ERevers = TopoDS::Edge(E.Reversed());
 511       C2dBis = BRep_Tool::CurveOnSurface(ERevers,F,f2dBis,l2dBis);
 512       Handle(Standard_Type) TheTypeC2dBis = C2dBis->DynamicType();
 513       C2dBis = new Geom2d_TrimmedCurve(C2dBis,f2dBis, l2dBis);
 514       Geom2dAdaptor_Curve   G2dACBis(C2dBis, f2dBis, l2dBis);
 515       Handle(Geom2dAdaptor_HCurve) G2dAHCBis = new Geom2dAdaptor_HCurve(G2dACBis);
 516
 517       TopLoc_Location Loc;
 518       Handle(Geom_Curve) C3d = BRep_Tool::Curve(E, f3d,l3d);
 519       if(C3d.IsNull()) {
 520          if(isConvert2d) {
 521            Curve2d = Handle(Geom2d_Curve)::DownCast(C2d->Copy());
 522            return Standard_True;
 523          }
 524
 525         return Standard_False;
 526       }
 527       if(!newE.IsNull()) {
 528         C3d = BRep_Tool::Curve(newE, f3d,l3d);
 529       }
 530       GeomAdaptor_Curve G3dAC(C3d, f3d, l3d);
 531       Handle(GeomAdaptor_HCurve) G3dAHC = new GeomAdaptor_HCurve(G3dAC);
 532
 533       Handle(Geom_Surface) S = BRep_Tool::Surface(F);
 534       Handle(Standard_Type) myT = S->DynamicType();
 535       if(newF.IsNull()) {
 536         mylcu.Append(C2dBis);
 537         Handle(Standard_Type) st = C2d->DynamicType();
 538         if ((st == STANDARD_TYPE(Geom2d_BSplineCurve)) ||
 539             (st == STANDARD_TYPE(Geom2d_BezierCurve))) {
 540           if(isConvert2d) {
 541             Curve2d = Handle(Geom2d_Curve)::DownCast(C2d->Copy());
 542             return Standard_True;
 543           }
 544           return Standard_False;
 545         }
 546       }
 547       else {
 548         S = BRep_Tool::Surface(newF);// S est une BSplineSurface : pas besoin de la trimmed
 549       }
 550       Standard_Real Uinf, Usup, Vinf, Vsup, u = 0, v = 0;
 551       S->Bounds(Uinf, Usup, Vinf, Vsup);
 552       //Uinf -= 1e-9; Usup += 1e-9; Vinf -= 1e-9; Vsup += 1e-9;
 553       u = (Usup - Uinf)*0.1;
 554       v = (Vsup - Vinf)*0.1;
 555       if(S->IsUPeriodic()) {
 556         Standard_Real uperiod = S->UPeriod();
 557         if(uperiod < (Usup+2*u-Uinf))
 558           if(uperiod <= (Usup-Uinf))
 559             u = 0;
 560           else
 561             u = (uperiod-(Usup-Uinf))*0.5;
 562       }
 563       if(S->IsVPeriodic()) {
 564         Standard_Real vperiod = S->VPeriod();
 565         if(vperiod < (Vsup+2*v-Vinf))
 566           if(vperiod <= (Vsup-Vinf))
 567             v = 0;
 568           else
 569             v = (vperiod-(Vsup-Vinf))*0.5;
 570       }
 571       GeomAdaptor_Surface GAS(S, Uinf-u,Usup+u,Vinf-v,Vsup+v);
 572       Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(GAS);
 573       myled.Append(E);
 574
 575       ProjLib_ComputeApproxOnPolarSurface
 576       ProjOnCurve(G2dAHC,G2dAHCBis,G3dAHC,GAHS,Tol);
 577
 578       if(ProjOnCurve.IsDone()) {
 579         Curve2d = ProjOnCurve.BSpline();
 580         mylcu.Append(ProjOnCurve.Curve2d());
 581         return Standard_True;
 582       }
 583       else {
 584         Curve2d = Geom2dConvert::CurveToBSplineCurve(C2d);
 585         mylcu.Append(C2dBis);
 586         return Standard_True;
 587       }
 588     }
 589     else { // on est au 2ieme tour
 590       C2d = Handle(Geom2d_Curve)::DownCast(itlcu.Value());
 591       Handle(Standard_Type) st = C2d->DynamicType();
 592       if (!(st == STANDARD_TYPE(Geom2d_BSplineCurve)) &&
 593           !(st == STANDARD_TYPE(Geom2d_BezierCurve))) {
 594         return Standard_False;
 595       }
 596       Curve2d = Geom2dConvert::CurveToBSplineCurve(C2d);
 597       return Standard_True;
 598     }
 599   }
 600 }
 601
 602 //=======================================================================
 603 //function : NewParameter
 604 //purpose  :
 605 //=======================================================================
 606
 607 Standard_Boolean BRepTools_NurbsConvertModification::NewParameter
 608    (const TopoDS_Vertex& V,
 609     const TopoDS_Edge& E,
 610     Standard_Real& P,
 611     Standard_Real& Tol)
 612 {
 613   if(BRep_Tool::Degenerated(E))
 614     return Standard_False;
 615   Standard_Real f, l, param = BRep_Tool::Parameter(V,E);
 616   TopLoc_Location L;
 617
 618   Handle(Geom_Curve) gc = BRep_Tool::Curve(E, L, f, l);
 619   if(!myMap.Contains(gc))
 620     return Standard_False;
 621
 622   Handle(Geom_BSplineCurve) gcc =
 623     Handle(Geom_BSplineCurve)::DownCast(myMap.FindFromKey(gc));
 624
 625   gcc = Handle(Geom_BSplineCurve)::DownCast(gcc->Transformed(L.Transformation()));
 626
 627   GeomAdaptor_Curve ac(gcc);
 628   gp_Pnt pnt = BRep_Tool::Pnt(V);
 629
 630   Extrema_LocateExtPC proj(pnt, ac, param, f, l, Tol);
 631   if(proj.IsDone()) {
 632     Standard_Real Dist2Min = proj.SquareDistance();
 633     if (Dist2Min < Tol*Tol) {
 634       // Standard_Real U_final_point,V_final_point;
 635       P = proj.Point().Parameter();
 636       return Standard_True;
 637     }
 638   }
 639   return Standard_False;
 640 }
 641
 642 //=======================================================================
 643 //function : Continuity
 644 //purpose  :
 645 //=======================================================================
 646
 647 GeomAbs_Shape BRepTools_NurbsConvertModification::Continuity
 648   (const TopoDS_Edge& E,
 649    const TopoDS_Face& F1,
 650    const TopoDS_Face& F2,
 651    const TopoDS_Edge&,
 652    const TopoDS_Face&,
 653    const TopoDS_Face&)
 654 {
 655   return BRep_Tool::Continuity(E,F1,F2);
 656 }
 657
 658