[occt.git] / src / BRepCheck / BRepCheck_Edge.cxx

// Created on: 1995-12-11
// Created by: Jacques GOUSSARD
// Copyright (c) 1995-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 <Adaptor3d_CurveOnSurface.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_CurveOnSurface.hxx>
#include <Bnd_Box.hxx>
#include <BRep_CurveOnSurface.hxx>
#include <BRep_CurveRepresentation.hxx>
#include <BRep_GCurve.hxx>
#include <BRep_ListIteratorOfListOfCurveRepresentation.hxx>
#include <BRep_ListOfCurveRepresentation.hxx>
#include <BRep_PolygonOnTriangulation.hxx>
#include <BRep_TEdge.hxx>
#include <BRep_TFace.hxx>
#include <BRep_Tool.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepCheck.hxx>
#include <BRepCheck_Edge.hxx>
#include <BRepCheck_ListIteratorOfListOfStatus.hxx>
#include <BRepCheck_ListOfStatus.hxx>
#include <Extrema_LocateExtPC.hxx>
#include <Geom2d_Curve.hxx>
#include <Geom2dAdaptor.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <Geom_Curve.hxx>
#include <Geom_Plane.hxx>
#include <Geom_RectangularTrimmedSurface.hxx>
#include <Geom_Surface.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <GeomProjLib.hxx>
#include <Poly_PolygonOnTriangulation.hxx>
#include <Poly_Triangulation.hxx>
#include <Precision.hxx>
#include <ProjLib_ProjectedCurve.hxx>
#include <Standard_Type.hxx>
#include <TColStd_Array1OfTransient.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Shape.hxx>

IMPLEMENT_STANDARD_RTTIEXT(BRepCheck_Edge,BRepCheck_Result)

//modified by NIZNHY-PKV Thu May 05 09:01:57 2011f
static 
  Standard_Boolean Validate(const Adaptor3d_Curve&,
  const Adaptor3d_CurveOnSurface&,
  const Standard_Real,
  const Standard_Boolean);
static
  void PrintProblematicPoint(const gp_Pnt&,
  const Standard_Real,
  const Standard_Real);

static
  Standard_Real Prec(const Adaptor3d_Curve& aAC3D,
  const Adaptor3d_CurveOnSurface& aACS);

//static Standard_Boolean Validate(const Adaptor3d_Curve&,
//				 const Adaptor3d_Curve&,
//				 const Standard_Real,
//				 const Standard_Boolean);
//modified by NIZNHY-PKV Thu May 05 09:02:01 2011t

static const Standard_Integer NCONTROL=23;

//=======================================================================
//function : BRepCheck_Edge
//purpose  : 
//=======================================================================

BRepCheck_Edge::BRepCheck_Edge(const TopoDS_Edge& E)
{
  Init(E);
  myGctrl = Standard_True;
}

//=======================================================================
//function : Minimum
//purpose  : 
//=======================================================================

