[occt.git] / src / TopOpeBRepTool / TopOpeBRepTool_PROJECT.cxx

// Created on: 1997-11-24
// Created by: Xuan PHAM PHU
// Copyright (c) 1997-1999 Matra Datavision
// Copyright (c) 1999-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 <TopOpeBRepTool_PROJECT.hxx>

#include <Geom2d_Curve.hxx>
#include <Geom_Curve.hxx>
#include <Geom_Surface.hxx>
#include <GeomAPI_ProjectPointOnCurve.hxx>
#include <GeomAPI_ProjectPointOnSurf.hxx>
#include <BRepLib_MakeVertex.hxx>
#include <BRepExtrema_ExtPF.hxx>
#include <Bnd_Box2d.hxx>
#include <Bnd_Box.hxx>
#include <BRepBndLib.hxx>
#include <BndLib_Add2dCurve.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <gp_Pnt.hxx>
#include <gp_Dir2d.hxx>
#include <BRep_Tool.hxx>
#include <Precision.hxx>

#include <TopOpeBRepTool_GEOMETRY.hxx>

// ----------------------------------------------------------------------
Standard_EXPORT void FUN_tool_bounds(const TopoDS_Edge& E,Standard_Real& f,Standard_Real& l)
{
  BRepAdaptor_Curve BAC(E);
  f = BAC.FirstParameter();
  l = BAC.LastParameter();
}

// ----------------------------------------------------------------------
Standard_EXPORT Standard_Integer FUN_tool_getindex(const Extrema_ExtPC& ponc)
{
  Standard_Real Dist2,Dist2Min = ponc.SquareDistance(1);
  Standard_Integer myIndex = 1,n = ponc.NbExt();
  
  for ( Standard_Integer i = 2; i <= n; i++) {
    Dist2 = ponc.SquareDistance(i);
    if ( Dist2 < Dist2Min) {
      Dist2Min = Dist2;
      myIndex = i;
    }
  }
  return myIndex;
}

// ----------------------------------------------------------------------
Standard_EXPORT Standard_Integer FUN_tool_getindex(const Extrema_ExtPC2d& ponc)
{
  Standard_Real Dist2,Dist2Min = ponc.SquareDistance(1);
  Standard_Integer myIndex = 1,n = ponc.NbExt();
  
  for ( Standard_Integer i = 2; i <= n; i++) {
    Dist2 = ponc.SquareDistance(i);
    if ( Dist2 < Dist2Min) {
      Dist2Min = Dist2;
      myIndex = i;
    }
  }
  return myIndex;
}

// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_projPonC(const gp_Pnt& P,
				      const Standard_Real tole,const BRepAdaptor_Curve& BAC,
				      const Standard_Real pmin,const Standard_Real pmax,
				      Standard_Real& param,Standard_Real& dist)
{
  // <True> if projection succeeds,and sets <param> to parameter of <P> on <C>.
  Extrema_ExtPC ponc(P,BAC,pmin,pmax);
  Standard_Boolean ok = ponc.IsDone();
  Standard_Integer nbext = 0;
  if (ok) {nbext = ponc.NbExt(); ok = (nbext > 0);}
  if (!ok) {
    for (Standard_Integer i = 1; i <= 2; i++) {
      Standard_Real par = (i == 1) ? pmin : pmax;
      gp_Pnt pt = BAC.Value(par);
      Standard_Real d2 = pt.SquareDistance(P);
      Standard_Boolean onpt = (d2 < tole * tole);
      if (onpt) {
	param = par; 
	dist = sqrt (d2);
	return Standard_True;}
    }
    return Standard_False;
  }
  Standard_Integer i = FUN_tool_getindex(ponc);  
  param = ponc.Point(i).Parameter();
  dist = sqrt (ponc.SquareDistance(i));
  return Standard_True;
}

// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_projPonC(const gp_Pnt& P,
				      const BRepAdaptor_Curve& BAC,
				      const Standard_Real pmin,const Standard_Real pmax,
				      Standard_Real& param,Standard_Real& dist)
{
  // <True> if projection succeeds,and sets <param> to parameter of <P> on <C>.
  Standard_Real tole = BAC.Tolerance();
  Standard_Boolean ok = FUN_tool_projPonC(P,tole,BAC,pmin,pmax,param,dist);
  return ok;
}

// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_projPonC(const gp_Pnt& P,
				      const BRepAdaptor_Curve& BAC,
				      Standard_Real& param,Standard_Real& dist)
{
  // <True> if projection succeeds,and sets <param> to parameter of <P> on <C>.
  Standard_Real tole = BAC.Tolerance();
  Standard_Real pmin = BAC.FirstParameter();
  Standard_Real pmax = BAC.LastParameter();
  Standard_Boolean ok = FUN_tool_projPonC(P,tole,BAC,pmin,pmax,param,dist);
  return ok;
}

// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_projPonC2D(const gp_Pnt& P,
					const Standard_Real tole,const BRepAdaptor_Curve2d& BAC2D,
					const Standard_Real pmin,const Standard_Real pmax,
					Standard_Real& param,Standard_Real& dist)
{
  // <True> if projection succeeds,and sets <param> to parameter of <P> on <C>.
  Standard_Boolean ok = Standard_False;

  gp_Pnt2d P2D;
  const TopoDS_Face& F = BAC2D.Face();
  ok = FUN_tool_projPonF(P,F,P2D,dist);
  if (!ok) return Standard_False;

  Extrema_ExtPC2d ponc2d(P2D,BAC2D,pmin,pmax);
  ok = ponc2d.IsDone();
  Standard_Integer nbext = ponc2d.NbExt();
  if (ok) ok = (nbext > 0);
  if (!ok) {
    for (Standard_Integer i = 1; i <= 2; i++) {
      Standard_Real par = (i == 1) ? pmin : pmax;
      gp_Pnt2d pt2d = BAC2D.Value(par);
      Standard_Real d2 = pt2d.SquareDistance(P2D);
      Standard_Boolean onpt = (d2 < tole * tole);
      if (onpt) {
	param = par; 
	dist = sqrt (d2);
	return Standard_True;}
    }
    return Standard_False;
  }

  Standard_Integer i = FUN_tool_getindex(ponc2d);  
  param = ponc2d.Point(i).Parameter();
  dist = sqrt (ponc2d.SquareDistance(i));
  return Standard_True;
}

// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_projPonC2D(const gp_Pnt& P,
					const BRepAdaptor_Curve2d& BAC2D,
					const Standard_Real pmin,const Standard_Real pmax,
					Standard_Real& param,Standard_Real& dist)
{
  // <True> if projection succeeds,and sets <param> to parameter of <P> on <C>.
  Standard_Real tole = BRep_Tool::Tolerance(BAC2D.Edge());
  Standard_Boolean ok = FUN_tool_projPonC2D(P,tole,BAC2D,pmin,pmax,param,dist);
  return ok;
}

// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_projPonC2D(const gp_Pnt& P,
					const BRepAdaptor_Curve2d& BAC2D,
					Standard_Real& param,Standard_Real& dist)
{
  // <True> if projection succeeds,and sets <param> to parameter of <P> on <C>.
  Standard_Real tole = BRep_Tool::Tolerance(BAC2D.Edge());
  Standard_Real pmin = BAC2D.FirstParameter();
  Standard_Real pmax = BAC2D.LastParameter();
  Standard_Boolean ok = FUN_tool_projPonC2D(P,tole,BAC2D,pmin,pmax,param,dist);
  return ok;
}

// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_projPonS(const gp_Pnt& P,
                                                   const Handle(Geom_Surface)& S,
                                                   gp_Pnt2d& UV,Standard_Real& dist,
                                                   const Extrema_ExtFlag anExtFlag,
                                                   const Extrema_ExtAlgo anExtAlgo)
{ 
  Standard_Real UMin, UMax, VMin, VMax;
  GeomAPI_ProjectPointOnSurf PonS;
  //
  S->Bounds(UMin, UMax, VMin, VMax);
  PonS.Init(S, UMin, UMax, VMin, VMax, anExtAlgo);
  Extrema_ExtPS& anExtPS = const_cast<Extrema_ExtPS&>(PonS.Extrema());
  anExtPS.SetFlag(anExtFlag);
  //
  PonS.Perform(P);
  //
  if (!PonS.Extrema().IsDone()) return Standard_False;
  if (PonS.NbPoints() == 0) return Standard_False;
  dist = PonS.LowerDistance();
  Standard_Real U,V; PonS.LowerDistanceParameters(U,V); UV.SetCoord(U,V);
  return Standard_True;
}

// ----------------------------------------------------------------------
//  projecting point <P> on topologies (edge <E>,face <F>)
// ----------------------------------------------------------------------

// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_projPonE(const gp_Pnt& P,const Standard_Real tole,const TopoDS_Edge& E,
				      Standard_Real& param,Standard_Real& dist)
{
  dist = 1.;
  BRepAdaptor_Curve BAC(E);
  Standard_Real first = BAC.FirstParameter();
  Standard_Real last = BAC.LastParameter();
  Standard_Boolean ok = FUN_tool_projPonC(P,tole,BAC,first,last,param,dist);
  if (!ok) return Standard_False;

  Standard_Real f,l; FUN_tool_bounds(E,f,l);
  Standard_Real tolp = Precision::Parametric(Precision::Confusion());
  Standard_Boolean onf = Abs(f-param) < tolp; if (onf) param = f;
  Standard_Boolean onl = Abs(l-param) < tolp; if (onl) param = l;
  return Standard_True;
}

// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_projPonE(const gp_Pnt& P,const TopoDS_Edge& E,
				      Standard_Real& param,Standard_Real& dist)
{
  Standard_Real tole = BRep_Tool::Tolerance(E);
  Standard_Boolean ok = FUN_tool_projPonE(P,tole,E,param,dist);
  return ok;
}

// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_projPonboundedF(const gp_Pnt& P,const TopoDS_Face& F,
					     gp_Pnt2d& UV,Standard_Real& dist)
{
  dist = 1.;
  // ! projecting point on surf does not take into account the face's 
  // restriction
  BRepLib_MakeVertex mv(P); TopoDS_Vertex V = mv.Vertex();
  BRepExtrema_ExtPF PonF(V,F);
  if (!PonF.IsDone()) return Standard_False;
  Standard_Integer npt = PonF.NbExt();
  if (npt == 0) return Standard_False;

  // tri
  Standard_Real dmin2 = 1.e14; Standard_Integer imin = 0;
  for (Standard_Integer i=1; i <=npt; i++){
    Standard_Real d2 = PonF.SquareDistance(i);
    if (d2 < dmin2) {imin = i; dmin2 = d2;}
  }
  if (imin == 0) return Standard_False;
  
  Standard_Real u,v; PonF.Parameter(imin,u,v);
  dist = sqrt (dmin2);
  UV = gp_Pnt2d(u,v);
  return Standard_True;
}

// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_projPonF(const gp_Pnt& P,const TopoDS_Face& F,
                                                   gp_Pnt2d& UV,Standard_Real& dist,
                                                   const Extrema_ExtFlag anExtFlag,
                                                   const Extrema_ExtAlgo anExtAlgo)
{
  dist = 1.;
  Handle(Geom_Surface) S = BRep_Tool::Surface(F);
  Standard_Boolean ok = FUN_tool_projPonS(P,S,UV,dist, anExtFlag, anExtAlgo);
  return ok;
}
Commit	Line	Data
b311480e	1	// Created on: 1997-11-24
	2	// Created by: Xuan PHAM PHU
	3	// Copyright (c) 1997-1999 Matra Datavision
	4	// Copyright (c) 1999-2012 OPEN CASCADE SAS
	5	//
	6	// The content of this file is subject to the Open CASCADE Technology Public
	7	// License Version 6.5 (the "License"). You may not use the content of this file
	8	// except in compliance with the License. Please obtain a copy of the License
	9	// at http://www.opencascade.org and read it completely before using this file.
	10	//
	11	// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
	12	// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
	13	//
	14	// The Original Code and all software distributed under the License is
	15	// distributed on an "AS IS" basis, without warranty of any kind, and the
	16	// Initial Developer hereby disclaims all such warranties, including without
	17	// limitation, any warranties of merchantability, fitness for a particular
	18	// purpose or non-infringement. Please see the License for the specific terms
	19	// and conditions governing the rights and limitations under the License.
	20
