[occt.git] / src / BOP / BOP_CorrectTolerances.cxx

// Created on: 2001-04-17
// Created by: Peter KURNEV
// Copyright (c) 2001-2012 OPEN CASCADE SAS
//
// The content of this file is subject to the Open CASCADE Technology Public
// License Version 6.5 (the "License"). You may not use the content of this file
// except in compliance with the License. Please obtain a copy of the License
// at http://www.opencascade.org and read it completely before using this file.
//
// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
//
// The Original Code and all software distributed under the License is
// distributed on an "AS IS" basis, without warranty of any kind, and the
// Initial Developer hereby disclaims all such warranties, including without
// limitation, any warranties of merchantability, fitness for a particular
// purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License.


#include <BOP_CorrectTolerances.ixx>

#include <TopTools_IndexedMapOfShape.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>

#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopoDS_Face.hxx>

#include <TopLoc_Location.hxx>

#include <BRep_TVertex.hxx>
#include <BRep_TEdge.hxx>
#include <BRep_TFace.hxx>
#include <BRep_Tool.hxx>
#include <BRep_GCurve.hxx>
#include <BRep_ListIteratorOfListOfPointRepresentation.hxx>
#include <BRep_ListIteratorOfListOfCurveRepresentation.hxx>
#include <BRep_CurveRepresentation.hxx>
#include <BRep_PointRepresentation.hxx>

#include <Geom_Curve.hxx>
#include <Geom_Surface.hxx>
#include <Geom_Plane.hxx>
#include <Geom_TrimmedCurve.hxx>

#include <GeomAdaptor_Curve.hxx>
#include <GeomAdaptor_HCurve.hxx>
#include <GeomAdaptor_HSurface.hxx>

#include <Geom2d_Curve.hxx>

#include <Geom2dAdaptor_HCurve.hxx>
#include <Geom_RectangularTrimmedSurface.hxx>
#include <Geom2dAdaptor.hxx>
#include <GeomProjLib.hxx>

#include <ProjLib_ProjectedCurve.hxx>
#include <Extrema_LocateExtPC.hxx>

#include <gp_Pnt.hxx>

#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_CurveOnSurface.hxx>
#include <Adaptor3d_HCurveOnSurface.hxx>


static 
  void CheckEdge (const TopoDS_Edge& E,
		  const Standard_Real aMaxTol);
static 
  void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
			     const TopoDS_Face& S,
			     const Standard_Real aMaxTol);
static 
  Standard_Boolean Validate(const Adaptor3d_Curve& CRef,
			 const Adaptor3d_Curve& Other,
			 const Standard_Real Tol,
			 const Standard_Boolean SameParameter,
			 Standard_Real& aNewTolerance);

//
static
  void CorrectVertexTolerance(const TopoDS_Edge& aE);
//

//=======================================================================
// Function : CorrectTolerances
// purpose : 
//=======================================================================
  void BOP_CorrectTolerances::CorrectTolerances(const TopoDS_Shape& aShape,
						const Standard_Real aMaxTol)
{
  BOP_CorrectTolerances::CorrectPointOnCurve(aShape, aMaxTol);
  BOP_CorrectTolerances::CorrectCurveOnSurface(aShape, aMaxTol);
}

//=======================================================================
// Function : CorrectPointOnCurve
// purpose : 
//=======================================================================
  void BOP_CorrectTolerances::CorrectPointOnCurve(const TopoDS_Shape& S,
						  const Standard_Real aMaxTol)
{
  Standard_Integer i, aNb;
  TopTools_IndexedMapOfShape Edges;
  TopExp::MapShapes (S, TopAbs_EDGE, Edges);
  aNb=Edges.Extent();
  for (i=1; i<=aNb; i++) {
    const TopoDS_Edge& E= TopoDS::Edge(Edges(i));
    CheckEdge(E, aMaxTol);
  }     
}

//=======================================================================
// Function : CorrectCurveOnSurface
// purpose : 
//=======================================================================
  void BOP_CorrectTolerances::CorrectCurveOnSurface(const TopoDS_Shape& S,
						    const Standard_Real aMaxTol)
{
  Standard_Integer i, aNbFaces, j, aNbEdges;
  TopTools_IndexedMapOfShape Faces;
  TopExp::MapShapes (S, TopAbs_FACE, Faces);
  
  aNbFaces=Faces.Extent();
  for (i=1; i<=aNbFaces; i++) {
    const TopoDS_Face& F= TopoDS::Face(Faces(i));
    TopTools_IndexedMapOfShape Edges;
    TopExp::MapShapes (F, TopAbs_EDGE, Edges);
    aNbEdges=Edges.Extent();
    for (j=1; j<=aNbEdges; j++) {
      const TopoDS_Edge& E= TopoDS::Edge(Edges(j));
      CorrectEdgeTolerance (E, F, aMaxTol);
    }
  }
}