void BRepCheck_Edge::Minimum()
{

  if (!myMin) {
    BRepCheck_ListOfStatus thelist;
    myMap.Bind(myShape, thelist);
    BRepCheck_ListOfStatus& lst = myMap(myShape);
    myCref.Nullify();

    // Existence et unicite d`une representation 3D
    Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*)&myShape.TShape());
    BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
    Standard_Boolean exist = Standard_False;
    Standard_Boolean unique = Standard_True;
    // Search for a 3D reference. If no existent one, creates it with the 
    // first encountered CurveOnSurf; if multiple, chooses the first one...

    Standard_Boolean Degenerated = TE->Degenerated();
    Standard_Boolean SameParameter = TE->SameParameter();
    Standard_Boolean SameRange = TE->SameRange();
    if (!SameRange && SameParameter) {
      BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag);
    }
    //    Handle(Geom_Curve) C3d;

    while (itcr.More()) {
      const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
      if (cr->IsCurve3D()) {
        if (!exist) {
          exist = Standard_True;
        }
        else {
          unique = Standard_False;
        }
        if (myCref.IsNull() && !cr->Curve3D().IsNull()) {
          myCref = cr;
        }
      }
      itcr.Next();
    }

    if (!exist) {
      BRepCheck::Add(lst,BRepCheck_No3DCurve);
      // myCref est nulle
    }
    else if (!unique) {
      BRepCheck::Add(lst,BRepCheck_Multiple3DCurve);
    }

    if (myCref.IsNull() && !Degenerated) {
      itcr.Initialize(TE->Curves());
      while (itcr.More()) {
        const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
        if (cr->IsCurveOnSurface()) {
          myCref = cr;
          break;
        }
        itcr.Next();
      }
    }
    else if (!myCref.IsNull() && Degenerated){
      BRepCheck::Add(lst,BRepCheck_InvalidDegeneratedFlag);
    }

    if (!myCref.IsNull()) {
      Handle(BRep_GCurve) GCref (Handle(BRep_GCurve)::DownCast (myCref));
      Standard_Real eps = Precision::PConfusion();
      Standard_Real First,Last;
      GCref->Range(First,Last);
      if (Last<=First) {
        myCref.Nullify();
        BRepCheck::Add(lst,BRepCheck_InvalidRange);
      }
      else {
        if (myCref->IsCurve3D()) {
          // eap 6 Jun 2002 occ332
          // better transform C3d instead of transforming Surf upto C3d initial location,
          // on transformed BSpline surface 'same parameter' may seem wrong
          TopLoc_Location L = myShape.Location() * myCref->Location();
          Handle(Geom_Curve) C3d = Handle(Geom_Curve)::DownCast
            (myCref->Curve3D()->Transformed
            (/*myCref->Location()*/L.Transformation()));
          Standard_Boolean IsPeriodic = C3d->IsPeriodic();
          Standard_Real aPeriod = RealLast();
          if(IsPeriodic)
          {
            aPeriod = C3d->Period();
          }
          Standard_Real f = C3d->FirstParameter(), l = C3d->LastParameter();
          if (C3d->DynamicType() == STANDARD_TYPE(Geom_TrimmedCurve))
          {
            const Handle(Geom_Curve)& aC = Handle(Geom_TrimmedCurve)::DownCast (C3d)->BasisCurve(); 
            f = aC->FirstParameter();
            l = aC->LastParameter();
            IsPeriodic = aC->IsPeriodic();
            if(IsPeriodic)
            {
              aPeriod = aC->Period();
            }
          }
          if(IsPeriodic && (Last - First > aPeriod + eps))
          {
            myCref.Nullify();
            BRepCheck::Add(lst,BRepCheck_InvalidRange);
          }
          else if(!IsPeriodic && (First < f - eps || Last > l + eps))
          {
            myCref.Nullify();
            BRepCheck::Add(lst,BRepCheck_InvalidRange);
          }
          else
          {
            GeomAdaptor_Curve GAC3d(C3d, C3d->TransformedParameter(First, L.Transformation()),
                                       C3d->TransformedParameter(Last, L.Transformation()));
            myHCurve = new GeomAdaptor_Curve(GAC3d);
          }
        }
        else { // curve on surface
          Handle(Geom_Surface) Sref = myCref->Surface();
          Sref = Handle(Geom_Surface)::DownCast
            (Sref->Transformed(myCref->Location().Transformation()));
          const Handle(Geom2d_Curve)& PCref = myCref->PCurve();
          Standard_Boolean IsPeriodic = PCref->IsPeriodic();
          Standard_Real aPeriod = RealLast();
          if(IsPeriodic)
          {
            aPeriod = PCref->Period();
          }
          Standard_Real f = PCref->FirstParameter(), l = PCref->LastParameter();
          if (PCref->DynamicType() == STANDARD_TYPE(Geom2d_TrimmedCurve))
          {
            const Handle(Geom2d_Curve)& aC = Handle(Geom2d_TrimmedCurve)::DownCast (PCref)->BasisCurve(); 
            f = aC->FirstParameter();
            l = aC->LastParameter();
            IsPeriodic = aC->IsPeriodic();
            if(IsPeriodic)
            {
              aPeriod = aC->Period();
            }
          }
          if(IsPeriodic && (Last - First > aPeriod + eps))
          {
            myCref.Nullify();
            BRepCheck::Add(lst,BRepCheck_InvalidRange);
          }
          else if(!IsPeriodic && (First < f - eps || Last > l + eps))
          {
            myCref.Nullify();
            BRepCheck::Add(lst,BRepCheck_InvalidRange);
          }
          else
          {
            Handle(GeomAdaptor_Surface) GAHSref = new GeomAdaptor_Surface(Sref);
            Handle(Geom2dAdaptor_Curve) GHPCref = 
              new Geom2dAdaptor_Curve(PCref,First,Last);
            Adaptor3d_CurveOnSurface ACSref(GHPCref,GAHSref);
            myHCurve = new Adaptor3d_CurveOnSurface(ACSref);
          }
        }
      }
    }
    if (lst.IsEmpty()) {
      lst.Append(BRepCheck_NoError);
    }
    myMin = Standard_True;
  }
}