7fd59977	21
	22	#include <TopOpeBRepTool_PROJECT.hxx>
	23
	24	#include <Geom2d_Curve.hxx>
	25	#include <Geom_Curve.hxx>
	26	#include <Geom_Surface.hxx>
	27	#include <GeomAPI_ProjectPointOnCurve.hxx>
	28	#include <GeomAPI_ProjectPointOnSurf.hxx>
	29	#include <BRepLib_MakeVertex.hxx>
	30	#include <BRepExtrema_ExtPF.hxx>
	31	#include <Bnd_Box2d.hxx>
	32	#include <Bnd_Box.hxx>
	33	#include <BRepBndLib.hxx>
	34	#include <BndLib_Add2dCurve.hxx>
	35	#include <BRepAdaptor_Curve.hxx>
	36	#include <BRepAdaptor_Curve2d.hxx>
	37	#include <gp_Pnt.hxx>
	38	#include <gp_Dir2d.hxx>
	39	#include <BRep_Tool.hxx>
	40	#include <Precision.hxx>
	41
	42	#include <TopOpeBRepTool_GEOMETRY.hxx>
	43
	44	// ----------------------------------------------------------------------
	45	Standard_EXPORT void FUN_tool_bounds(const TopoDS_Edge& E,Standard_Real& f,Standard_Real& l)
	46	{
	47	BRepAdaptor_Curve BAC(E);
	48	f = BAC.FirstParameter();
	49	l = BAC.LastParameter();
	50	}
	51
	52	// ----------------------------------------------------------------------
	53	Standard_EXPORT Standard_Integer FUN_tool_getindex(const Extrema_ExtPC& ponc)
	54	{
	55	Standard_Real Dist2,Dist2Min = ponc.SquareDistance(1);
	56	Standard_Integer myIndex = 1,n = ponc.NbExt();
	57
	58	for ( Standard_Integer i = 2; i <= n; i++) {
	59	Dist2 = ponc.SquareDistance(i);
	60	if ( Dist2 < Dist2Min) {
	61	Dist2Min = Dist2;
	62	myIndex = i;
	63	}
	64	}
	65	return myIndex;
	66	}
	67
	68	// ----------------------------------------------------------------------
	69	Standard_EXPORT Standard_Integer FUN_tool_getindex(const Extrema_ExtPC2d& ponc)
	70	{
	71	Standard_Real Dist2,Dist2Min = ponc.SquareDistance(1);
	72	Standard_Integer myIndex = 1,n = ponc.NbExt();
	73
	74	for ( Standard_Integer i = 2; i <= n; i++) {
	75	Dist2 = ponc.SquareDistance(i);
	76	if ( Dist2 < Dist2Min) {
	77	Dist2Min = Dist2;
	78	myIndex = i;
	79	}
	80	}
	81	return myIndex;
	82	}
	83
	84	// ----------------------------------------------------------------------