//=======================================================================
// Function : CorrectEdgeTolerance
// purpose :  Correct tolerances for Edge 
//=======================================================================
void CorrectEdgeTolerance (const TopoDS_Edge& myShape, 
			   const TopoDS_Face& S,
			   const Standard_Real aMaxTol)
{
  // 
  // 1. Minimum of conditions to Perform
  Handle (BRep_CurveRepresentation) myCref;
  Handle (Adaptor3d_HCurve) myHCurve;

  myCref.Nullify();

  Handle(BRep_TEdge)& TEx = *((Handle(BRep_TEdge)*)&myShape.TShape());
  BRep_ListIteratorOfListOfCurveRepresentation itcrx(TEx->Curves());
  Standard_Boolean Degenerated, SameParameterx, SameRangex;

  Standard_Integer unique = 0;

  Degenerated    = TEx->Degenerated();
  SameParameterx = TEx->SameParameter();
  SameRangex     = TEx->SameRange();
  
  if (!SameRangex && SameParameterx) {
    return;
  }

  Handle(Geom_Curve) C3d;
  while (itcrx.More()) {
    const Handle(BRep_CurveRepresentation)& cr = itcrx.Value();
    if (cr->IsCurve3D()) {
      unique++;
      if (myCref.IsNull() && !cr->Curve3D().IsNull()) {
	myCref = cr;
      }
    }
    itcrx.Next();
  }
  
  if (unique==0) {
    return;//...No3DCurve
  }
  if (unique>1) {
    return;//...Multiple3DCurve;
  }

  if (myCref.IsNull() && !Degenerated) {
    itcrx.Initialize(TEx->Curves());
    while (itcrx.More()) {
      const Handle(BRep_CurveRepresentation)& cr = itcrx.Value();
      if (cr->IsCurveOnSurface()) {
	myCref = cr;
	break;
      }
      itcrx.Next();
    }
  }
  
  else if (!myCref.IsNull() && Degenerated){
    return ;//...InvalidDegeneratedFlag;
  }
  
  if (!myCref.IsNull()) {
    const Handle(BRep_GCurve)& GCref = *((Handle(BRep_GCurve)*)&myCref);
    Standard_Real First,Last;
    GCref->Range(First,Last);
    if (Last<=First) {
      myCref.Nullify();
      return ;//InvalidRange;
    }
    
    else {
      if (myCref->IsCurve3D()) {
	Handle(Geom_Curve) C3dx = Handle(Geom_Curve)::DownCast
	  (myCref->Curve3D()->Transformed (myCref->Location().Transformation()));
	GeomAdaptor_Curve GAC3d(C3dx, First, Last);
	myHCurve = new GeomAdaptor_HCurve(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();
	Handle(GeomAdaptor_HSurface) GAHSref = new GeomAdaptor_HSurface(Sref);
	Handle(Geom2dAdaptor_HCurve) GHPCref = new Geom2dAdaptor_HCurve(PCref, First, Last);
	Adaptor3d_CurveOnSurface ACSref(GHPCref,GAHSref);
	myHCurve = new Adaptor3d_HCurveOnSurface(ACSref);
      }
    }
  }

  //=============================================== 
  // 2. Tolerances in InContext
  {
    if (myCref.IsNull()) 
      return;
    Standard_Boolean ok=Standard_True;;

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

    Standard_Boolean SameParameter = TE->SameParameter();
    Standard_Boolean SameRange = TE->SameRange();
    Standard_Real First = myHCurve->FirstParameter();
    Standard_Real Last  = myHCurve->LastParameter();
    Standard_Real Delta =1.e-14;

    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());
    //      Standard_Boolean checkclosed = Standard_False;
    Standard_Boolean pcurvefound = Standard_False;

    BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
    while (itcr.More()) {
      const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
      if (cr != myCref && cr->IsCurveOnSurface(Su,L)) {
	pcurvefound = Standard_True;
	const Handle(BRep_GCurve)& GC = *((Handle(BRep_GCurve)*)&cr);
	Standard_Real f,l;
	GC->Range(f,l);
	if (SameRange && (f != First || l != Last)) {
	  return ;//BRepCheck_InvalidSameRangeFlag);
	  if (SameParameter) {
	    return; //BRepCheck_InvalidSameParameterFlag);
	  }
        }
	
	Handle(Geom_Surface) Sb = cr->Surface();
	Sb = Handle(Geom_Surface)::DownCast (Su->Transformed(L.Transformation()));
	Handle(Geom2d_Curve) PC = cr->PCurve();
	Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(Sb);
	Handle(Geom2dAdaptor_HCurve) GHPC = new Geom2dAdaptor_HCurve(PC,f,l);
	Adaptor3d_CurveOnSurface ACS(GHPC,GAHS);
	ok = Validate(myHCurve->Curve(), ACS, Tol, SameParameter, aNewTol);
	if (ok) {
	  if (cr->IsCurveOnClosedSurface()) {
	    //return ;// BRepCheck::Add(lst,BRepCheck_InvalidCurveOnClosedSurface);
	  }
	  else {
	    //return;//BRepCheck::Add(lst,BRepCheck_InvalidCurveOnSurface);
	  }
	  if (SameParameter) {
	    //return;//BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag);
	  }
	  //
	  if (aNewTol<aMaxTol) {
	    TE->UpdateTolerance(aNewTol+Delta); 
	    //
	    CorrectVertexTolerance(myShape);
	  }
	}

	if (cr->IsCurveOnClosedSurface()) {
	  //	    checkclosed = Standard_True;
	  GHPC->ChangeCurve2d().Load(cr->PCurve2(),f,l); // same bounds
	  ACS.Load(GAHS); // sans doute inutile
	  ACS.Load(GHPC); // meme remarque...
	  ok = Validate(myHCurve->Curve(),ACS,Tol,SameParameter, aNewTol);
	  if (ok) {
	    //return;//BRepCheck::Add(lst,BRepCheck_InvalidCurveOnClosedSurface);
	    if (SameParameter) {
	      //return;//BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag);
	    }
	    if (aNewTol<aMaxTol) {
	      TE->UpdateTolerance(aNewTol+Delta);
	      CorrectVertexTolerance(myShape);
	    } 
	  }
	}
      }
      itcr.Next();
    }
    
    if (!pcurvefound) {
      Handle(Geom_Plane) P;
      Handle(Standard_Type) styp = Su->DynamicType();
      if (styp == 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
	return;//BRepCheck::Add(lst,BRepCheck_NoCurveOnSurface);
      }
      
      else {// on fait la projection a la volee, comme BRep_Tool
	P = Handle(Geom_Plane)::DownCast(P->Transformed(L.Transformation()));
	//on projette Cref sur ce plan
	Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(P);
	
	// Dub - Normalement myHCurve est une GeomAdaptor_HCurve
	GeomAdaptor_Curve& Gac = Handle(GeomAdaptor_HCurve)::DownCast(myHCurve)->ChangeCurve();
	Handle(Geom_Curve) C3dx = Gac.Curve();
	Handle(Geom_Curve) ProjOnPlane = GeomProjLib::ProjectOnPlane
	  (new Geom_TrimmedCurve(C3dx,First,Last), P, P->Position().Direction(), Standard_True);

	Handle(GeomAdaptor_HCurve) aHCurve = new GeomAdaptor_HCurve(ProjOnPlane);
	
	ProjLib_ProjectedCurve proj(GAHS,aHCurve);
	Handle(Geom2d_Curve) PC = Geom2dAdaptor::MakeCurve(proj);
	Handle(Geom2dAdaptor_HCurve) GHPC = 
	  new Geom2dAdaptor_HCurve(PC, myHCurve->FirstParameter(), myHCurve->LastParameter());
	
	Adaptor3d_CurveOnSurface ACS(GHPC,GAHS);
	
	Standard_Boolean okx = Validate(myHCurve->Curve(),ACS,
					Tol,Standard_True, aNewTol); // voir dub...
	if (okx) {
	  //return;//BRepCheck::Add(lst,BRepCheck_InvalidCurveOnSurface);
	  if (aNewTol<aMaxTol) {
	    TE->UpdateTolerance(aNewTol+Delta);
	    CorrectVertexTolerance(myShape);
	  }
	}
      }
      
    }//end of if (!pcurvefound) {
  } // end of  2. Tolerances in InContext

}