//=======================================================================
//function : InContext
//purpose  : 
//=======================================================================

void BRepCheck_Edge::InContext(const TopoDS_Shape& S)
{
  if (myMap.IsBound(S)) {
    return;
  }
  BRepCheck_ListOfStatus thelist;
  myMap.Bind(S, thelist);
  BRepCheck_ListOfStatus& lst = myMap(S);

  Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*)&myShape.TShape());
  Standard_Real Tol = BRep_Tool::Tolerance(TopoDS::Edge(myShape));

  TopAbs_ShapeEnum styp = S.ShapeType();
  //  for (TopExp_Explorer exp(S,TopAbs_EDGE); exp.More(); exp.Next()) {
  TopExp_Explorer exp(S,TopAbs_EDGE) ;
  for ( ; exp.More(); exp.Next()) {
    if (exp.Current().IsSame(myShape)) {
      break;
    }
  }
  if (!exp.More()) {
    BRepCheck::Add(lst,BRepCheck_SubshapeNotInShape);
    return;
  }

  switch (styp) 
  {
  case TopAbs_WIRE:
    {
    }
    break;

  case TopAbs_FACE:
    if (!myCref.IsNull()) {

      Standard_Boolean SameParameter = TE->SameParameter();
      Standard_Boolean SameRange = TE->SameRange();
      //  Modified by skv - Tue Apr 27 11:48:13 2004 Begin
      if (!SameParameter || !SameRange) {
        if (!SameParameter)
          BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag);
        if (!SameRange)
          BRepCheck::Add(lst,BRepCheck_InvalidSameRangeFlag);

        return;
      }
      //  Modified by skv - Tue Apr 27 11:48:14 2004 End
      Standard_Real First = myHCurve->FirstParameter();
      Standard_Real Last  = myHCurve->LastParameter();

      Handle(BRep_TFace)& TF = *((Handle(BRep_TFace)*) &S.TShape());
      const TopLoc_Location& Floc = S.Location();
      const TopLoc_Location& TFloc = TF->Location();
      const Handle(Geom_Surface)& Su = TF->Surface();
      TopLoc_Location L = (Floc * TFloc).Predivided(myShape.Location());
      TopLoc_Location LE = myShape.Location() * myCref->Location();
      const gp_Trsf& Etrsf = LE.Transformation();
      Standard_Boolean pcurvefound = Standard_False;

      BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
      Standard_Real eps = Precision::PConfusion();
      while (itcr.More()) {
        const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
        if (cr != myCref && cr->IsCurveOnSurface(Su,L)) {
          pcurvefound = Standard_True;
          Handle(BRep_GCurve) GC (Handle(BRep_GCurve)::DownCast (cr));
          Standard_Real f,l;
          GC->Range(f,l);
          Standard_Real ff = f, ll = l;
          if(myCref->IsCurve3D())
          {
            ff = myCref->Curve3D()->TransformedParameter(f, Etrsf);
            ll = myCref->Curve3D()->TransformedParameter(l, Etrsf);
          }
          // gka OCC
          //  Modified by skv - Tue Apr 27 11:50:35 2004 Begin
          if (Abs(ff-First) > eps ||
              Abs(ll-Last)  > eps) {
              BRepCheck::Add(lst,BRepCheck_InvalidSameRangeFlag);
              BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag);
          }
          //  Modified by skv - Tue Apr 27 11:50:37 2004 End
          //
          const Handle(Geom2d_Curve)& pc = cr->PCurve();
          Standard_Boolean IsPeriodic = pc->IsPeriodic();
          Standard_Real aPeriod = RealLast();
          if(IsPeriodic)
          {
            aPeriod = pc->Period();
          }
          Standard_Real fp = pc->FirstParameter(), lp = pc->LastParameter();
          if (pc->DynamicType() == STANDARD_TYPE(Geom2d_TrimmedCurve))
          {
            const Handle(Geom2d_Curve)& aC = Handle(Geom2d_TrimmedCurve)::DownCast (pc)->BasisCurve(); 
            fp = aC->FirstParameter();
            lp = aC->LastParameter();
            IsPeriodic = aC->IsPeriodic();
            if(IsPeriodic)
            {
              aPeriod = aC->Period();
            }
          }
          if(IsPeriodic && (l - f > aPeriod + eps))
          {
            BRepCheck::Add(lst,BRepCheck_InvalidRange);
            return;
          }
          else if(!IsPeriodic && (f < fp - eps || l > lp + eps))
          {
            BRepCheck::Add(lst,BRepCheck_InvalidRange);
            return;
          }

          if (myGctrl) {
            Handle(Geom_Surface) Sb = cr->Surface();
            Sb = Handle(Geom_Surface)::DownCast
              //	      (Su->Transformed(L.Transformation()));
              (Su->Transformed(/*L*/(Floc * TFloc).Transformation()));
            Handle(Geom2d_Curve) PC = cr->PCurve();
            Handle(GeomAdaptor_Surface) GAHS = new GeomAdaptor_Surface(Sb);
            Handle(Geom2dAdaptor_Curve) GHPC = new Geom2dAdaptor_Curve(PC,f,l);
            Adaptor3d_CurveOnSurface ACS(GHPC,GAHS);
            Standard_Boolean ok = Validate (*myHCurve, ACS, Tol, SameParameter);
            if (!ok) {
              if (cr->IsCurveOnClosedSurface()) {
                BRepCheck::Add(lst,BRepCheck_InvalidCurveOnClosedSurface);
              }
              else {
                BRepCheck::Add(lst,BRepCheck_InvalidCurveOnSurface);
              }
              //  Modified by skv - Tue Apr 27 11:53:00 2004 Begin
              BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag);
              // 	      if (SameParameter) {
              // 		BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag);
              // 	      }
              //  Modified by skv - Tue Apr 27 11:53:01 2004 End
            }
            if (cr->IsCurveOnClosedSurface()) {
              GHPC->Load(cr->PCurve2(),f,l); // same bounds
              ACS.Load(GHPC, GAHS); // sans doute inutile
              ok = Validate(*myHCurve,ACS,Tol,SameParameter);
              if (!ok) {
                BRepCheck::Add(lst,BRepCheck_InvalidCurveOnClosedSurface);
                //  Modified by skv - Tue Apr 27 11:53:20 2004 Begin
                if (SameParameter) {
                  BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag);
                }
                //  Modified by skv - Tue Apr 27 11:53:23 2004 End
              }
            }
          }
        }
        itcr.Next();
      }

      if (!pcurvefound) {
        Handle(Geom_Plane) P;
        Handle(Standard_Type) dtyp = Su->DynamicType();
        if (dtyp == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
          P = Handle(Geom_Plane)::DownCast
            (Handle(Geom_RectangularTrimmedSurface)::
            DownCast(Su)->BasisSurface());
        }
        else {
          P = Handle(Geom_Plane)::DownCast(Su);
        }
        if (P.IsNull()) { // not a plane
          BRepCheck::Add(lst,BRepCheck_NoCurveOnSurface);
        }
        else { // on fait la projection a la volee, comme BRep_Tool
          // plan en position
          if (myGctrl) {
            P = Handle(Geom_Plane)::
              DownCast(P->Transformed(/*L*/(Floc * TFloc).Transformation()));// eap occ332
            //on projette Cref sur ce plan
            Handle(GeomAdaptor_Surface) GAHS = new GeomAdaptor_Surface(P);

            // Dub - Normalement myHCurve est une GeomAdaptor_Curve
            Handle(GeomAdaptor_Curve) Gac = Handle(GeomAdaptor_Curve)::DownCast(myHCurve);
            Handle(Geom_Curve) C3d = Gac->Curve();
            Handle(Geom_Curve) ProjOnPlane = 
              GeomProjLib::ProjectOnPlane(new Geom_TrimmedCurve(C3d,First,Last),
              P, P->Position().Direction(),
              Standard_True);
            Handle(GeomAdaptor_Curve) aHCurve = 
              new GeomAdaptor_Curve(ProjOnPlane);

            ProjLib_ProjectedCurve proj(GAHS,aHCurve);
            Handle(Geom2d_Curve) PC = Geom2dAdaptor::MakeCurve(proj);
            Handle(Geom2dAdaptor_Curve) GHPC = 
              new Geom2dAdaptor_Curve(PC,
              myHCurve->FirstParameter(),
              myHCurve->LastParameter());

            Adaptor3d_CurveOnSurface ACS(GHPC,GAHS);

            Standard_Boolean ok = Validate (*myHCurve, ACS, Tol,Standard_True); // voir dub...
            if (!ok) {
              BRepCheck::Add(lst,BRepCheck_InvalidCurveOnSurface);
            }
          }
        }
      }
    }
    break;
  case TopAbs_SOLID:
    {
      // on verifie que l`edge est bien connectee 2 fois (pas de bord libre)
      Standard_Integer nbconnection = 0;
      //TopExp_Explorer exp;
      for (exp.Init(S,TopAbs_FACE); exp.More(); exp.Next()) {
        const TopoDS_Face& fac = TopoDS::Face(exp.Current());
        TopExp_Explorer exp2;
        for (exp2.Init(fac,TopAbs_EDGE); exp2.More(); exp2.Next()) {
          if (exp2.Current().IsSame(myShape)) {
            nbconnection++;
          }
        }
      }
      if (nbconnection < 2 && !TE->Degenerated()) {
        BRepCheck::Add(myMap(S),BRepCheck_FreeEdge);
      }
      else if (nbconnection > 2) {
        BRepCheck::Add(myMap(S),BRepCheck_InvalidMultiConnexity);
      }
      else {
        BRepCheck::Add(myMap(S),BRepCheck_NoError);
      }
    }
    break;
  default:
    break;
  }
  if (myMap(S).IsEmpty()) {
    myMap(S).Append(BRepCheck_NoError);
  }
}


