[occt.git] / src / IntTools / IntTools_Tools.cxx

// Created on: 2000-11-16
// Created by: Peter KURNEV
// Copyright (c) 2000-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 <IntTools_Tools.ixx>

#include <Precision.hxx>

#include <TopExp_Explorer.hxx>
#include <TopTools_IndexedDataMapOfShapeShape.hxx>

#include <TopoDS.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Wire.hxx>
#include <TopLoc_Location.hxx>

#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_Surface.hxx>

#include <gp_Pnt.hxx>
#include <gp_Pnt2d.hxx>
#include <gp.hxx>
#include <gp_Lin.hxx>
#include <gp_Dir.hxx>
#include <gp_Ax1.hxx>

#include <Geom_Curve.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <Geom_Surface.hxx>
#include <GeomAPI_ProjectPointOnSurf.hxx>
#include <GeomAPI_ProjectPointOnCurve.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAbs_CurveType.hxx>
#include <Geom_Line.hxx>
#include <Geom2d_Curve.hxx>
#include <Geom_BoundedCurve.hxx>
#include <Geom_Geometry.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <Geom2d_TrimmedCurve.hxx>

#include <IntTools_FClass2d.hxx>
#include <IntTools_Curve.hxx>
#include <IntTools_SequenceOfCurves.hxx>

static
  void ParabolaTolerance(const Handle(Geom_Curve)& ,
			 const Standard_Real ,
			 const Standard_Real ,
			 const Standard_Real ,
			 Standard_Real& ,
			 Standard_Real& );

//=======================================================================
//function : HasInternalEdge
//purpose  : 
//=======================================================================
  Standard_Boolean IntTools_Tools::HasInternalEdge(const TopoDS_Wire& aW)
{
  Standard_Boolean bFlag=Standard_True;

  TopExp_Explorer anExp(aW, TopAbs_EDGE);
  for (; anExp.More(); anExp.Next()) {
    const TopoDS_Edge& aE=TopoDS::Edge(anExp.Current());
    TopAbs_Orientation anOr=aE.Orientation();
    if (anOr==TopAbs_INTERNAL) {
      return bFlag;
    }
  }
  return !bFlag;
}

//=======================================================================
//function : IsClosed
//purpose  : 
//=======================================================================
  Standard_Boolean IntTools_Tools::IsClosed (const Handle(Geom_Curve)& aC3D)
{
  Standard_Boolean bRet;
  Standard_Real aF, aL, aDist, aPC;
  gp_Pnt aP1, aP2;
  
  Handle (Geom_BoundedCurve) aGBC=
      Handle (Geom_BoundedCurve)::DownCast(aC3D);
  if (aGBC.IsNull()) {
    return Standard_False;
  }
  
  aF=aC3D->FirstParameter();
  aL=aC3D-> LastParameter();
  
  aC3D->D0(aF, aP1);
  aC3D->D0(aL, aP2);

  
  //
  //modified by NIZNHY-PKV Mon Jul 04 11:58:23 2011f
  aPC=Precision::Confusion();
  aPC=aPC*aPC;
  aDist=aP1.SquareDistance(aP2);
  bRet=aDist<aPC;
  return bRet;
  //
  //aDist=aP1.Distance(aP2);
  //return (aDist < Precision::Confusion()); 
  //modified by NIZNHY-PKV Mon Jul 04 11:59:50 2011t
}

//=======================================================================
//function : RejectLines
//purpose  : 
//=======================================================================
   void IntTools_Tools::RejectLines(const IntTools_SequenceOfCurves& aSIn,
				    IntTools_SequenceOfCurves& aSOut)
{
  Standard_Integer i, j, aNb;
  Standard_Boolean bFlag;
  Handle (Geom_Curve) aC3D;

  gp_Dir aD1, aD2;

  aSOut.Clear();

  aNb=aSIn.Length();
  for (i=1; i<=aNb; i++) {
    const IntTools_Curve& IC=aSIn(i);
    aC3D=IC.Curve();
    //
    Handle (Geom_TrimmedCurve) aGTC=
      Handle (Geom_TrimmedCurve)::DownCast(aC3D);
    
    if (!aGTC.IsNull()) {
      aC3D=aGTC->BasisCurve();
      IntTools_Curve* pIC=(IntTools_Curve*) &IC;
      pIC->SetCurve(aC3D);
    }
    //
    Handle (Geom_Line) aGLine=
      Handle (Geom_Line)::DownCast(aC3D);
    
    if (aGLine.IsNull()) {
      aSOut.Clear();
      for (j=1; j<=aNb; j++) {
	aSOut.Append(aSIn(j));
      }
      return;
    }
    //
    gp_Lin aLin=aGLine->Lin();
    aD2=aLin.Direction();
    if (i==1) {
      aSOut.Append(IC);
      aD1=aD2;
      continue;
    }
    
    bFlag=IntTools_Tools::IsDirsCoinside(aD1, aD2);
    if (!bFlag) {
      aSOut.Append(IC);
      return;
    }
  }
}

//=======================================================================
//function : IsDirsCoinside
//purpose  : 
//=======================================================================
  Standard_Boolean IntTools_Tools::IsDirsCoinside  (const gp_Dir& D1, const gp_Dir& D2)
{
  Standard_Boolean bFlag;
  gp_Pnt P1(D1.X(), D1.Y(), D1.Z());  
  gp_Pnt P2(D2.X(), D2.Y(), D2.Z());
  Standard_Real dLim=0.0002, d;
  d=P1.Distance (P2); 
  bFlag= (d<dLim || fabs (2.-d)<dLim); 
  return bFlag;
}
  