//=======================================================================
//function : CorrectVertexTolerance
//purpose  : 
//=======================================================================
void CorrectVertexTolerance(const TopoDS_Edge& aE)
{
  Standard_Integer k, aNbV;
  Standard_Real aTolE, aTolV;
  TopTools_IndexedMapOfShape aVMap;
  
  aTolE=BRep_Tool::Tolerance(aE);
  
  TopExp::MapShapes(aE, TopAbs_VERTEX, aVMap);
  aNbV=aVMap.Extent();
  for (k=1; k<=aNbV; ++k) {
    const TopoDS_Vertex& aV=TopoDS::Vertex(aVMap(k));
    aTolV=BRep_Tool::Tolerance(aV);
    if (aTolV<aTolE) {
      Handle(BRep_TVertex)& aTV = *((Handle(BRep_TVertex)*)&aV.TShape());
      aTV->UpdateTolerance(aTolE);
    }
  }
}

			    
#define NCONTROL 23
//=======================================================================
//function : Validate
//purpose  : 
//=======================================================================
Standard_Boolean Validate(const Adaptor3d_Curve& CRef,
		       const Adaptor3d_Curve& Other,
		       const Standard_Real Tol,
		       const Standard_Boolean SameParameter,
		       Standard_Real& aNewTolerance)
{
  Standard_Real First, Last, MaxDistance, aD, Tol2;

  First = CRef.FirstParameter();
  Last  = CRef.LastParameter();
  MaxDistance = 0.;
  Tol2 = Tol*Tol;

  Standard_Integer i, aNC1=NCONTROL-1;

  Standard_Boolean aFlag=Standard_False;
  Standard_Boolean proj = (!SameParameter || 
			   First != Other.FirstParameter() ||
			   Last  != Other.LastParameter());
  //
  // 1. 
  if (!proj) {
    for (i = 0; i < NCONTROL; i++) {
      Standard_Real prm = ((aNC1-i)*First + i*Last)/aNC1;
      gp_Pnt pref   = CRef.Value(prm);
      gp_Pnt pother = Other.Value(prm);
      
      aD=pref.SquareDistance(pother);

      if (aD > Tol2) {
	if (aD>MaxDistance) {
	  MaxDistance=aD;
	}
	aFlag=Standard_True;
      }
    }

    if (aFlag) {
      aNewTolerance=sqrt(MaxDistance);
    }
    return aFlag;
  }
  
  //
  // 2.
  else {
    Extrema_LocateExtPC refd,otherd;
    Standard_Real OFirst, OLast;
    OFirst = Other.FirstParameter();
    OLast  = Other.LastParameter();
    
    gp_Pnt pd  = CRef.Value(First);
    gp_Pnt pdo = Other.Value(OFirst);
    
    aD = pd.SquareDistance(pdo);
    if (aD > Tol2) {
      if (aD>MaxDistance) {
	MaxDistance=aD;
      }
      aFlag=Standard_True;
    }

    pd  = CRef.Value(Last);
    pdo = Other.Value(OLast);
    aD = pd.SquareDistance(pdo);
    if (aD > Tol2 && aD > MaxDistance) {
      MaxDistance=aD;
      aFlag=Standard_True;
    }

    refd.Initialize(CRef, First, Last, CRef.Resolution(Tol));
    otherd.Initialize(Other, OFirst, OLast, Other.Resolution(Tol));
    
    for (i = 2; i< aNC1; i++) {
      Standard_Real rprm = ((aNC1-i)*First + i*Last)/aNC1;
      gp_Pnt pref = CRef.Value(rprm);

      Standard_Real oprm = ((aNC1-i)*OFirst + i*OLast)/aNC1;
      gp_Pnt pother = Other.Value(oprm);

      refd.Perform(pother,rprm);
      if (!refd.IsDone() || refd.SquareDistance() > Tol2) {
	if (refd.IsDone()) {
	  aD=refd.SquareDistance();
	  if (aD > Tol2 && aD>MaxDistance) {
	    aFlag=Standard_True;
	    MaxDistance=aD;
	  }
	}
      }

      otherd.Perform(pref,oprm);
      if (!otherd.IsDone() || otherd.SquareDistance() > Tol2) {
	
	if (otherd.IsDone()) {
	  aD=otherd.SquareDistance();
	  if (aD > Tol2 && aD>MaxDistance) {
	    aFlag=Standard_True;
	    MaxDistance=aD;
	  }
	}
      }
    }
  }
  
  aD=sqrt (MaxDistance);
  aNewTolerance=aD;

  return aFlag;
  
}