//=======================================================================
//function : Blind
//purpose  : 
//=======================================================================

void BRepCheck_Edge::Blind()
{
  //  Modified by skv - Tue Apr 27 11:36:01 2004 Begin
  // The body of this function is removed because of its useless.
  if (!myBlind) {
    myBlind = Standard_True;
  }
  //  Modified by skv - Tue Apr 27 11:36:02 2004 End
}


//=======================================================================
//function : GeometricControls
//purpose  : 
//=======================================================================

void BRepCheck_Edge::GeometricControls(const Standard_Boolean B)
{
  myGctrl = B;
}


//=======================================================================
//function : GeometricControls
//purpose  : 
//=======================================================================

Standard_Boolean BRepCheck_Edge::GeometricControls() const
{
  return myGctrl;
}

//=======================================================================
//function :   SetStatus
//purpose  : 
//=======================================================================
void BRepCheck_Edge::SetStatus(const BRepCheck_Status theStatus)
{
  BRepCheck::Add(myMap(myShape),theStatus);
}


//=======================================================================
//function : Tolerance
//purpose  : 
//=======================================================================

Standard_Real BRepCheck_Edge::Tolerance()
{
  Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*)&myShape.TShape());
  Standard_Integer it, iRep=1, nbRep=(TE->Curves()).Extent();
  if (nbRep<=1) {
    return Precision::Confusion();
  }
  TColStd_Array1OfTransient theRep(1, nbRep*2);
  Standard_Real First, Last;
  if (!myHCurve.IsNull()) {
    First = myHCurve->FirstParameter();
    Last=  myHCurve->LastParameter();
  }
  else {
    BRep_Tool::Range(TopoDS::Edge(myShape), First, Last);
  }

  BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
  for (; itcr.More(); itcr.Next()) {
    const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
    if (cr->IsCurve3D() && !TE->Degenerated()) {
      //// modified by jgv, 20.03.03 ////
      TopLoc_Location Loc = myShape.Location() * cr->Location();
      Handle(Geom_Curve) C3d = Handle(Geom_Curve)::DownCast
        (cr->Curve3D()->Transformed( Loc.Transformation() ));
      ///////////////////////////////////
      GeomAdaptor_Curve GAC3d(C3d,First,Last);
      it=iRep;
      if (iRep>1) {
        theRep(iRep)=theRep(1);
        it=1;
      }
      theRep(it) = new GeomAdaptor_Curve(GAC3d);
      iRep++;
    }
    else if (cr->IsCurveOnSurface()) {
      {
        Handle(Geom_Surface) Sref = cr->Surface();
        //// modified by jgv, 20.03.03 ////
        TopLoc_Location Loc = myShape.Location() * cr->Location();
        Sref = Handle(Geom_Surface)::DownCast
          (Sref->Transformed( Loc.Transformation() ));
        ///////////////////////////////////
        const Handle(Geom2d_Curve)& PCref = cr->PCurve();
        Handle(GeomAdaptor_Surface) GAHSref = new GeomAdaptor_Surface(Sref);
        Handle(Geom2dAdaptor_Curve) GHPCref = 
          new Geom2dAdaptor_Curve(PCref,First,Last);
        Adaptor3d_CurveOnSurface ACSref(GHPCref,GAHSref);
        theRep(iRep) = new Adaptor3d_CurveOnSurface(ACSref);
        iRep++;
      }
      if (cr->IsCurveOnClosedSurface()) {
        Handle(Geom_Surface) Sref = cr->Surface();
        Sref = Handle(Geom_Surface)::DownCast
          (Sref->Transformed(cr->Location().Transformation()));
        const Handle(Geom2d_Curve)& PCref = cr->PCurve2();
        Handle(GeomAdaptor_Surface) GAHSref = new GeomAdaptor_Surface(Sref);
        Handle(Geom2dAdaptor_Curve) GHPCref = 
          new Geom2dAdaptor_Curve(PCref,First,Last);
        Adaptor3d_CurveOnSurface ACSref(GHPCref,GAHSref);
        theRep(iRep) = new Adaptor3d_CurveOnSurface(ACSref);
        iRep++;
        nbRep++;
      }
    }
    else {
      nbRep--;
    }
  }

  Standard_Real dist2, tol2, tolCal=0., prm;
  gp_Pnt center, othP;
  Standard_Integer i;
  for (i= 0; i< NCONTROL; i++) {
    prm = ((NCONTROL-1-i)*First + i*Last)/(NCONTROL-1);
    tol2=dist2=0.;
    center=(*(Handle(Adaptor3d_Curve)*)&theRep(1))->Value(prm);
    if(Precision::IsInfinite(center.X()) || Precision::IsInfinite(center.Y()) 
       || Precision::IsInfinite(center.Z()))
    {
      return Precision::Infinite();
    }
    for (iRep=2; iRep<=nbRep; iRep++) {
      othP=(*(Handle(Adaptor3d_Curve)*)&theRep(iRep))->Value(prm);
      if(Precision::IsInfinite(othP.X()) || Precision::IsInfinite(othP.Y()) 
        || Precision::IsInfinite(othP.Z()))
      {
        return Precision::Infinite();
      }
      dist2=center.SquareDistance(othP);
      if (dist2>tolCal) tolCal=dist2;
    }
    if (tol2>tolCal) {
      tolCal=tol2;
    }
  }
  // On prend 5% de marge car au dessus on crontrole severement
  return sqrt(tolCal)*1.05;
}