//=======================================================================
//function : IsDirsCoinside
//purpose  : 
//=======================================================================
  Standard_Boolean IntTools_Tools::IsDirsCoinside  (const gp_Dir& D1, 
						    const gp_Dir& D2,
						    const Standard_Real dLim)
{
  Standard_Boolean bFlag;
  Standard_Real d;
  //
  gp_Pnt P1(D1.X(), D1.Y(), D1.Z());  
  gp_Pnt P2(D2.X(), D2.Y(), D2.Z());
  d=P1.Distance (P2); 
  bFlag= (d<dLim || fabs (2.-d)<dLim); 
  return bFlag;
}
//=======================================================================
//function : SplitCurve
//purpose  : 
//=======================================================================
  Standard_Integer IntTools_Tools::SplitCurve(const IntTools_Curve& IC,
					      IntTools_SequenceOfCurves& aCvs)
{
  Handle (Geom_Curve) aC3D =IC.Curve();
  if(aC3D.IsNull())
    return 0;
  //
  Handle (Geom2d_Curve) aC2D1=IC.FirstCurve2d();
  Handle (Geom2d_Curve) aC2D2=IC.SecondCurve2d();
  Standard_Boolean bIsClosed;

  bIsClosed=IntTools_Tools::IsClosed(aC3D);
  if (!bIsClosed) {
    return 0;
  }

  Standard_Real aF, aL, aMid;
  
  //
  aF=aC3D->FirstParameter();
  aL=aC3D->LastParameter();
  aMid=0.5*(aF+aL);
  GeomAdaptor_Curve aGAC(aC3D);
  GeomAbs_CurveType aCT=aGAC.GetType();
  if (aCT==GeomAbs_BSplineCurve ||
      aCT==GeomAbs_BezierCurve) {
    //aMid=0.5*aMid;
    aMid=IntTools_Tools::IntermediatePoint(aF, aL);
  }
  //
  Handle(Geom_Curve) aC3DNewF, aC3DNewL;
  aC3DNewF =new Geom_TrimmedCurve  (aC3D, aF, aMid);
  aC3DNewL =new Geom_TrimmedCurve  (aC3D, aMid, aL);

  //
  Handle (Geom2d_Curve) aC2D1F, aC2D1L, aC2D2F, aC2D2L;
  //
  if(!aC2D1.IsNull()) {
    aC2D1F=new Geom2d_TrimmedCurve (aC2D1, aF, aMid);
    aC2D1L=new Geom2d_TrimmedCurve (aC2D1, aMid, aL);
  }

  if(!aC2D2.IsNull()) {
    aC2D2F=new Geom2d_TrimmedCurve (aC2D2, aF, aMid);
    aC2D2L=new Geom2d_TrimmedCurve (aC2D2, aMid, aL);
  }
  // 
  
  IntTools_Curve aIC1(aC3DNewF, aC2D1F, aC2D2F);
  IntTools_Curve aIC2(aC3DNewL, aC2D1L, aC2D2L);
  //
  aCvs.Append(aIC1);
  //
  aCvs.Append(aIC2);
  //
  return 2;
}

//=======================================================================
//function : IntermediatePoint
//purpose  : 
//=======================================================================
  Standard_Real IntTools_Tools::IntermediatePoint (const Standard_Real aFirst,
						   const Standard_Real aLast)
{
  //define parameter division number as 10*e^(-M_PI) = 0.43213918
  const Standard_Real PAR_T = 0.43213918;
  Standard_Real aParm;
  aParm=(1.-PAR_T)*aFirst + PAR_T*aLast;
  return aParm;
}

//=======================================================================
//function : IsVertex
//purpose  : 
//=======================================================================
  Standard_Boolean IntTools_Tools::IsVertex (const gp_Pnt& aP,
					     const Standard_Real aTolPV,
					     const TopoDS_Vertex& aV)
{
  Standard_Boolean bRet;
  Standard_Real aTolV, aD, dTol;
  gp_Pnt aPv; 
  
  aTolV=BRep_Tool::Tolerance(aV);
  //
  dTol=Precision::Confusion();
  aTolV=aTolV+aTolPV+dTol;
  //
  aPv=BRep_Tool::Pnt(aV);
  //
  //modified by NIZNHY-PKV Mon Jul 04 12:00:37 2011f
  aD=aPv.SquareDistance(aP);
  aTolV=aTolV*aTolV;
  bRet=(aD<=aTolV);
  return bRet;
  //
  //aD=aPv.Distance(aP);
  //return (aD<=aTolV);
  //modified by NIZNHY-PKV Mon Jul 04 12:00:40 2011t
}


//=======================================================================
//function : IsVertex
//purpose  : 
//=======================================================================
  Standard_Boolean IntTools_Tools::IsVertex (const IntTools_CommonPrt& aCmnPrt)
{
  Standard_Boolean anIsVertex;
  Standard_Real aParam;

  const TopoDS_Edge&    aE1=aCmnPrt.Edge1();
  const IntTools_Range& aR1=aCmnPrt.Range1();
  aParam=0.5*(aR1.First()+aR1.Last());
  anIsVertex=IntTools_Tools::IsVertex (aE1, aParam);
  
  if (anIsVertex) {
    return Standard_True;
  }

  const TopoDS_Edge&    aE2=aCmnPrt.Edge2();
  const IntTools_SequenceOfRanges& aRs2=aCmnPrt.Ranges2();
  const IntTools_Range& aR2=aRs2(1);
  aParam=0.5*(aR2.First()+aR2.Last());
  anIsVertex=IntTools_Tools::IsVertex (aE2, aParam);
  if (anIsVertex) {
    return Standard_True;
  }
  return Standard_False;
}