//=======================================================================
// Function : CheckEdge
// purpose :  Correct tolerances for Vertices on Edge 
//=======================================================================
void CheckEdge (const TopoDS_Edge& Ed, const Standard_Real aMaxTol)
{
  TopoDS_Edge E=Ed;
  E.Orientation(TopAbs_FORWARD);

  gp_Pnt Controlp;
  
  TopExp_Explorer aVExp;
  aVExp.Init(E, TopAbs_VERTEX);
  for (; aVExp.More(); aVExp.Next()) {
    TopoDS_Vertex aVertex= TopoDS::Vertex(aVExp.Current());

    Handle(BRep_TVertex)& TV = *((Handle(BRep_TVertex)*) &aVertex.TShape());
    const gp_Pnt& prep = TV->Pnt();

    Standard_Real Tol, aD2, aNewTolerance, dd;

    Tol =BRep_Tool::Tolerance(aVertex);
    Tol = Max(Tol, BRep_Tool::Tolerance(E));
    dd=0.1*Tol;
    Tol*=Tol;

    const TopLoc_Location& Eloc = E.Location();
    BRep_ListIteratorOfListOfPointRepresentation itpr;
    
    Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*)&E.TShape());
    BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
    while (itcr.More()) {
      const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
      const TopLoc_Location& loc = cr->Location();
      TopLoc_Location L = (Eloc * loc).Predivided(aVertex.Location());
      
      if (cr->IsCurve3D()) {
	const Handle(Geom_Curve)& C = cr->Curve3D();
	if (!C.IsNull()) {
	  itpr.Initialize(TV->Points());
	  while (itpr.More()) {
	    const Handle(BRep_PointRepresentation)& pr = itpr.Value();
	    if (pr->IsPointOnCurve(C,L)) {
	      Controlp = C->Value(pr->Parameter());
	      Controlp.Transform(L.Transformation());
	      aD2=prep.SquareDistance(Controlp);
	      if (aD2 > Tol) {
		aNewTolerance=sqrt(aD2)+dd;
		if (aNewTolerance<aMaxTol)
		  TV->UpdateTolerance(aNewTolerance);
	      }
	    }
	    itpr.Next();
	  }
	  
	  TopAbs_Orientation orv = aVertex.Orientation();
	  if (orv == TopAbs_FORWARD || orv == TopAbs_REVERSED) {
	    const Handle(BRep_GCurve)& GC = *((Handle(BRep_GCurve)*)&cr);
	    
	    if (orv==TopAbs_FORWARD)
	      Controlp = C->Value(GC->First());
	    else 
	      Controlp = C->Value(GC->Last());

	    Controlp.Transform(L.Transformation());
	    aD2=prep.SquareDistance(Controlp);
	    
	    if (aD2 > Tol) {
	      aNewTolerance=sqrt(aD2)+dd;
	      if (aNewTolerance<aMaxTol)
		TV->UpdateTolerance(aNewTolerance);
	    }
	  }
	}
      }
      itcr.Next();
    }
  }
}
Commit	Line	Data
b311480e	1	// Created on: 2001-04-17
	2	// Created by: Peter KURNEV
	3	// Copyright (c) 2001-2012 OPEN CASCADE SAS
	4	//
	5	// The content of this file is subject to the Open CASCADE Technology Public
	6	// License Version 6.5 (the "License"). You may not use the content of this file
	7	// except in compliance with the License. Please obtain a copy of the License
	8	// at http://www.opencascade.org and read it completely before using this file.
	9	//
	10	// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
	11	// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
	12	//
	13	// The Original Code and all software distributed under the License is
	14	// distributed on an "AS IS" basis, without warranty of any kind, and the
	15	// Initial Developer hereby disclaims all such warranties, including without
	16	// limitation, any warranties of merchantability, fitness for a particular
	17	// purpose or non-infringement. Please see the License for the specific terms
	18	// and conditions governing the rights and limitations under the License.
	19
