[occt.git] / src / BRepTools / BRepTools_NurbsConvertModification.cxx

// Created on: 1996-07-12
// Created by: Stagiaire Mary FABIEN
// Copyright (c) 1996-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

#include <BRepTools_NurbsConvertModification.ixx>

#include <BRepTools.hxx>
#include <Standard_NoSuchObject.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <Geom_RectangularTrimmedSurface.hxx>
#include <Geom_BSplineSurface.hxx>
#include <Geom_BSplineCurve.hxx>
#include <Geom_BezierSurface.hxx>
#include <Geom_BezierCurve.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <GeomConvert.hxx>
#include <Geom2dConvert.hxx>
#include <Geom_Plane.hxx>
#include <Geom_Line.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <Geom2dAdaptor_HCurve.hxx>
#include <Geom2dAdaptor_HCurve.hxx>
#include <GeomAdaptor_HCurve.hxx>
#include <GeomAdaptor_HSurface.hxx>

#include <BSplCLib.hxx>
#include <Approx_SameParameter.hxx>
#include <BRep_Tool.hxx>
#include <Extrema_LocateExtPC.hxx>
#include <OSD_Chronometer.hxx>
#include <gp_GTrsf2d.hxx>
#include <gp_TrsfForm.hxx>
#include <TopAbs.hxx>
#include <TopoDS.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TColStd_ListIteratorOfListOfTransient.hxx>
#include <ProjLib_ComputeApprox.hxx>
#include <ProjLib_ComputeApproxOnPolarSurface.hxx>
#include <ElSLib.hxx>
#include <BSplCLib.hxx>
#include <Geom_Circle.hxx>
#include <Geom_Ellipse.hxx>
#include <Geom_CylindricalSurface.hxx>

#include <TColStd_Array1OfReal.hxx>
#include <BRep_TEdge.hxx>
#include <BRep_GCurve.hxx>
#include <BRep_ListIteratorOfListOfCurveRepresentation.hxx>

static void GeomLib_ChangeUBounds(Handle(Geom_BSplineSurface)& aSurface,
                  const Standard_Real newU1,
                  const Standard_Real newU2)
{
  TColStd_Array1OfReal  knots(1,aSurface->NbUKnots()) ;
  aSurface->UKnots(knots) ;
  BSplCLib::Reparametrize(newU1,
              newU2,
              knots) ;
  aSurface->SetUKnots(knots) ;
}
static void GeomLib_ChangeVBounds(Handle(Geom_BSplineSurface)& aSurface,
                  const Standard_Real newV1,
                  const Standard_Real newV2)
{
  TColStd_Array1OfReal  knots(1,aSurface->NbVKnots()) ;
  aSurface->VKnots(knots) ;
  BSplCLib::Reparametrize(newV1,
              newV2,
              knots) ;
  aSurface->SetVKnots(knots) ;
}

//=======================================================================
//function : BRepTools_NurbsConvertModification
//purpose  : 
//=======================================================================

BRepTools_NurbsConvertModification::BRepTools_NurbsConvertModification()
{
}


//=======================================================================
//function : NewSurface
//purpose  : 
//=======================================================================