//=======================================================================
//function : CheckPolygonOnTriangulation
//purpose  : 
//=======================================================================
BRepCheck_Status BRepCheck_Edge::
  CheckPolygonOnTriangulation(const TopoDS_Edge& theEdge)
{
  BRep_ListOfCurveRepresentation& aListOfCR = 
    (*((Handle(BRep_TEdge)*) &theEdge.TShape()))->ChangeCurves();
  BRep_ListIteratorOfListOfCurveRepresentation anITCR(aListOfCR);

  BRepAdaptor_Curve aBC;
  aBC.Initialize(theEdge);

  if(!aBC.Is3DCurve())
    return BRepCheck_NoError;

  while (anITCR.More())
  {
    if(!anITCR.Value()->IsPolygonOnTriangulation())
    {
      anITCR.Next();
      continue;
    }

    const Handle(BRep_CurveRepresentation) aCR = anITCR.Value();
    Handle(BRep_PolygonOnTriangulation) aPT (Handle(BRep_PolygonOnTriangulation)::DownCast(aCR));

    const TopLoc_Location aLL = theEdge.Location() * aPT->Location();
    const gp_Trsf aTrsf = aLL;

    const Handle(Poly_Triangulation) aTriang =  aCR->Triangulation();
    const Handle(Poly_PolygonOnTriangulation) aPOnTriag = 
      aCR->IsPolygonOnClosedTriangulation() ? 
      aCR->PolygonOnTriangulation2() : 
    aCR->PolygonOnTriangulation();
    const TColStd_Array1OfInteger& anIndices = aPOnTriag->Nodes();
    const Standard_Integer aNbNodes = anIndices.Length();

    const Standard_Real aTol = aPOnTriag->Deflection() +
      BRep_Tool::Tolerance(theEdge);

    if(aPOnTriag->HasParameters())
    {
      for(Standard_Integer i = aPOnTriag->Parameters()->Lower();
        i <= aPOnTriag->Parameters()->Upper(); i++)
      {
        const Standard_Real aParam = aPOnTriag->Parameters()->Value(i);
        const gp_Pnt aPE (aBC.Value (aParam));
        const gp_Pnt aPnt (aTriang->Node (anIndices (i)).Transformed (aTrsf));

        const Standard_Real aSQDist = aPE.SquareDistance(aPnt);
        if(aSQDist > aTol*aTol)
        {
          return BRepCheck_InvalidPolygonOnTriangulation;
        }
      }
    }
    else
    {
      //If aPOnTriag does not have any parameters we will check if it
      //inscribes into Bounding box, which is built on the edge triangulation.

      Bnd_Box aB;

      for (Standard_Integer i = 1; i <= aNbNodes; i++)
      {
        if (aTrsf.Form() == gp_Identity)
        {
          aB.Add (aTriang->Node (anIndices(i)));
        }
        else
        {
          aB.Add (aTriang->Node (anIndices(i)).Transformed(aTrsf));
        }
      }

      aB.Enlarge(aTol);

      Standard_Real aFP = aBC.FirstParameter();
      Standard_Real aLP = aBC.LastParameter();

      const Standard_Real aStep = (aLP - aFP)/IntToReal(NCONTROL);
      gp_Pnt aP;
      Standard_Real aPar = aFP;

      for(Standard_Integer i = 1; i < NCONTROL; i ++)
      {
        aBC.D0(aPar, aP);
        if(aB.IsOut(aP))
        {
          return BRepCheck_InvalidPolygonOnTriangulation;
        }

        aPar += aStep;
      }

      aBC.D0(aLP, aP);
      if(aB.IsOut(aP))
      {
        return BRepCheck_InvalidPolygonOnTriangulation;
      }
    }

    anITCR.Next();
  }

  return BRepCheck_NoError;
}