85	Standard_EXPORT Standard_Boolean FUN_tool_projPonC(const gp_Pnt& P,
86	const Standard_Real tole,const BRepAdaptor_Curve& BAC,
87	const Standard_Real pmin,const Standard_Real pmax,
88	Standard_Real& param,Standard_Real& dist)
89	{
90	// <True> if projection succeeds,and sets <param> to parameter of <P> on <C>.
91	Extrema_ExtPC ponc(P,BAC,pmin,pmax);
92	Standard_Boolean ok = ponc.IsDone();
93	Standard_Integer nbext = 0;
94	if (ok) {nbext = ponc.NbExt(); ok = (nbext > 0);}
95	if (!ok) {
96	for (Standard_Integer i = 1; i <= 2; i++) {
97	Standard_Real par = (i == 1) ? pmin : pmax;
98	gp_Pnt pt = BAC.Value(par);
99	Standard_Real d2 = pt.SquareDistance(P);
100	Standard_Boolean onpt = (d2 < tole * tole);
101	if (onpt) {
102	param = par;
103	dist = sqrt (d2);
104	return Standard_True;}
105	}
106	return Standard_False;
107	}
108	Standard_Integer i = FUN_tool_getindex(ponc);
109	param = ponc.Point(i).Parameter();
110	dist = sqrt (ponc.SquareDistance(i));
111	return Standard_True;
112	}
113
114	// ----------------------------------------------------------------------
115	Standard_EXPORT Standard_Boolean FUN_tool_projPonC(const gp_Pnt& P,
116	const BRepAdaptor_Curve& BAC,
117	const Standard_Real pmin,const Standard_Real pmax,
118	Standard_Real& param,Standard_Real& dist)
119	{
120	// <True> if projection succeeds,and sets <param> to parameter of <P> on <C>.
121	Standard_Real tole = BAC.Tolerance();
122	Standard_Boolean ok = FUN_tool_projPonC(P,tole,BAC,pmin,pmax,param,dist);
123	return ok;
124	}
125
126	// ----------------------------------------------------------------------
127	Standard_EXPORT Standard_Boolean FUN_tool_projPonC(const gp_Pnt& P,
128	const BRepAdaptor_Curve& BAC,
129	Standard_Real& param,Standard_Real& dist)
130	{
131	// <True> if projection succeeds,and sets <param> to parameter of <P> on <C>.
132	Standard_Real tole = BAC.Tolerance();
133	Standard_Real pmin = BAC.FirstParameter();
134	Standard_Real pmax = BAC.LastParameter();
135	Standard_Boolean ok = FUN_tool_projPonC(P,tole,BAC,pmin,pmax,param,dist);
136	return ok;
137	}
138
139	// ----------------------------------------------------------------------
140	Standard_EXPORT Standard_Boolean FUN_tool_projPonC2D(const gp_Pnt& P,
141	const Standard_Real tole,const BRepAdaptor_Curve2d& BAC2D,
142	const Standard_Real pmin,const Standard_Real pmax,
143	Standard_Real& param,Standard_Real& dist)
144	{
145	// <True> if projection succeeds,and sets <param> to parameter of <P> on <C>.
146	Standard_Boolean ok = Standard_False;
147
148	gp_Pnt2d P2D;
149	const TopoDS_Face& F = BAC2D.Face();
150	ok = FUN_tool_projPonF(P,F,P2D,dist);
151	if (!ok) return Standard_False;
152
153	Extrema_ExtPC2d ponc2d(P2D,BAC2D,pmin,pmax);
154	ok = ponc2d.IsDone();
155	Standard_Integer nbext = ponc2d.NbExt();
156	if (ok) ok = (nbext > 0);
157	if (!ok) {
158	for (Standard_Integer i = 1; i <= 2; i++) {
159	Standard_Real par = (i == 1) ? pmin : pmax;
160	gp_Pnt2d pt2d = BAC2D.Value(par);
161	Standard_Real d2 = pt2d.SquareDistance(P2D);
162	Standard_Boolean onpt = (d2 < tole * tole);
163	if (onpt) {
164	param = par;
165	dist = sqrt (d2);
166	return Standard_True;}
167	}
168	return Standard_False;
169	}
170
171	Standard_Integer i = FUN_tool_getindex(ponc2d);
172	param = ponc2d.Point(i).Parameter();
173	dist = sqrt (ponc2d.SquareDistance(i));
174	return Standard_True;
175	}
176
177	// ----------------------------------------------------------------------
178	Standard_EXPORT Standard_Boolean FUN_tool_projPonC2D(const gp_Pnt& P,
179	const BRepAdaptor_Curve2d& BAC2D,
180	const Standard_Real pmin,const Standard_Real pmax,
181	Standard_Real& param,Standard_Real& dist)
182	{
183	// <True> if projection succeeds,and sets <param> to parameter of <P> on <C>.
184	Standard_Real tole = BRep_Tool::Tolerance(BAC2D.Edge());
185	Standard_Boolean ok = FUN_tool_projPonC2D(P,tole,BAC2D,pmin,pmax,param,dist);
186	return ok;
187	}
188
189	// ----------------------------------------------------------------------
190	Standard_EXPORT Standard_Boolean FUN_tool_projPonC2D(const gp_Pnt& P,
191	const BRepAdaptor_Curve2d& BAC2D,
192	Standard_Real& param,Standard_Real& dist)
193	{
194	// <True> if projection succeeds,and sets <param> to parameter of <P> on <C>.
195	Standard_Real tole = BRep_Tool::Tolerance(BAC2D.Edge());
196	Standard_Real pmin = BAC2D.FirstParameter();
197	Standard_Real pmax = BAC2D.LastParameter();
198	Standard_Boolean ok = FUN_tool_projPonC2D(P,tole,BAC2D,pmin,pmax,param,dist);
199	return ok;
200	}
201
202	// ----------------------------------------------------------------------
203	Standard_EXPORT Standard_Boolean FUN_tool_projPonS(const gp_Pnt& P,
d633fd70	204	const Handle(Geom_Surface)& S,
d633fd70	205	gp_Pnt2d& UV,Standard_Real& dist,
95978b28	206	const Extrema_ExtFlag anExtFlag,
95978b28	207	const Extrema_ExtAlgo anExtAlgo)
d633fd70	208	{
	209	Standard_Real UMin, UMax, VMin, VMax;
	210	GeomAPI_ProjectPointOnSurf PonS;
	211	//
	212	S->Bounds(UMin, UMax, VMin, VMax);
95978b28	213	PonS.Init(S, UMin, UMax, VMin, VMax, anExtAlgo);
	214	Extrema_ExtPS& anExtPS = const_cast<Extrema_ExtPS&>(PonS.Extrema());
	215	anExtPS.SetFlag(anExtFlag);
d633fd70	216	//
	217	PonS.Perform(P);
	218	//
7fd59977	219	if (!PonS.Extrema().IsDone()) return Standard_False;
	220	if (PonS.NbPoints() == 0) return Standard_False;
	221	dist = PonS.LowerDistance();
	222	Standard_Real U,V; PonS.LowerDistanceParameters(U,V); UV.SetCoord(U,V);
	223	return Standard_True;
	224	}
	225
	226	// ----------------------------------------------------------------------
	227	// projecting point <P> on topologies (edge <E>,face <F>)
	228	// ----------------------------------------------------------------------
	229
	230	// ----------------------------------------------------------------------
	231	Standard_EXPORT Standard_Boolean FUN_tool_projPonE(const gp_Pnt& P,const Standard_Real tole,const TopoDS_Edge& E,
	232	Standard_Real& param,Standard_Real& dist)
	233	{
	234	dist = 1.;
	235	BRepAdaptor_Curve BAC(E);
	236	Standard_Real first = BAC.FirstParameter();
	237	Standard_Real last = BAC.LastParameter();
	238	Standard_Boolean ok = FUN_tool_projPonC(P,tole,BAC,first,last,param,dist);
	239	if (!ok) return Standard_False;
	240
	241	Standard_Real f,l; FUN_tool_bounds(E,f,l);
	242	Standard_Real tolp = Precision::Parametric(Precision::Confusion());
	243	Standard_Boolean onf = Abs(f-param) < tolp; if (onf) param = f;
	244	Standard_Boolean onl = Abs(l-param) < tolp; if (onl) param = l;
	245	return Standard_True;
	246	}
	247
	248	// ----------------------------------------------------------------------
	249	Standard_EXPORT Standard_Boolean FUN_tool_projPonE(const gp_Pnt& P,const TopoDS_Edge& E,
	250	Standard_Real& param,Standard_Real& dist)
	251	{
	252	Standard_Real tole = BRep_Tool::Tolerance(E);
	253	Standard_Boolean ok = FUN_tool_projPonE(P,tole,E,param,dist);
	254	return ok;
	255	}
	256
	257	// ----------------------------------------------------------------------
	258	Standard_EXPORT Standard_Boolean FUN_tool_projPonboundedF(const gp_Pnt& P,const TopoDS_Face& F,
	259	gp_Pnt2d& UV,Standard_Real& dist)
	260	{
	261	dist = 1.;
	262	// ! projecting point on surf does not take into account the face's
	263	// restriction
	264	BRepLib_MakeVertex mv(P); TopoDS_Vertex V = mv.Vertex();
	265	BRepExtrema_ExtPF PonF(V,F);
	266	if (!PonF.IsDone()) return Standard_False;
	267	Standard_Integer npt = PonF.NbExt();
	268	if (npt == 0) return Standard_False;
	269
	270	// tri
	271	Standard_Real dmin2 = 1.e14; Standard_Integer imin = 0;
	272	for (Standard_Integer i=1; i <=npt; i++){
	273	Standard_Real d2 = PonF.SquareDistance(i);
	274	if (d2 < dmin2) {imin = i; dmin2 = d2;}
	275	}
	276	if (imin == 0) return Standard_False;
	277
	278	Standard_Real u,v; PonF.Parameter(imin,u,v);
	279	dist = sqrt (dmin2);
	280	UV = gp_Pnt2d(u,v);
	281	return Standard_True;
	282	}
283
284	// ----------------------------------------------------------------------
285	Standard_EXPORT Standard_Boolean FUN_tool_projPonF(const gp_Pnt& P,const TopoDS_Face& F,
d633fd70	286	gp_Pnt2d& UV,Standard_Real& dist,
95978b28	287	const Extrema_ExtFlag anExtFlag,
95978b28	288	const Extrema_ExtAlgo anExtAlgo)
7fd59977	289	{
	290	dist = 1.;
	291	Handle(Geom_Surface) S = BRep_Tool::Surface(F);
95978b28	292	Standard_Boolean ok = FUN_tool_projPonS(P,S,UV,dist, anExtFlag, anExtAlgo);
7fd59977	293	return ok;
7fd59977	294	}