Standard_Boolean BRepTools_NurbsConvertModification::NewSurface
      (const TopoDS_Face& F,
       Handle(Geom_Surface)& S,
       TopLoc_Location& L,
       Standard_Real& Tol,
       Standard_Boolean& RevWires,
       Standard_Boolean& RevFace)
{
  Standard_Real U1, U2, curvU1, curvU2, surfU1, surfU2, UTol;
  Standard_Real V1, V2, curvV1, curvV2, surfV1, surfV2, VTol;
  RevWires = Standard_False;
  RevFace = Standard_False;
  Handle(Geom_Surface) SS = BRep_Tool::Surface(F,L);
  Handle(Standard_Type) TheTypeSS = SS->DynamicType();
  if ((TheTypeSS == STANDARD_TYPE(Geom_BSplineSurface)) ||
      (TheTypeSS == STANDARD_TYPE(Geom_BezierSurface))) {
    return Standard_False;
  }
  S = SS;
  BRepTools::UVBounds(F,curvU1,curvU2,curvV1,curvV2);
  Tol = BRep_Tool::Tolerance(F);
  Standard_Real TolPar = 0.1*Tol;
  Standard_Boolean IsUp = S->IsUPeriodic(), IsVp = S->IsVPeriodic();
  //OCC466(apo)->
  U1 = curvU1;  U2 = curvU2;  
  V1 = curvV1;  V2 = curvV2;
  SS->Bounds(surfU1,surfU2,surfV1,surfV2);

  if (Abs(U1 - surfU1) <= TolPar)
    U1 = surfU1;
  if (Abs(U2 - surfU2) <= TolPar)
    U2 = surfU2;
  if (Abs(V1 - surfV1) <= TolPar)
    V1 = surfV1;
  if (Abs(V2 - surfV2) <= TolPar)
    V2 = surfV2;
  
  if(!IsUp){
    U1 = Max(surfU1,curvU1);
    U2 = Min(surfU2,curvU2);
  }
  if(!IsVp){
    V1 = Max(surfV1,curvV1);
    V2 = Min(surfV2,curvV2);
  }
  //<-OCC466(apo)

  if (IsUp)
  {
    Standard_Real Up = S->UPeriod();
    if (U2 - U1 > Up)
      U2 = U1 + Up;
  }
  if (IsVp)
  {
    Standard_Real Vp = S->VPeriod();
    if (V2 - V1 > Vp)
      V2 = V1 + Vp;
  }
  
  /*
  if(IsUp && IsVp) {
    Standard_Real dU = Abs(U2 - U1), dV = Abs(V2 - V1);
    Standard_Real Up = S->UPeriod(), Vp = S->VPeriod();
    if(Abs(dU - Up) <= TolPar && U2 <= Up) {
      if(Abs(dV - Vp) <= TolPar && V2 <= Vp) { }
      else {
    SS = new Geom_RectangularTrimmedSurface(S, V1+1e-9, V2-1e-9, Standard_False);
      }
    }
    else {
      if(Abs(dV - Vp) <= TolPar && V2 <= Vp) 
    SS = new Geom_RectangularTrimmedSurface(S, U1+1e-9, U2-1e-9, Standard_True);
      else
    SS = new Geom_RectangularTrimmedSurface(S, U1+1e-9, U2-1e-9, V1+1e-9, V2-1e-9);
    }
  }

  if(IsUp && !IsVp) {
    Standard_Real dU = Abs(U2 - U1);
    Standard_Real Up = S->UPeriod();
    if(Abs(dU - Up) <= TolPar && U2 <= Up) 
      SS = new Geom_RectangularTrimmedSurface(S, V1+1e-9, V2-1e-9, Standard_False);
    else 
      SS = new Geom_RectangularTrimmedSurface(S, U1+1e-9, U2-1e-9, V1+1e-9, V2-1e-9);
  }
    
  if(!IsUp && IsVp) {
    Standard_Real dV = Abs(V2 - V1);
    Standard_Real Vp = S->VPeriod();
    if(Abs(dV - Vp) <= TolPar && V2 <= Vp) 
      SS = new Geom_RectangularTrimmedSurface(S, U1+1e-9, U2-1e-9, Standard_True);
    else
      SS = new Geom_RectangularTrimmedSurface(S, U1+1e-9, U2-1e-9, V1+1e-9, V2-1e-9);
  }

  if(!IsUp && !IsVp) {
    SS = new Geom_RectangularTrimmedSurface(S, U1+1e-9, U2-1e-9, V1+1e-9, V2-1e-9);
  }
  */

  if (Abs(surfU1-U1) > Tol || Abs(surfU2-U2) > Tol ||
      Abs(surfV1-V1) > Tol || Abs(surfV2-V2) > Tol)
    SS = new Geom_RectangularTrimmedSurface(S, U1, U2, V1, V2);
  SS->Bounds(surfU1,surfU2,surfV1,surfV2); 

  S = GeomConvert::SurfaceToBSplineSurface(SS);
  Handle(Geom_BSplineSurface) BS = Handle(Geom_BSplineSurface)::DownCast(S) ;
  BS->Resolution(Tol, UTol, VTol) ;
  
  // 
  // on recadre les bornes de S  sinon les anciennes PCurves sont aux fraises
  //

  if (Abs(curvU1-surfU1) > UTol && !BS->IsUPeriodic()) {
    GeomLib_ChangeUBounds(BS, U1,U2) ;
  }
  if (Abs(curvV1-surfV1) > VTol && !BS->IsVPeriodic()) {
    GeomLib_ChangeVBounds(BS, V1, V2) ;
  }

  return Standard_True;
}