7fd59977	20
	21
	22	#include <BOP_CorrectTolerances.ixx>
	23
	24	#include <TopTools_IndexedMapOfShape.hxx>
	25	#include <TopExp.hxx>
	26	#include <TopExp_Explorer.hxx>
	27
	28	#include <TopoDS.hxx>
	29	#include <TopoDS_Edge.hxx>
	30	#include <TopoDS_Vertex.hxx>
	31	#include <TopoDS_Face.hxx>
	32
	33	#include <TopLoc_Location.hxx>
	34
	35	#include <BRep_TVertex.hxx>
	36	#include <BRep_TEdge.hxx>
	37	#include <BRep_TFace.hxx>
	38	#include <BRep_Tool.hxx>
	39	#include <BRep_GCurve.hxx>
	40	#include <BRep_ListIteratorOfListOfPointRepresentation.hxx>
	41	#include <BRep_ListIteratorOfListOfCurveRepresentation.hxx>
	42	#include <BRep_CurveRepresentation.hxx>
	43	#include <BRep_PointRepresentation.hxx>
	44
	45	#include <Geom_Curve.hxx>
	46	#include <Geom_Surface.hxx>
	47	#include <Geom_Plane.hxx>
	48	#include <Geom_TrimmedCurve.hxx>
	49
	50	#include <GeomAdaptor_Curve.hxx>
	51	#include <GeomAdaptor_HCurve.hxx>
	52	#include <GeomAdaptor_HSurface.hxx>
	53
	54	#include <Geom2d_Curve.hxx>
	55
	56	#include <Geom2dAdaptor_HCurve.hxx>
	57	#include <Geom_RectangularTrimmedSurface.hxx>
	58	#include <Geom2dAdaptor.hxx>
	59	#include <GeomProjLib.hxx>
	60
	61	#include <ProjLib_ProjectedCurve.hxx>
	62	#include <Extrema_LocateExtPC.hxx>
	63
	64	#include <gp_Pnt.hxx>
	65
	66	#include <Adaptor3d_HCurve.hxx>
	67	#include <Adaptor3d_CurveOnSurface.hxx>
	68	#include <Adaptor3d_HCurveOnSurface.hxx>
	69
	70
	71
	72	static
	73	void CheckEdge (const TopoDS_Edge& E,
	74	const Standard_Real aMaxTol);
	75	static
	76	void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
	77	const TopoDS_Face& S,
	78	const Standard_Real aMaxTol);
	79	static
	80	Standard_Boolean Validate(const Adaptor3d_Curve& CRef,
	81	const Adaptor3d_Curve& Other,
	82	const Standard_Real Tol,
	83	const Standard_Boolean SameParameter,
84	Standard_Real& aNewTolerance);
85
86	//
87	static
88	void CorrectVertexTolerance(const TopoDS_Edge& aE);
89	//
90
91	//=======================================================================
92	// Function : CorrectTolerances
93	// purpose :
94	//=======================================================================
95	void BOP_CorrectTolerances::CorrectTolerances(const TopoDS_Shape& aShape,
96	const Standard_Real aMaxTol)
97	{
98	BOP_CorrectTolerances::CorrectPointOnCurve(aShape, aMaxTol);
99	BOP_CorrectTolerances::CorrectCurveOnSurface(aShape, aMaxTol);
100	}
101
102	//=======================================================================
103	// Function : CorrectPointOnCurve
104	// purpose :
105	//=======================================================================
106	void BOP_CorrectTolerances::CorrectPointOnCurve(const TopoDS_Shape& S,
107	const Standard_Real aMaxTol)
108	{
109	Standard_Integer i, aNb;
110	TopTools_IndexedMapOfShape Edges;
111	TopExp::MapShapes (S, TopAbs_EDGE, Edges);
112	aNb=Edges.Extent();
113	for (i=1; i<=aNb; i++) {
114	const TopoDS_Edge& E= TopoDS::Edge(Edges(i));
115	CheckEdge(E, aMaxTol);
116	}
117	}
118
119	//=======================================================================
120	// Function : CorrectCurveOnSurface
121	// purpose :
122	//=======================================================================
123	void BOP_CorrectTolerances::CorrectCurveOnSurface(const TopoDS_Shape& S,
124	const Standard_Real aMaxTol)
125	{
126	Standard_Integer i, aNbFaces, j, aNbEdges;
127	TopTools_IndexedMapOfShape Faces;
128	TopExp::MapShapes (S, TopAbs_FACE, Faces);
129
130	aNbFaces=Faces.Extent();
131	for (i=1; i<=aNbFaces; i++) {
132	const TopoDS_Face& F= TopoDS::Face(Faces(i));
133	TopTools_IndexedMapOfShape Edges;
134	TopExp::MapShapes (F, TopAbs_EDGE, Edges);
135	aNbEdges=Edges.Extent();
136	for (j=1; j<=aNbEdges; j++) {
137	const TopoDS_Edge& E= TopoDS::Edge(Edges(j));
138	CorrectEdgeTolerance (E, F, aMaxTol);
139	}
140	}
141	}
142
143	//=======================================================================
144	// Function : CorrectEdgeTolerance
145	// purpose : Correct tolerances for Edge
146	//=======================================================================
147	void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
148	const TopoDS_Face& S,
149	const Standard_Real aMaxTol)
150	{
151	//
152	// 1. Minimum of conditions to Perform
153	Handle (BRep_CurveRepresentation) myCref;
154	Handle (Adaptor3d_HCurve) myHCurve;
155
156	myCref.Nullify();
157
158	Handle(BRep_TEdge)& TEx = ((Handle(BRep_TEdge))&myShape.TShape());
159	BRep_ListIteratorOfListOfCurveRepresentation itcrx(TEx->Curves());
160	Standard_Boolean Degenerated, SameParameterx, SameRangex;
161
162	Standard_Integer unique = 0;
163
164	Degenerated = TEx->Degenerated();
165	SameParameterx = TEx->SameParameter();
166	SameRangex = TEx->SameRange();
167
168	if (!SameRangex && SameParameterx) {
169	return;
170	}
171
172	Handle(Geom_Curve) C3d;
173	while (itcrx.More()) {
174	const Handle(BRep_CurveRepresentation)& cr = itcrx.Value();
175	if (cr->IsCurve3D()) {
176	unique++;
177	if (myCref.IsNull() && !cr->Curve3D().IsNull()) {
178	myCref = cr;
179	}
180	}
181	itcrx.Next();
182	}
183
184	if (unique==0) {
185	return;//...No3DCurve
186	}
187	if (unique>1) {
188	return;//...Multiple3DCurve;
189	}
190
191	if (myCref.IsNull() && !Degenerated) {
192	itcrx.Initialize(TEx->Curves());
193	while (itcrx.More()) {
194	const Handle(BRep_CurveRepresentation)& cr = itcrx.Value();
195	if (cr->IsCurveOnSurface()) {
196	myCref = cr;
197	break;
198	}
199	itcrx.Next();
200	}
201	}
202
203	else if (!myCref.IsNull() && Degenerated){
204	return ;//...InvalidDegeneratedFlag;
205	}
206
207	if (!myCref.IsNull()) {
208	const Handle(BRep_GCurve)& GCref = ((Handle(BRep_GCurve))&myCref);
209	Standard_Real First,Last;
210	GCref->Range(First,Last);
211	if (Last<=First) {
212	myCref.Nullify();
213	return ;//InvalidRange;
214	}
215
216	else {
217	if (myCref->IsCurve3D()) {
218	Handle(Geom_Curve) C3dx = Handle(Geom_Curve)::DownCast
219	(myCref->Curve3D()->Transformed (myCref->Location().Transformation()));
220	GeomAdaptor_Curve GAC3d(C3dx, First, Last);
221	myHCurve = new GeomAdaptor_HCurve(GAC3d);
222	}
223	else { // curve on surface
224	Handle(Geom_Surface) Sref = myCref->Surface();
225	Sref = Handle(Geom_Surface)::DownCast(Sref->Transformed(myCref->Location().Transformation()));
226	const Handle(Geom2d_Curve)& PCref = myCref->PCurve();
227	Handle(GeomAdaptor_HSurface) GAHSref = new GeomAdaptor_HSurface(Sref);
228	Handle(Geom2dAdaptor_HCurve) GHPCref = new Geom2dAdaptor_HCurve(PCref, First, Last);
229	Adaptor3d_CurveOnSurface ACSref(GHPCref,GAHSref);
230	myHCurve = new Adaptor3d_HCurveOnSurface(ACSref);
231	}
232	}
233	}
234
235	//===============================================
236	// 2. Tolerances in InContext
237	{
238	if (myCref.IsNull())
239	return;
240	Standard_Boolean ok=Standard_True;;
241
242	Handle(BRep_TEdge)& TE = ((Handle(BRep_TEdge))&myShape.TShape());
243	Standard_Real Tol = BRep_Tool::Tolerance(TopoDS::Edge(myShape));
244	Standard_Real aNewTol=Tol;
245
246	Standard_Boolean SameParameter = TE->SameParameter();
247	Standard_Boolean SameRange = TE->SameRange();
248	Standard_Real First = myHCurve->FirstParameter();
249	Standard_Real Last = myHCurve->LastParameter();
250	Standard_Real Delta =1.e-14;
251
252	Handle(BRep_TFace)& TF = ((Handle(BRep_TFace)) &S.TShape());
253	const TopLoc_Location& Floc = S.Location();
254	const TopLoc_Location& TFloc = TF->Location();
255	const Handle(Geom_Surface)& Su = TF->Surface();
256	TopLoc_Location L = (Floc * TFloc).Predivided(myShape.Location());
257	// Standard_Boolean checkclosed = Standard_False;
258	Standard_Boolean pcurvefound = Standard_False;
259
260	BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
261	while (itcr.More()) {
262	const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
263	if (cr != myCref && cr->IsCurveOnSurface(Su,L)) {
264	pcurvefound = Standard_True;
265	const Handle(BRep_GCurve)& GC = ((Handle(BRep_GCurve))&cr);
266	Standard_Real f,l;
267	GC->Range(f,l);
268	if (SameRange && (f != First \|\| l != Last)) {
269	return ;//BRepCheck_InvalidSameRangeFlag);
270	if (SameParameter) {
271	return; //BRepCheck_InvalidSameParameterFlag);
272	}
273	}
274
275	Handle(Geom_Surface) Sb = cr->Surface();
276	Sb = Handle(Geom_Surface)::DownCast (Su->Transformed(L.Transformation()));
277	Handle(Geom2d_Curve) PC = cr->PCurve();
278	Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(Sb);
279	Handle(Geom2dAdaptor_HCurve) GHPC = new Geom2dAdaptor_HCurve(PC,f,l);
280	Adaptor3d_CurveOnSurface ACS(GHPC,GAHS);
281	ok = Validate(myHCurve->Curve(), ACS, Tol, SameParameter, aNewTol);
282	if (ok) {
283	if (cr->IsCurveOnClosedSurface()) {
284	//return ;// BRepCheck::Add(lst,BRepCheck_InvalidCurveOnClosedSurface);
285	}
286	else {
287	//return;//BRepCheck::Add(lst,BRepCheck_InvalidCurveOnSurface);
288	}
289	if (SameParameter) {
290	//return;//BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag);
291	}
292	//
293	if (aNewTol<aMaxTol) {
294	TE->UpdateTolerance(aNewTol+Delta);
295	//
296	CorrectVertexTolerance(myShape);
297	}
298	}
299
300	if (cr->IsCurveOnClosedSurface()) {
301	// checkclosed = Standard_True;
302	GHPC->ChangeCurve2d().Load(cr->PCurve2(),f,l); // same bounds
303	ACS.Load(GAHS); // sans doute inutile
304	ACS.Load(GHPC); // meme remarque...
305	ok = Validate(myHCurve->Curve(),ACS,Tol,SameParameter, aNewTol);
306	if (ok) {
307	//return;//BRepCheck::Add(lst,BRepCheck_InvalidCurveOnClosedSurface);
308	if (SameParameter) {
309	//return;//BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag);
310	}
311	if (aNewTol<aMaxTol) {
312	TE->UpdateTolerance(aNewTol+Delta);
313	CorrectVertexTolerance(myShape);
314	}
315	}
316	}
317	}
318	itcr.Next();
319	}
320
321	if (!pcurvefound) {
322	Handle(Geom_Plane) P;
323	Handle(Standard_Type) styp = Su->DynamicType();
324	if (styp == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
325	P = Handle(Geom_Plane)::DownCast(Handle(Geom_RectangularTrimmedSurface)::
326	DownCast(Su)->BasisSurface());
327	}
328	else {
329	P = Handle(Geom_Plane)::DownCast(Su);
330	}
331	if (P.IsNull()) { // not a plane
332	return;//BRepCheck::Add(lst,BRepCheck_NoCurveOnSurface);
333	}
334
335	else {// on fait la projection a la volee, comme BRep_Tool
336	P = Handle(Geom_Plane)::DownCast(P->Transformed(L.Transformation()));
337	//on projette Cref sur ce plan
338	Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(P);
339
340	// Dub - Normalement myHCurve est une GeomAdaptor_HCurve
341	GeomAdaptor_Curve& Gac = Handle(GeomAdaptor_HCurve)::DownCast(myHCurve)->ChangeCurve();
342	Handle(Geom_Curve) C3dx = Gac.Curve();
343	Handle(Geom_Curve) ProjOnPlane = GeomProjLib::ProjectOnPlane
344	(new Geom_TrimmedCurve(C3dx,First,Last), P, P->Position().Direction(), Standard_True);
345
346	Handle(GeomAdaptor_HCurve) aHCurve = new GeomAdaptor_HCurve(ProjOnPlane);
347
348	ProjLib_ProjectedCurve proj(GAHS,aHCurve);
349	Handle(Geom2d_Curve) PC = Geom2dAdaptor::MakeCurve(proj);
350	Handle(Geom2dAdaptor_HCurve) GHPC =
351	new Geom2dAdaptor_HCurve(PC, myHCurve->FirstParameter(), myHCurve->LastParameter());
352
353	Adaptor3d_CurveOnSurface ACS(GHPC,GAHS);
354
355	Standard_Boolean okx = Validate(myHCurve->Curve(),ACS,
356	Tol,Standard_True, aNewTol); // voir dub...
357	if (okx) {
358	//return;//BRepCheck::Add(lst,BRepCheck_InvalidCurveOnSurface);
359	if (aNewTol<aMaxTol) {
360	TE->UpdateTolerance(aNewTol+Delta);
361	CorrectVertexTolerance(myShape);
362	}
363	}
364	}
365
366	}//end of if (!pcurvefound) {
367	} // end of 2. Tolerances in InContext
368
369	}
370
371	//=======================================================================
372	//function : CorrectVertexTolerance
373	//purpose :
374	//=======================================================================
375	void CorrectVertexTolerance(const TopoDS_Edge& aE)
376	{
377	Standard_Integer k, aNbV;
378	Standard_Real aTolE, aTolV;
379	TopTools_IndexedMapOfShape aVMap;
380
381	aTolE=BRep_Tool::Tolerance(aE);
382
383	TopExp::MapShapes(aE, TopAbs_VERTEX, aVMap);
384	aNbV=aVMap.Extent();
385	for (k=1; k<=aNbV; ++k) {
386	const TopoDS_Vertex& aV=TopoDS::Vertex(aVMap(k));
387	aTolV=BRep_Tool::Tolerance(aV);
388	if (aTolV<aTolE) {
389	Handle(BRep_TVertex)& aTV = ((Handle(BRep_TVertex))&aV.TShape());
390	aTV->UpdateTolerance(aTolE);
391	}
392	}
393	}
394
395
396
397	#define NCONTROL 23
398	//=======================================================================
399	//function : Validate
400	//purpose :
401	//=======================================================================
402	Standard_Boolean Validate(const Adaptor3d_Curve& CRef,
403	const Adaptor3d_Curve& Other,
404	const Standard_Real Tol,
405	const Standard_Boolean SameParameter,
406	Standard_Real& aNewTolerance)
407	{
408	Standard_Real First, Last, MaxDistance, aD, Tol2;
409
410	First = CRef.FirstParameter();
411	Last = CRef.LastParameter();
412	MaxDistance = 0.;
413	Tol2 = Tol*Tol;
414
415	Standard_Integer i, aNC1=NCONTROL-1;
416
417	Standard_Boolean aFlag=Standard_False;
418	Standard_Boolean proj = (!SameParameter \|\|
419	First != Other.FirstParameter() \|\|
420	Last != Other.LastParameter());
421	//
422	// 1.
423	if (!proj) {
424	for (i = 0; i < NCONTROL; i++) {
425	Standard_Real prm = ((aNC1-i)First + iLast)/aNC1;
426	gp_Pnt pref = CRef.Value(prm);
427	gp_Pnt pother = Other.Value(prm);
428
429	aD=pref.SquareDistance(pother);
430
431	if (aD > Tol2) {
432	if (aD>MaxDistance) {
433	MaxDistance=aD;
434	}
435	aFlag=Standard_True;
436	}
437	}
438
439	if (aFlag) {
440	aNewTolerance=sqrt(MaxDistance);
441	}
442	return aFlag;
443	}
444
445	//
446	// 2.
447	else {
448	Extrema_LocateExtPC refd,otherd;
449	Standard_Real OFirst, OLast;
450	OFirst = Other.FirstParameter();
451	OLast = Other.LastParameter();
452
453	gp_Pnt pd = CRef.Value(First);
454	gp_Pnt pdo = Other.Value(OFirst);
455
456	aD = pd.SquareDistance(pdo);
457	if (aD > Tol2) {
458	if (aD>MaxDistance) {
459	MaxDistance=aD;
460	}
461	aFlag=Standard_True;
462	}
463
464	pd = CRef.Value(Last);
465	pdo = Other.Value(OLast);
466	aD = pd.SquareDistance(pdo);
467	if (aD > Tol2 && aD > MaxDistance) {
468	MaxDistance=aD;
469	aFlag=Standard_True;
470	}
471
472	refd.Initialize(CRef, First, Last, CRef.Resolution(Tol));
473	otherd.Initialize(Other, OFirst, OLast, Other.Resolution(Tol));
474
475	for (i = 2; i< aNC1; i++) {
476	Standard_Real rprm = ((aNC1-i)First + iLast)/aNC1;
477	gp_Pnt pref = CRef.Value(rprm);
478
479	Standard_Real oprm = ((aNC1-i)OFirst + iOLast)/aNC1;
480	gp_Pnt pother = Other.Value(oprm);
481
482	refd.Perform(pother,rprm);
483	if (!refd.IsDone() \|\| refd.SquareDistance() > Tol2) {
484	if (refd.IsDone()) {
485	aD=refd.SquareDistance();
486	if (aD > Tol2 && aD>MaxDistance) {
487	aFlag=Standard_True;
488	MaxDistance=aD;
489	}
490	}
491	}
492
493	otherd.Perform(pref,oprm);
494	if (!otherd.IsDone() \|\| otherd.SquareDistance() > Tol2) {
495
496	if (otherd.IsDone()) {
497	aD=otherd.SquareDistance();
498	if (aD > Tol2 && aD>MaxDistance) {
499	aFlag=Standard_True;
500	MaxDistance=aD;
501	}
502	}
503	}
504	}
505	}
506
507	aD=sqrt (MaxDistance);
508	aNewTolerance=aD;
509
510	return aFlag;
511
512	}
513
514	//=======================================================================
515	// Function : CheckEdge
516	// purpose : Correct tolerances for Vertices on Edge
517	//=======================================================================
518	void CheckEdge (const TopoDS_Edge& Ed, const Standard_Real aMaxTol)
519	{
520	TopoDS_Edge E=Ed;
521	E.Orientation(TopAbs_FORWARD);
522
523	gp_Pnt Controlp;
524
525	TopExp_Explorer aVExp;
526	aVExp.Init(E, TopAbs_VERTEX);
527	for (; aVExp.More(); aVExp.Next()) {
528	TopoDS_Vertex aVertex= TopoDS::Vertex(aVExp.Current());
529
530	Handle(BRep_TVertex)& TV = ((Handle(BRep_TVertex)) &aVertex.TShape());
531	const gp_Pnt& prep = TV->Pnt();
532
533	Standard_Real Tol, aD2, aNewTolerance, dd;
534
535	Tol =BRep_Tool::Tolerance(aVertex);
536	Tol = Max(Tol, BRep_Tool::Tolerance(E));
537	dd=0.1*Tol;
538	Tol*=Tol;
539
540	const TopLoc_Location& Eloc = E.Location();
541	BRep_ListIteratorOfListOfPointRepresentation itpr;
542
543	Handle(BRep_TEdge)& TE = ((Handle(BRep_TEdge))&E.TShape());
544	BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
545	while (itcr.More()) {
546	const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
547	const TopLoc_Location& loc = cr->Location();
548	TopLoc_Location L = (Eloc * loc).Predivided(aVertex.Location());
549
550	if (cr->IsCurve3D()) {
551	const Handle(Geom_Curve)& C = cr->Curve3D();
552	if (!C.IsNull()) {
553	itpr.Initialize(TV->Points());
554	while (itpr.More()) {
555	const Handle(BRep_PointRepresentation)& pr = itpr.Value();
556	if (pr->IsPointOnCurve(C,L)) {
557	Controlp = C->Value(pr->Parameter());
558	Controlp.Transform(L.Transformation());
559	aD2=prep.SquareDistance(Controlp);
560	if (aD2 > Tol) {
561	aNewTolerance=sqrt(aD2)+dd;
562	if (aNewTolerance<aMaxTol)
563	TV->UpdateTolerance(aNewTolerance);
564	}
565	}
566	itpr.Next();
567	}
568
569	TopAbs_Orientation orv = aVertex.Orientation();
570	if (orv == TopAbs_FORWARD \|\| orv == TopAbs_REVERSED) {
571	const Handle(BRep_GCurve)& GC = ((Handle(BRep_GCurve))&cr);
572
573	if (orv==TopAbs_FORWARD)
574	Controlp = C->Value(GC->First());
575	else
576	Controlp = C->Value(GC->Last());
577
578	Controlp.Transform(L.Transformation());
579	aD2=prep.SquareDistance(Controlp);
580
581	if (aD2 > Tol) {
582	aNewTolerance=sqrt(aD2)+dd;
583	if (aNewTolerance<aMaxTol)
584	TV->UpdateTolerance(aNewTolerance);
585	}
586	}
587	}
588	}
589	itcr.Next();
590	}
591	}
592	}
593