b55e9bae371950b96d823165889757877a6107c0
[occt.git] / src / TopOpeBRepTool / TopOpeBRepTool_PROJECT.cxx
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
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,
204                                                    const Handle(Geom_Surface)& S,
205                                                    gp_Pnt2d& UV,Standard_Real& dist,
206                                                    const Extrema_ExtFlag aExtFlag,
207                                                    const Extrema_ExtAlgo aExtAlgo)
208
209   Standard_Real UMin, UMax, VMin, VMax;
210   GeomAPI_ProjectPointOnSurf PonS;
211   //
212   S->Bounds(UMin, UMax, VMin, VMax);
213   PonS.Init(S, UMin, UMax, VMin, VMax, aExtAlgo);
214   Extrema_ExtPS& anExtAlgo = const_cast<Extrema_ExtPS&>(PonS.Extrema());
215   anExtAlgo.SetFlag(aExtFlag);
216   //
217   PonS.Perform(P);
218   //
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,
286                                                    gp_Pnt2d& UV,Standard_Real& dist,
287                                                    const Extrema_ExtFlag aExtFlag,
288                                                    const Extrema_ExtAlgo aExtAlgo)
289 {
290   dist = 1.;
291   Handle(Geom_Surface) S = BRep_Tool::Surface(F);
292   Standard_Boolean ok = FUN_tool_projPonS(P,S,UV,dist, aExtFlag, aExtAlgo);
293   return ok;
294 }