static Standard_Boolean IsConvert(const TopoDS_Edge& E)
{
  Standard_Boolean isConvert = Standard_False;
  Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*)&E.TShape());
  // iterate on pcurves
  BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
  for ( ; itcr.More() && !isConvert; itcr.Next() ) {
    Handle(BRep_GCurve) GC = Handle(BRep_GCurve)::DownCast(itcr.Value());
    if ( GC.IsNull() || ! GC->IsCurveOnSurface() ) continue;
    Handle(Geom_Surface) aSurface = GC->Surface();
    Handle(Geom2d_Curve) aCurve2d = GC->PCurve();
    isConvert =((!aSurface->IsKind(STANDARD_TYPE(Geom_BSplineSurface)) && 
                !aSurface->IsKind(STANDARD_TYPE(Geom_BezierSurface))) ||
               (!aCurve2d->IsKind(STANDARD_TYPE(Geom2d_BSplineCurve)) &&
               !aCurve2d->IsKind(STANDARD_TYPE(Geom2d_BezierCurve))));
     
  }
  return isConvert;
  
}

//=======================================================================
//function : NewCurve
//purpose  : 
//=======================================================================

Standard_Boolean BRepTools_NurbsConvertModification::NewCurve
(const TopoDS_Edge& E, 
 Handle(Geom_Curve)& C,
 TopLoc_Location& L,
 Standard_Real& Tol)
{

  Tol = BRep_Tool::Tolerance(E);
  if(BRep_Tool::Degenerated(E)) {
    C.Nullify();
    L.Identity();
    return Standard_True;
  }
  Standard_Real f, l;

  Handle(Geom_Curve) Caux = BRep_Tool::Curve(E, L, f, l);

  if ( Caux.IsNull()) {
    L.Identity();    
    return Standard_False;
  }
  Handle(Standard_Type) TheType = Caux->DynamicType();
  if ((TheType == STANDARD_TYPE(Geom_BSplineCurve)) ||
      (TheType == STANDARD_TYPE(Geom_BezierCurve))) {
    if(IsConvert(E)) {
      C = Handle(Geom_Curve)::DownCast(Caux->Copy());
      return Standard_True;
    }
    return Standard_False;
  } 

  C = Caux; 

  Standard_Real TolPar = Tol *.1;

  if(C->IsPeriodic()) {
    Standard_Real p = C->Period();
    Standard_Real d = Abs(l - f);
    if(Abs(d - p) <= TolPar && l <= p) {}
    else
      C = new Geom_TrimmedCurve(C, f, l);
  } 
  else 
    C = new Geom_TrimmedCurve(C, f, l);

//modif WOK++ portage hp (fbi du 14/03/97)
//  gp_Trsf trsf(L);
//  gp_Trsf trsf = L.Transformation();

//  C = GeomConvert::CurveToBSplineCurve(C,Convert_QuasiAngular);

  C = GeomConvert::CurveToBSplineCurve(C);

  Standard_Real fnew = C->FirstParameter(), lnew = C->LastParameter(), UTol;

  Handle(Geom_BSplineCurve) BC = Handle(Geom_BSplineCurve)::DownCast(C) ;

  if(!BC->IsPeriodic()) {
    BC->Resolution(Tol, UTol) ;
    if(Abs(f - fnew) > UTol || Abs(l - lnew) > UTol) {
      TColStd_Array1OfReal  knots(1,BC->NbKnots()) ;
      BC->Knots(knots) ;
      BSplCLib::Reparametrize(f, l, knots) ;
      BC->SetKnots(knots) ;
    }
  }

  if(!myMap.Contains(Caux)) {
    myMap.Add(Caux,C);
  }
  return Standard_True ;
}

//=======================================================================
//function : NewPoint
//purpose  : 
//=======================================================================

Standard_Boolean BRepTools_NurbsConvertModification::NewPoint
    (const TopoDS_Vertex&, gp_Pnt&, Standard_Real& )
{
  return Standard_False;
}