//=======================================================================
//function : IsVertex
//purpose  : 
//=======================================================================
  Standard_Boolean IntTools_Tools::IsVertex (const TopoDS_Edge& aE,
					     const TopoDS_Vertex& aV,
					     const Standard_Real t)
{
  Standard_Real aTolV, aTolV2, d2;
  gp_Pnt aPv, aPt; 
  
  BRepAdaptor_Curve aBAC(aE);
  aBAC.D0(t, aPt);

  aTolV=BRep_Tool::Tolerance(aV);
  aTolV2=aTolV*aTolV;
  aPv=BRep_Tool::Pnt(aV);
  d2=aPv.SquareDistance (aPt);
  if (d2 < aTolV2) {
    return Standard_True;
  }
  return Standard_False;
}
//=======================================================================
//function : IsVertex
//purpose  : 
//=======================================================================
  Standard_Boolean IntTools_Tools::IsVertex (const TopoDS_Edge& aE,
					     const Standard_Real t)
{
  Standard_Real aTolV, aTolV2, d2;
  TopoDS_Vertex aV;
  gp_Pnt aPv, aPt; 
  
  BRepAdaptor_Curve aBAC(aE);
  aBAC.D0(t, aPt);

  TopExp_Explorer anExp(aE, TopAbs_VERTEX);
  for (; anExp.More(); anExp.Next()) {
    aV=TopoDS::Vertex (anExp.Current());
    aTolV=BRep_Tool::Tolerance(aV);
    aTolV2=aTolV*aTolV;
    aTolV2=1.e-12;
     aPv=BRep_Tool::Pnt(aV);
     d2=aPv.SquareDistance (aPt);
     if (d2 < aTolV2) {
       return Standard_True;
     }
  }
  return Standard_False;
}


//=======================================================================
//function : ComputeVV
//purpose  : 
//=======================================================================
  Standard_Integer IntTools_Tools::ComputeVV(const TopoDS_Vertex& aV1, 
					     const TopoDS_Vertex& aV2)
{
  Standard_Real aTolV1, aTolV2, aTolSum, d;
  gp_Pnt aP1, aP2;

  aTolV1=BRep_Tool::Tolerance(aV1);
  aTolV2=BRep_Tool::Tolerance(aV2);
  aTolSum=aTolV1+aTolV2;
  
  aP1=BRep_Tool::Pnt(aV1);
  aP2=BRep_Tool::Pnt(aV2);
  //modified by NIZNHY-PKV Mon Jul 04 11:55:52 2011f
  aTolSum=aTolSum*aTolSum;
  d=aP1.SquareDistance(aP2);
  //d=aP1.Distance(aP2);
  //modified by NIZNHY-PKV Mon Jul 04 11:55:53 2011t
  if (d<aTolSum) {
    return 0;
  }
  return -1;
}

//=======================================================================
//function : MakeFaceFromWireAndFace
//purpose  : 
//=======================================================================
  void IntTools_Tools::MakeFaceFromWireAndFace(const TopoDS_Wire& aW,
					       const TopoDS_Face& aF,
					       TopoDS_Face& aFNew)
{
  TopoDS_Face aFF;
  aFF=aF;
  aFF.Orientation(TopAbs_FORWARD);
  aFNew=TopoDS::Face (aFF.EmptyCopied());
  BRep_Builder BB;
  BB.Add(aFNew, aW);
}

//=======================================================================
//function : ClassifyPointByFace
//purpose  : 
//=======================================================================
  TopAbs_State IntTools_Tools::ClassifyPointByFace(const TopoDS_Face& aF,
						   const gp_Pnt2d& aP2d)
{
  Standard_Real aFaceTolerance;
  TopAbs_State aState;
  
  aFaceTolerance=BRep_Tool::Tolerance(aF);
  IntTools_FClass2d aClass2d(aF, aFaceTolerance);
  aState=aClass2d.Perform(aP2d);
  
  return aState;
}

//=======================================================================
//function : IsMiddlePointsEqual
//purpose  : 
//=======================================================================
  Standard_Boolean IntTools_Tools::IsMiddlePointsEqual(const TopoDS_Edge& aE1,
						       const TopoDS_Edge& aE2)
						       
{
  Standard_Boolean bRet;
  Standard_Real f1, l1, m1, f2, l2, m2, aTol1, aTol2, aSumTol, aD2;
  gp_Pnt aP1, aP2;

  aTol1=BRep_Tool::Tolerance(aE1);
  Handle(Geom_Curve) C1=BRep_Tool::Curve(aE1, f1, l1);
  m1=0.5*(f1+l1);
  C1->D0(m1, aP1);

  aTol2=BRep_Tool::Tolerance(aE2);
  Handle(Geom_Curve) C2=BRep_Tool::Curve(aE2, f2, l2);
  m2=0.5*(f2+l2);
  C2->D0(m2, aP2);

  aSumTol=aTol1+aTol2;
  //modified by NIZNHY-PKV Mon Jul 04 12:02:20 2011f
  aSumTol=aSumTol*aSumTol;
  aD2=aP1.SquareDistance(aP2);
  bRet=aD2<aSumTol;
  return bRet;
  //
  //if (aP1.Distance(aP2) < aSumTol) {
  //  return Standard_True;
  //}
  //return Standard_False;
  //modified by NIZNHY-PKV Mon Jul 04 12:02:24 2011t
}