//=======================================================================
//function : Validate
//purpose  : 
//=======================================================================
Standard_Boolean Validate(const Adaptor3d_Curve& CRef,
  const Adaptor3d_CurveOnSurface& Other,
  const Standard_Real Tol,
  const Standard_Boolean SameParameter)
{
  Standard_Boolean  Status, proj; 
  Standard_Real aPC, First, Last, Error;
  gp_Pnt  problematic_point ;
  //
  Status = Standard_True;
  Error = 0.;
  First = CRef.FirstParameter();
  Last  = CRef.LastParameter();

  aPC=Precision::PConfusion();
  proj = (!SameParameter || 
    Abs(Other.FirstParameter()-First) > aPC || 
    Abs( Other.LastParameter()-Last) > aPC);
  if (!proj)
  {
    Standard_Integer i;
    Standard_Real Tol2, prm, dD;
    gp_Pnt pref, pother;
    //modified by NIZNHY-PKV Thu May 05 09:06:41 2011f
    //OCC22428
    dD=Prec(CRef, Other);//3.e-15;
    Tol2=Tol+dD;
    Tol2=Tol2*Tol2;
    //Tol2=Tol*Tol;
    //modified by NIZNHY-PKV Thu May 05 09:06:47 2011t

    for (i = 0; i < NCONTROL; ++i) {
      prm = ((NCONTROL-1-i)*First + i*Last)/(NCONTROL-1);
      pref = CRef.Value(prm);
      pother = Other.Value(prm);
      if (pref.SquareDistance(pother) > Tol2) {
        problematic_point = pref ;
        Status = Standard_False;
        Error  = pref.Distance(pother);
        PrintProblematicPoint(problematic_point, Error, Tol);
        return Status;
        //goto FINISH ;
      }
    }
  }
  else {
    Extrema_LocateExtPC refd,otherd;
    Standard_Real OFirst = Other.FirstParameter();
    Standard_Real OLast  = Other.LastParameter();
    gp_Pnt pd = CRef.Value(First);
    gp_Pnt pdo = Other.Value(OFirst);
    Standard_Real distt = pd.SquareDistance(pdo);
    if (distt > Tol*Tol) {
      problematic_point = pd ;
      Status = Standard_False ;
      Error = Sqrt(distt);
      PrintProblematicPoint(problematic_point, Error, Tol);
      return Status;
      //goto FINISH ;
    }
    pd = CRef.Value(Last);
    pdo = Other.Value(OLast);
    distt = pd.SquareDistance(pdo);
    if (distt > Tol*Tol) {
      problematic_point = pd ;
      Status = Standard_False ;
      Error = Sqrt(distt);
      PrintProblematicPoint(problematic_point, Error, Tol);
      return Status;
      //goto FINISH ;
    }

    refd.Initialize(CRef,First,Last,CRef.Resolution(Tol));
    otherd.Initialize(Other,OFirst,OLast,Other.Resolution(Tol));
    for (Standard_Integer i = 2; i< NCONTROL-1; i++) {
      Standard_Real rprm = ((NCONTROL-1-i)*First + i*Last)/(NCONTROL-1);
      gp_Pnt pref = CRef.Value(rprm);
      Standard_Real oprm = ((NCONTROL-1-i)*OFirst + i*OLast)/(NCONTROL-1);
      gp_Pnt pother = Other.Value(oprm);
      refd.Perform(pother,rprm);
      if (!refd.IsDone() || refd.SquareDistance() > Tol * Tol) {
        problematic_point = pref ;
        Status = Standard_False ;
        if (refd.IsDone()) {
          Error = sqrt (refd.SquareDistance());
        }
        else {
          Error = RealLast();
        }
        PrintProblematicPoint(problematic_point, Error, Tol);
        return Status;
        //goto FINISH ;
      }
      otherd.Perform(pref,oprm);
      if (!otherd.IsDone() || otherd.SquareDistance() > Tol * Tol) {
        problematic_point = pref ;
        Status = Standard_False ;
        if (otherd.IsDone()) {
          Error = sqrt (otherd.SquareDistance());
        }
        else {
          Error = RealLast();
        }
        PrintProblematicPoint(problematic_point, Error, Tol);
        return Status;
        //goto FINISH ;
      }
    }
  }

  return Status ;

}