//=======================================================================
//function : NewCurve2d
//purpose  : 
//=======================================================================

Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
  (const TopoDS_Edge& E, 
   const TopoDS_Face& F, 
   const TopoDS_Edge& newE, 
   const TopoDS_Face& newF, 
   Handle(Geom2d_Curve)& Curve2d,
   Standard_Real& Tol)
{

  Tol = BRep_Tool::Tolerance(E);
  Standard_Real f2d,l2d;
  Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(E,F,f2d,l2d);
  Standard_Real f3d,l3d;
  TopLoc_Location Loc;
  Handle(Geom_Curve) C3d = BRep_Tool::Curve(E, Loc, f3d,l3d);
  Standard_Boolean isConvert2d = ((!C3d.IsNull() && !C3d->IsKind(STANDARD_TYPE(Geom_BSplineCurve)) &&
    !C3d->IsKind(STANDARD_TYPE(Geom_BezierCurve))) ||
    IsConvert(E));

  if(BRep_Tool::Degenerated(E)) {
    //Curve2d = C2d;
    if(!C2d->IsKind(STANDARD_TYPE(Geom2d_TrimmedCurve)))
    {
      Handle(Geom2d_TrimmedCurve) aTrimC = new Geom2d_TrimmedCurve(C2d,f2d,l2d);
      C2d = aTrimC;
    }
    Curve2d = Geom2dConvert::CurveToBSplineCurve(C2d);
    return Standard_True;
  }
  if(!BRepTools::IsReallyClosed(E,F)) {
    Handle(Standard_Type) TheTypeC2d = C2d->DynamicType();

    if(TheTypeC2d == STANDARD_TYPE(Geom2d_TrimmedCurve)) {
      Handle(Geom2d_TrimmedCurve) TC = Handle(Geom2d_TrimmedCurve)::DownCast(C2d);
      C2d = TC->BasisCurve();
    }

    Standard_Real fc = C2d->FirstParameter(), lc = C2d->LastParameter();

    if(!C2d->IsPeriodic()) {
      if(fc - f2d > Precision::PConfusion()) f2d = fc;
      if(l2d - lc > Precision::PConfusion()) l2d = lc;
    }

    C2d = new Geom2d_TrimmedCurve(C2d, f2d, l2d);

    Geom2dAdaptor_Curve   G2dAC(C2d, f2d, l2d);
    Handle(Geom2dAdaptor_HCurve) G2dAHC = new Geom2dAdaptor_HCurve(G2dAC);
    
    TopLoc_Location Loc;
    Handle(Geom_Curve) C3d = BRep_Tool::Curve(E, Loc, f3d,l3d);
    if(!newE.IsNull()) {
      C3d = BRep_Tool::Curve(newE, f3d, l3d);
    }
    else {
      C3d = BRep_Tool::Curve(E,f3d,l3d);
    }
    GeomAdaptor_Curve   G3dAC(C3d, f3d, l3d);
    Handle(GeomAdaptor_HCurve) G3dAHC = new GeomAdaptor_HCurve(G3dAC);
    
    Standard_Real Uinf, Usup, Vinf, Vsup, u = 0, v = 0;
    Handle(Geom_Surface) S = BRep_Tool::Surface(F);
    Handle(Standard_Type) myT = S->DynamicType();
    if(myT != STANDARD_TYPE(Geom_Plane)) {
      if(newF.IsNull()) {
        Handle(Standard_Type) st = C2d->DynamicType();
        if ((st == STANDARD_TYPE(Geom2d_BSplineCurve)) ||
            (st == STANDARD_TYPE(Geom2d_BezierCurve))) {
          if(isConvert2d) {
            Curve2d = Handle(Geom2d_Curve)::DownCast(C2d->Copy());
            return Standard_True;
          }
          return Standard_False;
        }
      }
      else {
        S = BRep_Tool::Surface(newF);
      }
      S->Bounds(Uinf, Usup, Vinf, Vsup);
      //Uinf -= 1e-9; Usup += 1e-9; Vinf -= 1e-9; Vsup += 1e-9;
      u = (Usup - Uinf)*0.1;
      v = (Vsup - Vinf)*0.1;
      if(S->IsUPeriodic()) {
        Standard_Real uperiod = S->UPeriod();
        if(uperiod < (Usup+2*u-Uinf)) {
          if(uperiod <= (Usup-Uinf))  {
            u = 0;
          } 
          else {
            u = (uperiod-(Usup-Uinf))*0.5;
          }
        }
      }
      if(S->IsVPeriodic()) {
        Standard_Real vperiod = S->VPeriod();
        if(vperiod < (Vsup+2*v-Vinf)) {
          if(vperiod <= (Vsup-Vinf)) {
            v = 0;
          }
          else {
            v = (vperiod-(Vsup-Vinf))*0.5;
          }
        }
      }
    }
    else {
      S = BRep_Tool::Surface(F);// Si S est un plan, pas de changement de parametrisation
      GeomAdaptor_Surface GAS(S);
      Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(GAS);
      ProjLib_ComputeApprox ProjOnCurve(G3dAHC,GAHS,Tol);
      if(ProjOnCurve.BSpline().IsNull()) {
        Curve2d = Geom2dConvert::CurveToBSplineCurve(ProjOnCurve.Bezier());
        return Standard_True;
      }
      Curve2d = ProjOnCurve.BSpline();
      return Standard_True;
    }
    GeomAdaptor_Surface GAS(S,Uinf-u,Usup+u,Vinf-v,Vsup+v);

    Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(GAS);

    ProjLib_ComputeApproxOnPolarSurface ProjOnCurve(G2dAHC,G3dAHC,GAHS,Tol);

    if(ProjOnCurve.IsDone()) {
      Curve2d = ProjOnCurve.BSpline();
      return Standard_True;
    }
    else {
      Curve2d = Geom2dConvert::CurveToBSplineCurve(C2d);
      return Standard_True;
    }
  }
  else  {
    TopTools_ListIteratorOfListOfShape itled;
    TColStd_ListIteratorOfListOfTransient itlcu;
    
    for (itled.Initialize(myled), itlcu.Initialize(mylcu);
      itled.More(); // itlcu.More()
      itled.Next(),itlcu.Next()) {
      if (itled.Value().IsSame(E)) {
        // deja traitee
        break;
      }
    }
    if (!itled.More()) { // on stocke l`edge et la curve2d
      Handle(Geom2d_Curve) C2dBis;
      Standard_Real f3d,l3d,f2dBis,l2dBis;
      C2d = new Geom2d_TrimmedCurve(C2d, f2d, l2d);
      Geom2dAdaptor_Curve G2dAC(C2d, f2d, l2d);
      Handle(Geom2dAdaptor_HCurve) G2dAHC = new Geom2dAdaptor_HCurve(G2dAC);
      TopoDS_Edge ERevers = E;
      ERevers.Reverse();
      C2dBis = BRep_Tool::CurveOnSurface(ERevers,F,f2dBis,l2dBis);
      Handle(Standard_Type) TheTypeC2dBis = C2dBis->DynamicType();
      C2dBis = new Geom2d_TrimmedCurve(C2dBis,f2dBis, l2dBis);
      Geom2dAdaptor_Curve   G2dACBis(C2dBis, f2dBis, l2dBis); 
      Handle(Geom2dAdaptor_HCurve) G2dAHCBis = new Geom2dAdaptor_HCurve(G2dACBis);
      
      TopLoc_Location Loc;
      Handle(Geom_Curve) C3d = BRep_Tool::Curve(E, f3d,l3d);
      if(C3d.IsNull()) {
         if(isConvert2d) {
           Curve2d = Handle(Geom2d_Curve)::DownCast(C2d->Copy());
           return Standard_True;
         }
        return Standard_False;
      }
      if(!newE.IsNull()) {
        C3d = BRep_Tool::Curve(newE, f3d,l3d);
      }
      GeomAdaptor_Curve G3dAC(C3d, f3d, l3d);
      Handle(GeomAdaptor_HCurve) G3dAHC = new GeomAdaptor_HCurve(G3dAC);
      
      Handle(Geom_Surface) S = BRep_Tool::Surface(F);
      Handle(Standard_Type) myT = S->DynamicType();
      if(newF.IsNull()) {
        mylcu.Append(C2dBis);
        Handle(Standard_Type) st = C2d->DynamicType();
        if ((st == STANDARD_TYPE(Geom2d_BSplineCurve)) ||
            (st == STANDARD_TYPE(Geom2d_BezierCurve))) {
          if(isConvert2d) {
            Curve2d = Handle(Geom2d_Curve)::DownCast(C2d->Copy());
            return Standard_True;
          }
          return Standard_False;
        }
      }
      else {
        S = BRep_Tool::Surface(newF);// S est une BSplineSurface : pas besoin de la trimmed
      }
      Standard_Real Uinf, Usup, Vinf, Vsup, u = 0, v = 0;
      S->Bounds(Uinf, Usup, Vinf, Vsup);
      //Uinf -= 1e-9; Usup += 1e-9; Vinf -= 1e-9; Vsup += 1e-9;
      u = (Usup - Uinf)*0.1;
      v = (Vsup - Vinf)*0.1;
      if(S->IsUPeriodic()) {
        Standard_Real uperiod = S->UPeriod();
        if(uperiod < (Usup+2*u-Uinf)) {
          if(uperiod <= (Usup-Uinf))
            u = 0;
          else
            u = (uperiod-(Usup-Uinf))*0.5;
        }
      }
      if(S->IsVPeriodic()) {
        Standard_Real vperiod = S->VPeriod();
        if(vperiod < (Vsup+2*v-Vinf)) {
          if(vperiod <= (Vsup-Vinf))
            v = 0;
          else
            v = (vperiod-(Vsup-Vinf))*0.5;
        }
      }
      GeomAdaptor_Surface GAS(S, Uinf-u,Usup+u,Vinf-v,Vsup+v);
      Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(GAS);
      myled.Append(E);

      ProjLib_ComputeApproxOnPolarSurface 
      ProjOnCurve(G2dAHC,G2dAHCBis,G3dAHC,GAHS,Tol);

      if(ProjOnCurve.IsDone()) {
        Curve2d = ProjOnCurve.BSpline();
        mylcu.Append(ProjOnCurve.Curve2d());
        return Standard_True;
      }
      else {
        Curve2d = Geom2dConvert::CurveToBSplineCurve(C2d);
        mylcu.Append(C2dBis);
        return Standard_True;
      }
    }
    else { // on est au 2ieme tour 
      C2d = Handle(Geom2d_Curve)::DownCast(itlcu.Value());
      Handle(Standard_Type) st = C2d->DynamicType();
      if (!(st == STANDARD_TYPE(Geom2d_BSplineCurve)) &&
      !(st == STANDARD_TYPE(Geom2d_BezierCurve))) {
        return Standard_False;
      }
      Curve2d = Geom2dConvert::CurveToBSplineCurve(C2d);
      return Standard_True;
    }
  }
}