//=======================================================================
//function : CurveTolerance
//purpose  : 
//=======================================================================
  Standard_Real IntTools_Tools::CurveTolerance(const Handle(Geom_Curve)& aC3D,
					       const Standard_Real aTolBase)
{
  Standard_Real aTolReached, aTf, aTl, aTolMin, aTolMax;

  aTolReached=aTolBase;
  //
  if (aC3D.IsNull()) {
    return aTolReached;
  }
  //
  Handle(Geom_TrimmedCurve) aCT3D=Handle(Geom_TrimmedCurve)::DownCast(aC3D);
  if (aCT3D.IsNull()) {
    return aTolReached;
  }
  //
  aTolMin=aTolBase;
  aTolMax=aTolBase;
  //
  aTf=aCT3D->FirstParameter();
  aTl=aCT3D->LastParameter();
  //
  GeomAdaptor_Curve aGAC(aCT3D);
  GeomAbs_CurveType aCType=aGAC.GetType();
  //
  if (aCType==GeomAbs_Parabola) {
    Handle(Geom_Curve) aC3DBase=aCT3D->BasisCurve();
    ParabolaTolerance(aC3DBase, aTf, aTl, aTolBase, aTolMin, aTolMax);
    aTolReached=aTolMax;
  }
  //
  return aTolReached;
}

#include <Geom_Parabola.hxx>
#include <gp_Parab.hxx>
//=======================================================================
//function : ParabolaTolerance
//purpose  : 
//=======================================================================
void ParabolaTolerance(const Handle(Geom_Curve)& aC3D,
		       const Standard_Real aTf,
		       const Standard_Real aTl,
		       const Standard_Real aTol,
		       Standard_Real& aTolMin,
		       Standard_Real& aTolMax)
{
  
  aTolMin=aTol;
  aTolMax=aTol;

  Handle(Geom_Parabola) aGP=Handle(Geom_Parabola)::DownCast(aC3D);
  if (aGP.IsNull()){
    return;
  }

  Standard_Integer aNbPoints;
  Standard_Real aFocal, aX1, aX2, aTol1, aTol2;
  gp_Pnt aPf, aPl;
  gp_Parab aParab=aGP->Parab();
  gp_Ax1 aXAxis=aParab.XAxis();
  Handle(Geom_Line) aGAxis=new Geom_Line(aXAxis);

  aFocal=aGP->Focal();
  if (aFocal==0.) {
    return;
  }
  //
  // aTol1
  aTol1=aTol;
  aX1=0.;
  aGP->D0(aTf, aPf);
  GeomAPI_ProjectPointOnCurve aProj1(aPf, aGAxis);
  aNbPoints=aProj1.NbPoints();
  if (aNbPoints) {
    aX1=aProj1.LowerDistanceParameter();
  }
  if (aX1>=0.) {
    aTol1=aTol*sqrt(0.5*aX1/aFocal);
  }
  if (aTol1==0.) {
    aTol1=aTol;
  }
  //
  // aTol2
  aTol2=aTol;
  aX2=0.;
  aGP->D0(aTl, aPl);
  GeomAPI_ProjectPointOnCurve aProj2(aPl, aGAxis);
  aNbPoints=aProj2.NbPoints();
  if (aNbPoints) {
    aX2=aProj2.LowerDistanceParameter();
  }
  
  if (aX2>=0.) {
    aTol2=aTol*sqrt(0.5*aX2/aFocal);
  }
  if (aTol2==0.) {
    aTol2=aTol;
  }
  //
  aTolMax=(aTol1>aTol2) ? aTol1 : aTol2;
  aTolMin=(aTol1<aTol2) ? aTol1 : aTol2;
}
Commit	Line	Data
b311480e	1	// Created on: 2000-11-16
	2	// Created by: Peter KURNEV
	3	// Copyright (c) 2000-2012 OPEN CASCADE SAS