//=======================================================================
//function : Prec
//purpose  : 
//=======================================================================
Standard_Real Prec(const Adaptor3d_Curve& aAC3D,
                   const Adaptor3d_CurveOnSurface& aACS)
{
  Standard_Real aXEmax, aXC, aXS;
  const Handle(Adaptor3d_Surface)& aAHS = aACS.GetSurface();
  //
  aXC = BRepCheck::PrecCurve(aAC3D);
  aXS = BRepCheck::PrecSurface(aAHS);
  aXEmax = (aXC>aXS) ? aXC: aXS;
  return aXEmax;
}

//=======================================================================
//function : PrintProblematicPoint
//purpose  : 
//=======================================================================
#ifdef OCCT_DEBUG
void PrintProblematicPoint(const gp_Pnt& problematic_point,
  const Standard_Real Error,
  const Standard_Real Tol)
{
  std::cout << " **** probleme de SameParameter au point :" << std::endl;
  std::cout << "         " << problematic_point.Coord(1) << " " 
    << problematic_point.Coord(2) << " " << problematic_point.Coord(3) << std::endl ;
  std::cout << "   Erreur detectee :" << Error << " Tolerance :" << Tol << std::endl;
}
#else
void PrintProblematicPoint(const gp_Pnt&,
  const Standard_Real,
  const Standard_Real)
{
}
#endif