//=======================================================================
//function : NewParameter
//purpose  : 
//=======================================================================

Standard_Boolean BRepTools_NurbsConvertModification::NewParameter
   (const TopoDS_Vertex& V, 
    const TopoDS_Edge& E, 
    Standard_Real& P, 
    Standard_Real& Tol)
{
  if(BRep_Tool::Degenerated(E))
    return Standard_False;
  Standard_Real f, l, param = BRep_Tool::Parameter(V,E);
  TopLoc_Location L;

  Handle(Geom_Curve) gc = BRep_Tool::Curve(E, L, f, l);
  if(!myMap.Contains(gc))
    return Standard_False;

  Handle(Geom_BSplineCurve) gcc = 
    Handle(Geom_BSplineCurve)::DownCast(myMap.FindFromKey(gc));

  gcc = Handle(Geom_BSplineCurve)::DownCast(gcc->Transformed(L.Transformation()));

  GeomAdaptor_Curve ac(gcc);
  gp_Pnt pnt = BRep_Tool::Pnt(V);

  Extrema_LocateExtPC proj(pnt, ac, param, f, l, Tol);
  if(proj.IsDone()) {
    Standard_Real Dist2Min = proj.SquareDistance();
    if (Dist2Min < Tol*Tol) {
      P = proj.Point().Parameter();
      return Standard_True;
    }
  }
  return Standard_False;
}

//=======================================================================
//function : Continuity
//purpose  : 
//=======================================================================

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