7fd59977	4	//
b311480e	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	#include <IntTools_Tools.ixx>
	22
	23	#include <Precision.hxx>
	24
	25	#include <TopExp_Explorer.hxx>
	26	#include <TopTools_IndexedDataMapOfShapeShape.hxx>
	27
	28	#include <TopoDS.hxx>
	29	#include <TopoDS_Shape.hxx>
	30	#include <TopoDS_Vertex.hxx>
	31	#include <TopoDS_Edge.hxx>
	32	#include <TopoDS_Face.hxx>
	33	#include <TopoDS_Wire.hxx>
	34	#include <TopLoc_Location.hxx>
	35
	36	#include <BRep_Builder.hxx>
	37	#include <BRep_Tool.hxx>
	38	#include <BRepAdaptor_Surface.hxx>
	39	#include <BRepAdaptor_Curve.hxx>
	40	#include <BRepAdaptor_Surface.hxx>
	41
	42	#include <gp_Pnt.hxx>
	43	#include <gp_Pnt2d.hxx>
	44	#include <gp.hxx>
	45	#include <gp_Lin.hxx>
	46	#include <gp_Dir.hxx>
	47	#include <gp_Ax1.hxx>
	48
	49	#include <Geom_Curve.hxx>
	50	#include <GeomAdaptor_Surface.hxx>
	51	#include <Geom_Surface.hxx>
	52	#include <GeomAPI_ProjectPointOnSurf.hxx>
	53	#include <GeomAPI_ProjectPointOnCurve.hxx>
	54	#include <GeomAdaptor_Curve.hxx>
	55	#include <GeomAbs_CurveType.hxx>
	56	#include <Geom_Line.hxx>
	57	#include <Geom2d_Curve.hxx>
	58	#include <Geom_BoundedCurve.hxx>
	59	#include <Geom_Geometry.hxx>
	60	#include <Geom_TrimmedCurve.hxx>
	61	#include <Geom2d_TrimmedCurve.hxx>
	62
	63	#include <IntTools_FClass2d.hxx>
	64	#include <IntTools_Curve.hxx>
	65	#include <IntTools_SequenceOfCurves.hxx>
	66
	67	static
	68	void ParabolaTolerance(const Handle(Geom_Curve)& ,
	69	const Standard_Real ,
	70	const Standard_Real ,
	71	const Standard_Real ,
	72	Standard_Real& ,
	73	Standard_Real& );
	74
	75	//=======================================================================
	76	//function : HasInternalEdge
	77	//purpose :
	78	//=======================================================================
	79	Standard_Boolean IntTools_Tools::HasInternalEdge(const TopoDS_Wire& aW)
	80	{
	81	Standard_Boolean bFlag=Standard_True;
	82
	83	TopExp_Explorer anExp(aW, TopAbs_EDGE);
84	for (; anExp.More(); anExp.Next()) {
85	const TopoDS_Edge& aE=TopoDS::Edge(anExp.Current());
86	TopAbs_Orientation anOr=aE.Orientation();
87	if (anOr==TopAbs_INTERNAL) {
88	return bFlag;
89	}
90	}
91	return !bFlag;
92	}
93
94	//=======================================================================
95	//function : IsClosed
96	//purpose :
97	//=======================================================================
98	Standard_Boolean IntTools_Tools::IsClosed (const Handle(Geom_Curve)& aC3D)
99	{
cf8e963a	100	Standard_Boolean bRet;
cf8e963a	101	Standard_Real aF, aL, aDist, aPC;
7fd59977	102	gp_Pnt aP1, aP2;
cf8e963a	103
7fd59977	104	Handle (Geom_BoundedCurve) aGBC=
	105	Handle (Geom_BoundedCurve)::DownCast(aC3D);
	106	if (aGBC.IsNull()) {
	107	return Standard_False;
	108	}
cf8e963a	109
7fd59977	110	aF=aC3D->FirstParameter();
	111	aL=aC3D-> LastParameter();
	112
	113	aC3D->D0(aF, aP1);
	114	aC3D->D0(aL, aP2);
	115
cf8e963a	116
	117	//
	118	//modified by NIZNHY-PKV Mon Jul 04 11:58:23 2011f
	119	aPC=Precision::Confusion();
	120	aPC=aPC*aPC;
	121	aDist=aP1.SquareDistance(aP2);
	122	bRet=aDist<aPC;
	123	return bRet;
	124	//
	125	//aDist=aP1.Distance(aP2);
	126	//return (aDist < Precision::Confusion());
	127	//modified by NIZNHY-PKV Mon Jul 04 11:59:50 2011t
7fd59977	128	}
	129
	130	//=======================================================================
	131	//function : RejectLines
	132	//purpose :
	133	//=======================================================================
	134	void IntTools_Tools::RejectLines(const IntTools_SequenceOfCurves& aSIn,
	135	IntTools_SequenceOfCurves& aSOut)
	136	{
	137	Standard_Integer i, j, aNb;
	138	Standard_Boolean bFlag;
	139	Handle (Geom_Curve) aC3D;
	140
	141	gp_Dir aD1, aD2;
	142
	143	aSOut.Clear();
	144
	145	aNb=aSIn.Length();
	146	for (i=1; i<=aNb; i++) {
	147	const IntTools_Curve& IC=aSIn(i);
	148	aC3D=IC.Curve();
	149	//
	150	Handle (Geom_TrimmedCurve) aGTC=
	151	Handle (Geom_TrimmedCurve)::DownCast(aC3D);
	152
	153	if (!aGTC.IsNull()) {
	154	aC3D=aGTC->BasisCurve();
	155	IntTools_Curve* pIC=(IntTools_Curve*) &IC;
	156	pIC->SetCurve(aC3D);
	157	}
	158	//
	159	Handle (Geom_Line) aGLine=
	160	Handle (Geom_Line)::DownCast(aC3D);
	161
	162	if (aGLine.IsNull()) {
	163	aSOut.Clear();
	164	for (j=1; j<=aNb; j++) {
	165	aSOut.Append(aSIn(j));
	166	}
	167	return;
	168	}
	169	//
	170	gp_Lin aLin=aGLine->Lin();
	171	aD2=aLin.Direction();
	172	if (i==1) {
	173	aSOut.Append(IC);
	174	aD1=aD2;
	175	continue;
	176	}
	177
	178	bFlag=IntTools_Tools::IsDirsCoinside(aD1, aD2);
	179	if (!bFlag) {
	180	aSOut.Append(IC);
	181	return;
	182	}
	183	}
	184	}
	185
	186	//=======================================================================
	187	//function : IsDirsCoinside
	188	//purpose :
	189	//=======================================================================
	190	Standard_Boolean IntTools_Tools::IsDirsCoinside (const gp_Dir& D1, const gp_Dir& D2)
	191	{
192	Standard_Boolean bFlag;
193	gp_Pnt P1(D1.X(), D1.Y(), D1.Z());
194	gp_Pnt P2(D2.X(), D2.Y(), D2.Z());
195	Standard_Real dLim=0.0002, d;
196	d=P1.Distance (P2);
197	bFlag= (d<dLim \|\| fabs (2.-d)<dLim);
198	return bFlag;
199	}
200
201	//=======================================================================
202	//function : IsDirsCoinside
203	//purpose :
204	//=======================================================================
205	Standard_Boolean IntTools_Tools::IsDirsCoinside (const gp_Dir& D1,
206	const gp_Dir& D2,
207	const Standard_Real dLim)
208	{
209	Standard_Boolean bFlag;
210	Standard_Real d;
211	//
212	gp_Pnt P1(D1.X(), D1.Y(), D1.Z());
213	gp_Pnt P2(D2.X(), D2.Y(), D2.Z());
214	d=P1.Distance (P2);
215	bFlag= (d<dLim \|\| fabs (2.-d)<dLim);
216	return bFlag;
217	}
218	//=======================================================================
219	//function : SplitCurve
220	//purpose :
221	//=======================================================================
222	Standard_Integer IntTools_Tools::SplitCurve(const IntTools_Curve& IC,
223	IntTools_SequenceOfCurves& aCvs)
224	{
225	Handle (Geom_Curve) aC3D =IC.Curve();
226	if(aC3D.IsNull())
227	return 0;
228	//
229	Handle (Geom2d_Curve) aC2D1=IC.FirstCurve2d();
230	Handle (Geom2d_Curve) aC2D2=IC.SecondCurve2d();
231	Standard_Boolean bIsClosed;
232
233	bIsClosed=IntTools_Tools::IsClosed(aC3D);
234	if (!bIsClosed) {
235	return 0;
236	}
237
238	Standard_Real aF, aL, aMid;
239
240	//
241	aF=aC3D->FirstParameter();
242	aL=aC3D->LastParameter();
243	aMid=0.5*(aF+aL);
7fd59977	244	GeomAdaptor_Curve aGAC(aC3D);
	245	GeomAbs_CurveType aCT=aGAC.GetType();
	246	if (aCT==GeomAbs_BSplineCurve \|\|
	247	aCT==GeomAbs_BezierCurve) {
	248	//aMid=0.5*aMid;
	249	aMid=IntTools_Tools::IntermediatePoint(aF, aL);
	250	}
7fd59977	251	//
	252	Handle(Geom_Curve) aC3DNewF, aC3DNewL;
	253	aC3DNewF =new Geom_TrimmedCurve (aC3D, aF, aMid);
	254	aC3DNewL =new Geom_TrimmedCurve (aC3D, aMid, aL);
	255
	256	//
	257	Handle (Geom2d_Curve) aC2D1F, aC2D1L, aC2D2F, aC2D2L;
	258	//
	259	if(!aC2D1.IsNull()) {
	260	aC2D1F=new Geom2d_TrimmedCurve (aC2D1, aF, aMid);
	261	aC2D1L=new Geom2d_TrimmedCurve (aC2D1, aMid, aL);
	262	}
	263
	264	if(!aC2D2.IsNull()) {
	265	aC2D2F=new Geom2d_TrimmedCurve (aC2D2, aF, aMid);
	266	aC2D2L=new Geom2d_TrimmedCurve (aC2D2, aMid, aL);
	267	}
	268	//
	269
	270	IntTools_Curve aIC1(aC3DNewF, aC2D1F, aC2D2F);
	271	IntTools_Curve aIC2(aC3DNewL, aC2D1L, aC2D2L);
	272	//
	273	aCvs.Append(aIC1);
	274	//
	275	aCvs.Append(aIC2);
	276	//
	277	return 2;
	278	}
	279
	280	//=======================================================================
	281	//function : IntermediatePoint
	282	//purpose :
	283	//=======================================================================
	284	Standard_Real IntTools_Tools::IntermediatePoint (const Standard_Real aFirst,
	285	const Standard_Real aLast)
	286	{
c6541a0c	287	//define parameter division number as 10*e^(-M_PI) = 0.43213918
7fd59977	288	const Standard_Real PAR_T = 0.43213918;
	289	Standard_Real aParm;
	290	aParm=(1.-PAR_T)aFirst + PAR_TaLast;
	291	return aParm;
	292	}
	293
	294	//=======================================================================
	295	//function : IsVertex
	296	//purpose :
	297	//=======================================================================
	298	Standard_Boolean IntTools_Tools::IsVertex (const gp_Pnt& aP,
	299	const Standard_Real aTolPV,
	300	const TopoDS_Vertex& aV)
	301	{
cf8e963a	302	Standard_Boolean bRet;
7fd59977	303	Standard_Real aTolV, aD, dTol;
	304	gp_Pnt aPv;
	305
	306	aTolV=BRep_Tool::Tolerance(aV);
	307	//
7fd59977	308	dTol=Precision::Confusion();
7fd59977	309	aTolV=aTolV+aTolPV+dTol;
7fd59977	310	//
7fd59977	311	aPv=BRep_Tool::Pnt(aV);
cf8e963a	312	//
	313	//modified by NIZNHY-PKV Mon Jul 04 12:00:37 2011f
	314	aD=aPv.SquareDistance(aP);
	315	aTolV=aTolV*aTolV;
	316	bRet=(aD<=aTolV);
	317	return bRet;
	318	//
	319	//aD=aPv.Distance(aP);
	320	//return (aD<=aTolV);
	321	//modified by NIZNHY-PKV Mon Jul 04 12:00:40 2011t
7fd59977	322	}
	323
	324
	325	//=======================================================================
	326	//function : IsVertex
	327	//purpose :
	328	//=======================================================================
	329	Standard_Boolean IntTools_Tools::IsVertex (const IntTools_CommonPrt& aCmnPrt)
	330	{
	331	Standard_Boolean anIsVertex;
	332	Standard_Real aParam;
	333
	334	const TopoDS_Edge& aE1=aCmnPrt.Edge1();
	335	const IntTools_Range& aR1=aCmnPrt.Range1();
	336	aParam=0.5*(aR1.First()+aR1.Last());
	337	anIsVertex=IntTools_Tools::IsVertex (aE1, aParam);
	338
	339	if (anIsVertex) {
	340	return Standard_True;
	341	}
	342
	343	const TopoDS_Edge& aE2=aCmnPrt.Edge2();
	344	const IntTools_SequenceOfRanges& aRs2=aCmnPrt.Ranges2();
	345	const IntTools_Range& aR2=aRs2(1);
	346	aParam=0.5*(aR2.First()+aR2.Last());
	347	anIsVertex=IntTools_Tools::IsVertex (aE2, aParam);
	348	if (anIsVertex) {
	349	return Standard_True;
	350	}
	351	return Standard_False;
	352	}
	353
	354	//=======================================================================
	355	//function : IsVertex
	356	//purpose :
	357	//=======================================================================
	358	Standard_Boolean IntTools_Tools::IsVertex (const TopoDS_Edge& aE,
	359	const TopoDS_Vertex& aV,
	360	const Standard_Real t)
	361	{
	362	Standard_Real aTolV, aTolV2, d2;
	363	gp_Pnt aPv, aPt;
	364
	365	BRepAdaptor_Curve aBAC(aE);
	366	aBAC.D0(t, aPt);
	367
	368	aTolV=BRep_Tool::Tolerance(aV);
	369	aTolV2=aTolV*aTolV;
	370	aPv=BRep_Tool::Pnt(aV);
	371	d2=aPv.SquareDistance (aPt);
	372	if (d2 < aTolV2) {
	373	return Standard_True;
	374	}
	375	return Standard_False;
	376	}
	377	//=======================================================================
	378	//function : IsVertex
	379	//purpose :
	380	//=======================================================================
	381	Standard_Boolean IntTools_Tools::IsVertex (const TopoDS_Edge& aE,
	382	const Standard_Real t)
	383	{
	384	Standard_Real aTolV, aTolV2, d2;
	385	TopoDS_Vertex aV;
386	gp_Pnt aPv, aPt;
387
388	BRepAdaptor_Curve aBAC(aE);
389	aBAC.D0(t, aPt);
390
391	TopExp_Explorer anExp(aE, TopAbs_VERTEX);
392	for (; anExp.More(); anExp.Next()) {
393	aV=TopoDS::Vertex (anExp.Current());
394	aTolV=BRep_Tool::Tolerance(aV);
395	aTolV2=aTolV*aTolV;
396	aTolV2=1.e-12;
397	aPv=BRep_Tool::Pnt(aV);
398	d2=aPv.SquareDistance (aPt);
399	if (d2 < aTolV2) {
400	return Standard_True;
401	}
402	}
403	return Standard_False;
404	}
405
406
407	//=======================================================================
408	//function : ComputeVV
409	//purpose :
410	//=======================================================================
411	Standard_Integer IntTools_Tools::ComputeVV(const TopoDS_Vertex& aV1,
412	const TopoDS_Vertex& aV2)
413	{
414	Standard_Real aTolV1, aTolV2, aTolSum, d;
415	gp_Pnt aP1, aP2;
416
417	aTolV1=BRep_Tool::Tolerance(aV1);
418	aTolV2=BRep_Tool::Tolerance(aV2);
419	aTolSum=aTolV1+aTolV2;
cf8e963a	420
7fd59977	421	aP1=BRep_Tool::Pnt(aV1);
7fd59977	422	aP2=BRep_Tool::Pnt(aV2);
cf8e963a	423	//modified by NIZNHY-PKV Mon Jul 04 11:55:52 2011f
	424	aTolSum=aTolSum*aTolSum;
	425	d=aP1.SquareDistance(aP2);
	426	//d=aP1.Distance(aP2);
	427	//modified by NIZNHY-PKV Mon Jul 04 11:55:53 2011t
7fd59977	428	if (d<aTolSum) {
	429	return 0;
	430	}
	431	return -1;
	432	}
	433
	434	//=======================================================================
	435	//function : MakeFaceFromWireAndFace
	436	//purpose :
	437	//=======================================================================
	438	void IntTools_Tools::MakeFaceFromWireAndFace(const TopoDS_Wire& aW,
	439	const TopoDS_Face& aF,
	440	TopoDS_Face& aFNew)
	441	{
	442	TopoDS_Face aFF;
	443	aFF=aF;
	444	aFF.Orientation(TopAbs_FORWARD);
	445	aFNew=TopoDS::Face (aFF.EmptyCopied());
	446	BRep_Builder BB;
	447	BB.Add(aFNew, aW);
	448	}
	449
	450	//=======================================================================
	451	//function : ClassifyPointByFace
	452	//purpose :
	453	//=======================================================================
	454	TopAbs_State IntTools_Tools::ClassifyPointByFace(const TopoDS_Face& aF,
	455	const gp_Pnt2d& aP2d)
	456	{
	457	Standard_Real aFaceTolerance;
	458	TopAbs_State aState;
	459
	460	aFaceTolerance=BRep_Tool::Tolerance(aF);
	461	IntTools_FClass2d aClass2d(aF, aFaceTolerance);
	462	aState=aClass2d.Perform(aP2d);
	463
	464	return aState;
	465	}
	466
	467	//=======================================================================
	468	//function : IsMiddlePointsEqual
	469	//purpose :
	470	//=======================================================================
	471	Standard_Boolean IntTools_Tools::IsMiddlePointsEqual(const TopoDS_Edge& aE1,
	472	const TopoDS_Edge& aE2)
	473
	474	{
cf8e963a	475	Standard_Boolean bRet;
cf8e963a	476	Standard_Real f1, l1, m1, f2, l2, m2, aTol1, aTol2, aSumTol, aD2;
7fd59977	477	gp_Pnt aP1, aP2;
	478
	479	aTol1=BRep_Tool::Tolerance(aE1);
	480	Handle(Geom_Curve) C1=BRep_Tool::Curve(aE1, f1, l1);
	481	m1=0.5*(f1+l1);
	482	C1->D0(m1, aP1);
	483
	484	aTol2=BRep_Tool::Tolerance(aE2);
	485	Handle(Geom_Curve) C2=BRep_Tool::Curve(aE2, f2, l2);
	486	m2=0.5*(f2+l2);
	487	C2->D0(m2, aP2);
	488
	489	aSumTol=aTol1+aTol2;
cf8e963a	490	//modified by NIZNHY-PKV Mon Jul 04 12:02:20 2011f
	491	aSumTol=aSumTol*aSumTol;
	492	aD2=aP1.SquareDistance(aP2);
	493	bRet=aD2<aSumTol;
	494	return bRet;
	495	//
	496	//if (aP1.Distance(aP2) < aSumTol) {
	497	// return Standard_True;
	498	//}
	499	//return Standard_False;
	500	//modified by NIZNHY-PKV Mon Jul 04 12:02:24 2011t
7fd59977	501	}
	502
	503	//=======================================================================
	504	//function : CurveTolerance
	505	//purpose :
	506	//=======================================================================
	507	Standard_Real IntTools_Tools::CurveTolerance(const Handle(Geom_Curve)& aC3D,
	508	const Standard_Real aTolBase)
	509	{
	510	Standard_Real aTolReached, aTf, aTl, aTolMin, aTolMax;
	511
	512	aTolReached=aTolBase;
	513	//
	514	if (aC3D.IsNull()) {
	515	return aTolReached;
	516	}
	517	//
	518	Handle(Geom_TrimmedCurve) aCT3D=Handle(Geom_TrimmedCurve)::DownCast(aC3D);
	519	if (aCT3D.IsNull()) {
	520	return aTolReached;
	521	}
	522	//
	523	aTolMin=aTolBase;
	524	aTolMax=aTolBase;
	525	//
	526	aTf=aCT3D->FirstParameter();
	527	aTl=aCT3D->LastParameter();
	528	//
	529	GeomAdaptor_Curve aGAC(aCT3D);
	530	GeomAbs_CurveType aCType=aGAC.GetType();
	531	//
	532	if (aCType==GeomAbs_Parabola) {
	533	Handle(Geom_Curve) aC3DBase=aCT3D->BasisCurve();
	534	ParabolaTolerance(aC3DBase, aTf, aTl, aTolBase, aTolMin, aTolMax);
	535	aTolReached=aTolMax;
	536	}
	537	//
	538	return aTolReached;
	539	}
	540
	541	#include <Geom_Parabola.hxx>
	542	#include <gp_Parab.hxx>
	543	//=======================================================================
	544	//function : ParabolaTolerance
	545	//purpose :
	546	//=======================================================================
	547	void ParabolaTolerance(const Handle(Geom_Curve)& aC3D,
	548	const Standard_Real aTf,
	549	const Standard_Real aTl,
	550	const Standard_Real aTol,
	551	Standard_Real& aTolMin,
	552	Standard_Real& aTolMax)
	553	{
	554
	555	aTolMin=aTol;
	556	aTolMax=aTol;
	557
	558	Handle(Geom_Parabola) aGP=Handle(Geom_Parabola)::DownCast(aC3D);
	559	if (aGP.IsNull()){
	560	return;
	561	}
	562
	563	Standard_Integer aNbPoints;
	564	Standard_Real aFocal, aX1, aX2, aTol1, aTol2;
565	gp_Pnt aPf, aPl;
566	gp_Parab aParab=aGP->Parab();
567	gp_Ax1 aXAxis=aParab.XAxis();
568	Handle(Geom_Line) aGAxis=new Geom_Line(aXAxis);
569
570	aFocal=aGP->Focal();
571	if (aFocal==0.) {
572	return;
573	}
574	//
575	// aTol1
576	aTol1=aTol;
577	aX1=0.;
578	aGP->D0(aTf, aPf);
579	GeomAPI_ProjectPointOnCurve aProj1(aPf, aGAxis);
580	aNbPoints=aProj1.NbPoints();
581	if (aNbPoints) {
582	aX1=aProj1.LowerDistanceParameter();
583	}
584	if (aX1>=0.) {
585	aTol1=aTolsqrt(0.5aX1/aFocal);
586	}
587	if (aTol1==0.) {
588	aTol1=aTol;
589	}
590	//
591	// aTol2
592	aTol2=aTol;
593	aX2=0.;
594	aGP->D0(aTl, aPl);
595	GeomAPI_ProjectPointOnCurve aProj2(aPl, aGAxis);
596	aNbPoints=aProj2.NbPoints();
597	if (aNbPoints) {
598	aX2=aProj2.LowerDistanceParameter();
599	}
600
601	if (aX2>=0.) {
602	aTol2=aTolsqrt(0.5aX2/aFocal);
603	}
604	if (aTol2==0.) {
605	aTol2=aTol;
606	}
607	//
608	aTolMax=(aTol1>aTol2) ? aTol1 : aTol2;
609	aTolMin=(aTol1<aTol2) ? aTol1 : aTol2;
610	}
611