Commit | Line | Data |
---|---|---|
7fd59977 | 1 | // File: TopOpeBRepTool_TOOL.cxx |
2 | // Created: Thu Nov 26 10:53:41 1998 | |
3 | // Author: Xuan PHAM PHU | |
4 | // <xpu@poulopox.paris1.matra-dtv.fr> | |
5 | ||
6 | ||
7 | #include <TopOpeBRepTool_TOOL.ixx> | |
8 | #include <BRepAdaptor_Curve.hxx> | |
9 | #include <BRepAdaptor_Surface.hxx> | |
10 | #include <TopExp.hxx> | |
11 | #include <TopExp_Explorer.hxx> | |
12 | #include <TopoDS.hxx> | |
13 | #include <TopoDS_Iterator.hxx> | |
14 | #include <Precision.hxx> | |
15 | #include <BRep_Tool.hxx> | |
16 | #include <BRep_Builder.hxx> | |
17 | #include <Geom2d_Line.hxx> | |
18 | #include <Geom2dAPI_ProjectPointOnCurve.hxx> | |
19 | #include <gp_Pln.hxx> | |
20 | #include <gp_Cylinder.hxx> | |
21 | #include <gp_Lin.hxx> | |
22 | #include <gp_Circ.hxx> | |
23 | #include <gp_Elips.hxx> | |
24 | #include <gp_Hypr.hxx> | |
25 | #include <gp_Parab.hxx> | |
26 | #include <TopOpeBRepTool_define.hxx> | |
27 | #include <TopOpeBRepTool.hxx> | |
28 | #include <TopOpeBRepTool_EXPORT.hxx> | |
29 | #include <TopOpeBRepTool_2d.hxx> | |
30 | #include <TopOpeBRepTool_ShapeTool.hxx> | |
31 | #include <TopTools_DataMapOfIntegerShape.hxx> | |
32 | #include <TColStd_Array1OfReal.hxx> | |
33 | #include <TColStd_IndexedMapOfReal.hxx> | |
34 | #include <TCollection_CompareOfReal.hxx> | |
35 | #include <SortTools_QuickSortOfReal.hxx> | |
36 | #include <BRepLProp_CLProps.hxx> | |
37 | #include <GeomLProp_SLProps.hxx> | |
38 | #include <gp_Torus.hxx> | |
39 | #include <gp_Cone.hxx> | |
40 | #include <gp_Sphere.hxx> | |
41 | #include <Bnd_Box.hxx> | |
42 | #include <BRepBndLib.hxx> | |
43 | #include <ElCLib.hxx> | |
44 | ||
45 | #define M_FORWARD(sta) (sta == TopAbs_FORWARD) | |
46 | #define M_REVERSED(sta) (sta == TopAbs_REVERSED) | |
47 | #define M_INTERNAL(sta) (sta == TopAbs_INTERNAL) | |
48 | #define M_EXTERNAL(sta) (sta == TopAbs_EXTERNAL) | |
49 | ||
50 | #define FORWARD (1) | |
51 | #define REVERSED (2) | |
52 | #define INTERNAL (3) | |
53 | #define EXTERNAL (4) | |
54 | #define CLOSING (5) | |
55 | ||
56 | // Unused : | |
57 | #ifdef DEB | |
58 | static Standard_Real FUN_nullcurv(const Standard_Real curv) | |
59 | { | |
60 | Standard_Real tol = Precision::Confusion()*1.e+2; // NYI | |
61 | return (curv < tol); | |
62 | } | |
63 | #endif | |
64 | static Standard_Boolean FUN_nullprodv(const Standard_Real prodv) | |
65 | { | |
66 | // Standard_Real tola = Precision::Angular()*1.e+1; // NYI | |
67 | Standard_Real tola = 1.e-6; // NYI NYI NYI : for case cto 012 I2 | |
68 | return (Abs(prodv) < tola); | |
69 | } | |
70 | ||
71 | //modified by NIZNHY-PKV Fri Aug 4 11:22:57 2000 from | |
72 | ||
73 | //======================================================================= | |
74 | //function : CheckEdgeLength | |
75 | //purpose : | |
76 | //======================================================================= | |
77 | static Standard_Boolean CheckEdgeLength (const TopoDS_Edge& E) | |
78 | { | |
79 | BRepAdaptor_Curve BC(E); | |
80 | ||
81 | TopTools_IndexedMapOfShape aM; | |
82 | TopExp::MapShapes(E, TopAbs_VERTEX, aM); | |
83 | Standard_Integer i, anExtent, aN=10; | |
84 | Standard_Real ln=0., d, t, f, l, dt; | |
85 | anExtent=aM.Extent(); | |
86 | ||
87 | if (anExtent!=1) | |
88 | return Standard_True; | |
89 | ||
90 | gp_Pnt p1, p2; | |
91 | f = BC.FirstParameter(); | |
92 | l = BC.LastParameter(); | |
93 | dt=(l-f)/aN; | |
94 | ||
95 | BC.D0(f, p1); | |
96 | for (i=1; i<=aN; i++) { | |
97 | t=f+i*dt; | |
98 | ||
99 | if (i==aN) | |
100 | BC.D0(l, p2); | |
101 | else | |
102 | BC.D0(t, p2); | |
103 | ||
104 | d=p1.Distance(p2); | |
105 | ln+=d; | |
106 | p1=p2; | |
107 | } | |
108 | ||
109 | return (ln > Precision::Confusion()); | |
110 | } | |
111 | ||
112 | //modified by NIZNHY-PKV Fri Aug 4 11:23:07 2000 to | |
113 | ||
114 | //======================================================================= | |
115 | //function : OriinSor | |
116 | //purpose : | |
117 | //======================================================================= | |
118 | ||
119 | Standard_Integer TopOpeBRepTool_TOOL::OriinSor(const TopoDS_Shape& sub, const TopoDS_Shape& S, const Standard_Boolean checkclo) | |
120 | { | |
121 | if (checkclo) { | |
122 | Standard_Boolean Sclosed = Standard_False; | |
123 | if (S.ShapeType() == TopAbs_EDGE) { | |
124 | if (sub.ShapeType() != TopAbs_VERTEX) return 0; | |
125 | ||
126 | TopoDS_Vertex vclo; Sclosed = TopOpeBRepTool_TOOL::ClosedE(TopoDS::Edge(S),vclo); | |
127 | if (Sclosed) | |
128 | if (sub.IsSame(vclo)) return CLOSING; | |
129 | } | |
130 | else if (S.ShapeType() == TopAbs_FACE) { | |
131 | if (sub.ShapeType() != TopAbs_EDGE) return 0; | |
132 | ||
133 | Sclosed = ClosedS(TopoDS::Face(S)); | |
134 | if (Sclosed) | |
135 | if (IsClosingE(TopoDS::Edge(sub),TopoDS::Face(S))) return CLOSING; | |
136 | } | |
137 | } | |
138 | ||
139 | TopExp_Explorer ex(S,sub.ShapeType()); | |
140 | for(; ex.More(); ex.Next()) { | |
141 | const TopoDS_Shape& ssub = ex.Current(); | |
142 | Standard_Boolean same = ssub.IsSame(sub); | |
143 | if (!same) continue; | |
144 | TopAbs_Orientation osub = ssub.Orientation(); | |
145 | if (M_FORWARD(osub)) return FORWARD; | |
146 | else if (M_REVERSED(osub)) return REVERSED; | |
147 | else if (M_INTERNAL(osub)) return INTERNAL; | |
148 | else if (M_EXTERNAL(osub)) return EXTERNAL; | |
149 | } | |
150 | return 0; | |
151 | } | |
152 | ||
153 | //======================================================================= | |
154 | //function : OriinSorclosed | |
155 | //purpose : | |
156 | //======================================================================= | |
157 | ||
158 | Standard_Integer TopOpeBRepTool_TOOL::OriinSorclosed(const TopoDS_Shape& sub, const TopoDS_Shape& S) | |
159 | { | |
160 | if (S.ShapeType() == TopAbs_EDGE) | |
161 | {if (sub.ShapeType() != TopAbs_VERTEX) return 0;} | |
162 | else if (S.ShapeType() == TopAbs_FACE) | |
163 | {if (sub.ShapeType() != TopAbs_EDGE) return 0;} | |
164 | TopoDS_Iterator it(S); | |
165 | for(; it.More(); it.Next()) { | |
166 | const TopoDS_Shape& ssub = it.Value(); | |
167 | Standard_Boolean equal = ssub.IsEqual(sub); | |
168 | if (!equal) continue; | |
169 | TopAbs_Orientation osub = ssub.Orientation(); | |
170 | if (M_FORWARD(osub)) return FORWARD; | |
171 | else if (M_REVERSED(osub)) return REVERSED; | |
172 | } | |
173 | return 0; | |
174 | } | |
175 | ||
176 | ||
177 | ||
178 | //======================================================================= | |
179 | //function : ClosedE | |
180 | //purpose : | |
181 | //======================================================================= | |
182 | ||
183 | Standard_Boolean TopOpeBRepTool_TOOL::ClosedE(const TopoDS_Edge& E, TopoDS_Vertex& vclo) | |
184 | { | |
185 | // returns true if <E> has a closing vertex <vclosing> | |
186 | // return E.IsClosed(); | |
187 | Standard_Boolean isdgE = BRep_Tool::Degenerated(E); | |
188 | if (isdgE) return Standard_False; | |
189 | ||
190 | TopoDS_Shape vv; vclo.Nullify(); | |
191 | TopExp_Explorer ex(E,TopAbs_VERTEX); | |
192 | for (; ex.More(); ex.Next()) { | |
193 | const TopoDS_Shape& v = ex.Current(); | |
194 | if (M_INTERNAL(v.Orientation())) continue; | |
195 | if (vv.IsNull()) vv = v; | |
196 | else if (v.IsSame(vv)) | |
197 | {vclo = TopoDS::Vertex(vv); return Standard_True;} | |
198 | } | |
199 | return Standard_False; | |
200 | } | |
201 | ||
202 | //======================================================================= | |
203 | //function : ClosedS | |
204 | //purpose : | |
205 | //======================================================================= | |
206 | ||
207 | Standard_Boolean TopOpeBRepTool_TOOL::ClosedS(const TopoDS_Face& F) | |
208 | { | |
209 | Handle(Geom_Surface) S =TopOpeBRepTool_ShapeTool::BASISSURFACE(TopoDS::Face(F)); | |
210 | if (S.IsNull()) return Standard_False; | |
211 | Standard_Boolean uclosed = S->IsUClosed(); if (uclosed) uclosed = S->IsUPeriodic(); | |
212 | Standard_Boolean vclosed = S->IsVClosed(); if (vclosed) vclosed = S->IsVPeriodic(); | |
213 | return (uclosed || vclosed); | |
214 | } | |
215 | ||
216 | //======================================================================= | |
217 | //function : IsClosingE | |
218 | //purpose : | |
219 | //======================================================================= | |
220 | ||
221 | Standard_Boolean TopOpeBRepTool_TOOL::IsClosingE(const TopoDS_Edge& E, const TopoDS_Face& F) | |
222 | { | |
223 | Standard_Integer nbocc = 0; | |
224 | TopExp_Explorer exp(F,TopAbs_EDGE); | |
225 | for (;exp.More();exp.Next()) | |
226 | if (exp.Current().IsSame(E)) nbocc++; | |
227 | if (nbocc != 2) return Standard_False; | |
228 | return BRep_Tool::IsClosed(E,F); | |
229 | } | |
230 | ||
231 | //======================================================================= | |
232 | //function : IsClosingE | |
233 | //purpose : | |
234 | //======================================================================= | |
235 | ||
236 | Standard_Boolean TopOpeBRepTool_TOOL::IsClosingE(const TopoDS_Edge& E, const TopoDS_Shape& W, const TopoDS_Face& F) | |
237 | { | |
238 | Standard_Integer nbocc = 0; | |
239 | TopExp_Explorer exp(W,TopAbs_EDGE); | |
240 | for (;exp.More();exp.Next()) | |
241 | if (exp.Current().IsSame(E)) nbocc++; | |
242 | if (nbocc != 2) return Standard_False; | |
243 | return BRep_Tool::IsClosed(E,F); | |
244 | } | |
245 | ||
246 | //======================================================================= | |
247 | //function : Vertices | |
248 | //purpose : | |
249 | //======================================================================= | |
250 | ||
251 | void TopOpeBRepTool_TOOL::Vertices(const TopoDS_Edge& E, TopTools_Array1OfShape& Vces) | |
252 | { | |
253 | // Returns vertices (F,R) if E is FORWARD | |
254 | // (R,V) if E is REVERSED | |
255 | TopAbs_Orientation oriE = E.Orientation(); | |
256 | TopoDS_Vertex v1, v2; TopExp::Vertices(E,v1,v2); | |
257 | ||
258 | if (M_INTERNAL(oriE) || M_EXTERNAL(oriE)) | |
259 | {Vces.ChangeValue(1)=v1;Vces.ChangeValue(2)=v2;} | |
260 | ||
261 | Standard_Real par1 = BRep_Tool::Parameter(v1,E); | |
262 | Standard_Real par2 = BRep_Tool::Parameter(v2,E); | |
263 | #ifdef DEB | |
264 | // if (par1>par2) cout<<"TopOpeBRepTool_TOOL::Vertices ERROR"<<endl; | |
265 | #endif | |
266 | Standard_Integer ivparSMA = (par1<par2) ? FORWARD : REVERSED; | |
267 | Standard_Integer ivparSUP = (par1<par2) ? REVERSED : FORWARD; | |
268 | if (M_REVERSED(oriE)) { | |
269 | ivparSMA = (ivparSMA == FORWARD) ? REVERSED : FORWARD; | |
270 | ivparSUP = (ivparSUP == REVERSED) ? FORWARD : REVERSED; | |
271 | } | |
272 | Vces.ChangeValue(ivparSMA) = v1; | |
273 | Vces.ChangeValue(ivparSUP) = v2; | |
274 | } | |
275 | ||
276 | //======================================================================= | |
277 | //function : Vertex | |
278 | //purpose : | |
279 | //======================================================================= | |
280 | ||
281 | TopoDS_Vertex TopOpeBRepTool_TOOL::Vertex(const Standard_Integer Iv, const TopoDS_Edge& E) | |
282 | { | |
283 | TopTools_Array1OfShape Vces(1,2); Vertices(E,Vces); | |
284 | TopoDS_Vertex V = TopoDS::Vertex(Vces(Iv)); | |
285 | return V; | |
286 | } | |
287 | ||
288 | //======================================================================= | |
289 | //function : ParE | |
290 | //purpose : | |
291 | //======================================================================= | |
292 | ||
293 | Standard_Real TopOpeBRepTool_TOOL::ParE(const Standard_Integer Iv, const TopoDS_Edge& E) | |
294 | { | |
295 | const TopoDS_Vertex& v = Vertex(Iv,E); | |
296 | return (BRep_Tool::Parameter(v,E)); | |
297 | } | |
298 | ||
299 | //======================================================================= | |
300 | //function : OnBoundary | |
301 | //purpose : | |
302 | //======================================================================= | |
303 | ||
304 | Standard_Integer TopOpeBRepTool_TOOL::OnBoundary(const Standard_Real par, const TopoDS_Edge& e) | |
305 | { | |
306 | BRepAdaptor_Curve bc(e); | |
307 | Standard_Boolean closed = bc.IsClosed(); | |
308 | Standard_Real first = bc.FirstParameter(); | |
309 | Standard_Real last = bc.LastParameter(); | |
310 | Standard_Real tole = bc.Tolerance(); Standard_Real tolp = bc.Resolution(tole); | |
311 | ||
312 | Standard_Boolean onf = Abs(par-first)<tolp; | |
313 | Standard_Boolean onl = Abs(par-last)<tolp; | |
314 | Standard_Boolean onfl = (onf || onf); | |
315 | if (onfl && closed) return CLOSING; | |
316 | if (onf) return FORWARD; | |
317 | if (onl) return REVERSED; | |
318 | if ((first < par)&&(par < last)) return INTERNAL; | |
319 | return EXTERNAL; | |
320 | } | |
321 | ||
322 | ||
323 | ||
324 | static void FUN_tool_sortVonE(TopTools_ListOfShape& lov, const TopoDS_Edge E) | |
325 | { | |
326 | TopTools_DataMapOfIntegerShape mapiv;// mapiv.Find(iV) = V | |
327 | TColStd_IndexedMapOfReal mappar; // mappar.FindIndex(parV) = iV | |
328 | ||
329 | for (TopTools_ListIteratorOfListOfShape itlove(lov); itlove.More(); itlove.Next()){ | |
330 | const TopoDS_Vertex& v = TopoDS::Vertex(itlove.Value()); | |
331 | Standard_Real par = BRep_Tool::Parameter(v,E); | |
332 | Standard_Integer iv = mappar.Add(par); | |
333 | mapiv.Bind(iv,v); | |
334 | } | |
335 | Standard_Integer nv = mapiv.Extent(); | |
336 | TColStd_Array1OfReal tabpar(1,nv); | |
337 | // for (Standard_Integer i = 1; i <= nv; i++) { | |
338 | Standard_Integer i ; | |
339 | for ( i = 1; i <= nv; i++) { | |
340 | Standard_Real p = mappar.FindKey(i); | |
341 | tabpar.SetValue(i,p); | |
342 | } | |
343 | ||
344 | TopTools_ListOfShape newlov; | |
345 | TCollection_CompareOfReal compare; SortTools_QuickSortOfReal::Sort(tabpar, compare); | |
346 | for (i = 1; i <= nv; i++) { | |
347 | Standard_Real par = tabpar.Value(i); | |
348 | Standard_Integer iv = mappar.FindIndex(par); | |
349 | const TopoDS_Shape& v = mapiv.Find(iv); | |
350 | newlov.Append(v); | |
351 | } | |
352 | lov.Clear(); lov.Append(newlov); | |
353 | } | |
354 | ||
355 | //======================================================================= | |
356 | //function : SplitE | |
357 | //purpose : | |
358 | //======================================================================= | |
359 | ||
360 | Standard_Boolean TopOpeBRepTool_TOOL::SplitE(const TopoDS_Edge& Eanc, TopTools_ListOfShape& Splits) | |
361 | { | |
362 | // prequesitory : <Eanc> is a valid edge. | |
363 | TopAbs_Orientation oEanc = Eanc.Orientation(); | |
364 | TopoDS_Shape aLocalShape = Eanc.Oriented(TopAbs_FORWARD); | |
365 | TopoDS_Edge EFOR = TopoDS::Edge(aLocalShape); | |
366 | // TopoDS_Edge EFOR = TopoDS::Edge(Eanc.Oriented(TopAbs_FORWARD)); | |
367 | TopTools_ListOfShape lov; | |
368 | TopExp_Explorer exv(EFOR,TopAbs_VERTEX); | |
369 | for (;exv.More(); exv.Next()) { | |
370 | const TopoDS_Shape& v = exv.Current(); | |
371 | lov.Append(v); | |
372 | } | |
373 | Standard_Integer nv = lov.Extent(); | |
374 | if (nv <= 2) return Standard_False; | |
375 | ||
376 | ::FUN_tool_sortVonE(lov,EFOR); | |
377 | ||
378 | TopoDS_Vertex v0; | |
379 | TopTools_ListIteratorOfListOfShape itlov(lov); | |
380 | if (itlov.More()) {v0 = TopoDS::Vertex(itlov.Value()); itlov.Next();} | |
381 | else return Standard_False; | |
382 | ||
383 | for (; itlov.More(); itlov.Next()) { | |
384 | TopoDS_Vertex v = TopoDS::Vertex(itlov.Value()); | |
385 | ||
386 | // prequesitory: par0 < par | |
387 | Standard_Real par0 = BRep_Tool::Parameter(v0, EFOR); | |
388 | Standard_Real par = BRep_Tool::Parameter(v, EFOR); | |
389 | ||
390 | // here, ed has the same geometries than Ein, but with no subshapes. | |
391 | TopoDS_Edge ed; FUN_ds_CopyEdge(EFOR,ed); | |
392 | BRep_Builder BB; | |
393 | v0.Orientation(TopAbs_FORWARD); BB.Add(ed,v0); FUN_ds_Parameter(ed,v0,par0); | |
394 | v.Orientation(TopAbs_REVERSED); BB.Add(ed,v); FUN_ds_Parameter(ed,v,par); | |
395 | Splits.Append(ed.Oriented(oEanc)); | |
396 | v0 = v; | |
397 | } | |
398 | return Standard_True; | |
399 | } | |
400 | ||
401 | ||
402 | ||
403 | ||
404 | //======================================================================= | |
405 | //function : UVF | |
406 | //purpose : | |
407 | //======================================================================= | |
408 | ||
409 | gp_Pnt2d TopOpeBRepTool_TOOL::UVF(const Standard_Real par, const TopOpeBRepTool_C2DF& C2DF) | |
410 | { | |
411 | Standard_Real f,l,tol; const Handle(Geom2d_Curve)& PC = C2DF.PC(f,l,tol); | |
412 | gp_Pnt2d UV; PC->D0(par,UV); | |
413 | return UV; | |
414 | } | |
415 | ||
416 | //======================================================================= | |
417 | //function : ParISO | |
418 | //purpose : | |
419 | //======================================================================= | |
420 | ||
421 | Standard_Boolean TopOpeBRepTool_TOOL::ParISO(const gp_Pnt2d& uv, const TopoDS_Edge& E, const TopoDS_Face& F, | |
422 | Standard_Real& par) | |
423 | { | |
424 | par = 1.e7; | |
425 | Standard_Boolean isou,isov; gp_Dir2d d2d; gp_Pnt2d o2d; | |
426 | Standard_Boolean uviso = TopOpeBRepTool_TOOL::UVISO(E,F, isou,isov, d2d,o2d); | |
427 | if (!uviso) return Standard_False; | |
428 | if (isou) {par = (uv.Y()-o2d.Y()); if (d2d.Y()<0) par = -par;} | |
429 | if (isov) {par = (uv.X()-o2d.X()); if (d2d.X()<0) par = -par;} | |
430 | return Standard_True; | |
431 | } | |
432 | ||
433 | ||
434 | ||
435 | //======================================================================= | |
436 | //function : ParE2d | |
437 | //purpose : | |
438 | //======================================================================= | |
439 | ||
440 | Standard_Boolean TopOpeBRepTool_TOOL::ParE2d(const gp_Pnt2d& p2d, const TopoDS_Edge& E, const TopoDS_Face& F, | |
441 | Standard_Real& par, Standard_Real& dist) | |
442 | { | |
443 | // Avoid projections if possible : | |
444 | BRepAdaptor_Curve2d BC2d(E,F); | |
445 | GeomAbs_CurveType CT = BC2d.GetType(); | |
446 | const Handle(Geom2d_Curve)& C2d = BC2d.Curve(); | |
447 | if (CT == GeomAbs_Line) { | |
448 | Standard_Boolean isoU,isoV; gp_Pnt2d Loc; gp_Dir2d dir2d; | |
449 | TopOpeBRepTool_TOOL::UVISO(C2d,isoU,isoV,dir2d,Loc); | |
450 | if (isoU) {par = p2d.Y()-Loc.Y();dist = Abs(p2d.X()-Loc.X());} | |
451 | if (isoV) {par = p2d.X()-Loc.X();dist = Abs(p2d.Y()-Loc.Y());} | |
452 | if (isoU || isoV) return Standard_True; | |
453 | } | |
454 | ||
455 | Geom2dAPI_ProjectPointOnCurve proj(p2d,C2d); | |
456 | dist = p2d.Distance(proj.NearestPoint()); | |
457 | par = proj.LowerDistanceParameter(); | |
458 | return Standard_True; | |
459 | } | |
460 | ||
461 | ||
462 | ||
463 | //======================================================================= | |
464 | //function : TgINSIDE | |
465 | //purpose : | |
466 | //======================================================================= | |
467 | ||
468 | Standard_Boolean TopOpeBRepTool_TOOL::TgINSIDE(const TopoDS_Vertex& v, const TopoDS_Edge& E, | |
469 | gp_Vec& Tg, Standard_Integer& OvinE) | |
470 | { | |
471 | TopoDS_Shape aLocalShape = E.Oriented(TopAbs_FORWARD); | |
472 | TopoDS_Edge EFOR = TopoDS::Edge(aLocalShape); | |
473 | // TopoDS_Edge EFOR = TopoDS::Edge(E.Oriented(TopAbs_FORWARD)); | |
474 | Standard_Integer ovE = TopOpeBRepTool_TOOL::OriinSor(v,EFOR,Standard_True); | |
475 | if (ovE == 0) return Standard_False; | |
476 | OvinE = ovE; | |
477 | Standard_Integer iv = 0; | |
478 | if (ovE == CLOSING) iv = FORWARD; | |
479 | else if ((ovE == FORWARD)||(ovE == REVERSED)) iv = ovE; | |
480 | Standard_Real parE; | |
481 | if (iv == 0) parE = BRep_Tool::Parameter(v,E); | |
482 | else parE = TopOpeBRepTool_TOOL::ParE(iv,EFOR); | |
483 | Standard_Boolean ok = TopOpeBRepTool_TOOL::TggeomE(parE,EFOR,Tg); | |
484 | if (!ok) return Standard_False; | |
485 | if (ovE == REVERSED) Tg.Reverse(); | |
486 | return Standard_True; | |
487 | } | |
488 | ||
489 | //======================================================================= | |
490 | //function : TggeomE | |
491 | //purpose : | |
492 | //======================================================================= | |
493 | ||
494 | Standard_Boolean TopOpeBRepTool_TOOL::TggeomE(const Standard_Real par, const BRepAdaptor_Curve& BC, | |
495 | gp_Vec& Tg) | |
496 | { | |
497 | #ifdef DEB | |
498 | GeomAbs_CurveType ct = | |
499 | #endif | |
500 | BC.GetType(); | |
501 | #ifdef DEB | |
502 | Standard_Boolean apoles = (ct == GeomAbs_BezierCurve)||(ct == GeomAbs_BSplineCurve); | |
503 | #endif | |
504 | ||
505 | Standard_Real f = BC.FirstParameter(), l = BC.LastParameter(); | |
506 | Standard_Real tolE = BC.Tolerance(); Standard_Real tolp = BC.Resolution(tolE); | |
507 | ||
508 | Standard_Boolean onf = Abs(f-par)<tolp; Standard_Boolean onl = Abs(l-par)<tolp; | |
509 | Standard_Boolean inbounds = (f<par)&&(par<l); | |
510 | ||
511 | if ((!inbounds) && (!onf) && (!onl)) return Standard_False; | |
512 | Standard_Real thepar = par; | |
513 | // if (apoles && (onf || onl)) thepar = onf ? (thepar+tolp) : (thepar-tolp); | |
514 | ||
515 | gp_Pnt thepnt; BC.D1(thepar, thepnt, Tg); | |
516 | Tg.Normalize(); | |
517 | return Standard_True; | |
518 | ||
519 | } | |
520 | ||
521 | //======================================================================= | |
522 | //function : TggeomE | |
523 | //purpose : | |
524 | //======================================================================= | |
525 | ||
526 | Standard_Boolean TopOpeBRepTool_TOOL::TggeomE(const Standard_Real par, const TopoDS_Edge& E, gp_Vec& Tg) | |
527 | { | |
528 | Standard_Boolean isdgE = BRep_Tool::Degenerated(E); | |
529 | if (isdgE) return Standard_False; | |
530 | ||
531 | BRepAdaptor_Curve BC(E); | |
532 | //modified by NIZNHY-PKV Fri Aug 4 09:49:31 2000 f | |
533 | if (!CheckEdgeLength(E)) { | |
534 | return Standard_False; | |
535 | } | |
536 | //modified by NIZNHY-PKV Fri Aug 4 09:49:36 2000 t | |
537 | ||
538 | return (TopOpeBRepTool_TOOL::TggeomE(par,BC,Tg)); | |
539 | } | |
540 | ||
541 | //======================================================================= | |
542 | //function : Tg2d | |
543 | //purpose : | |
544 | //======================================================================= | |
545 | ||
546 | gp_Vec2d TopOpeBRepTool_TOOL::Tg2d(const Standard_Integer iv, const TopoDS_Edge& E, | |
547 | const TopOpeBRepTool_C2DF& C2DF) | |
548 | { | |
549 | Standard_Real f,l,tol; const Handle(Geom2d_Curve)& PC = C2DF.PC(f,l,tol); | |
550 | Standard_Real par = TopOpeBRepTool_TOOL::ParE(iv,E); | |
551 | gp_Pnt2d UV; gp_Vec2d tg2d; PC->D1(par,UV,tg2d); | |
552 | gp_Dir2d d2d(tg2d); | |
553 | return d2d; | |
554 | } | |
555 | ||
556 | //======================================================================= | |
557 | //function : Tg2dApp | |
558 | //purpose : | |
559 | //======================================================================= | |
560 | ||
561 | gp_Vec2d TopOpeBRepTool_TOOL::Tg2dApp(const Standard_Integer iv, const TopoDS_Edge& E, | |
562 | const TopOpeBRepTool_C2DF& C2DF, | |
563 | const Standard_Real factor) | |
564 | { | |
565 | Standard_Real f,l,tol; const Handle(Geom2d_Curve)& PC = C2DF.PC(f,l,tol); | |
566 | ||
567 | Standard_Integer iOOv = (iv == 1) ? 2 : 1; | |
568 | Standard_Real par = TopOpeBRepTool_TOOL::ParE(iv,E); | |
569 | Standard_Real OOpar = TopOpeBRepTool_TOOL::ParE(iOOv,E); | |
570 | Standard_Real parE = (1-factor)*par + factor*OOpar; | |
571 | ||
572 | gp_Pnt2d UV; gp_Vec2d tg2d; PC->D1(parE,UV,tg2d); | |
573 | gp_Dir2d d2d(tg2d); | |
574 | ||
575 | //modified by NIZHNY-MZV Wed May 24 12:52:18 2000 | |
576 | // TopAbs_Orientation oE = E.Orientation(); | |
577 | // if (M_REVERSED(oE)) d2d.Reverse(); | |
578 | //we remove this line because we want to know original tangent | |
579 | return d2d; | |
580 | } | |
581 | ||
582 | //======================================================================= | |
583 | //function : tryTg2dApp | |
584 | //purpose : | |
585 | //======================================================================= | |
586 | ||
587 | gp_Vec2d TopOpeBRepTool_TOOL::tryTg2dApp(const Standard_Integer iv, const TopoDS_Edge& E, | |
588 | const TopOpeBRepTool_C2DF& C2DF, | |
589 | const Standard_Real factor) | |
590 | { | |
591 | Standard_Real f,l,tol; const Handle(Geom2d_Curve)& PC = C2DF.PC(f,l,tol); | |
592 | Standard_Boolean isquad = FUN_tool_quad(PC); | |
593 | Standard_Boolean line = FUN_tool_line(PC); | |
594 | if (!isquad || line) return TopOpeBRepTool_TOOL::Tg2d(iv,E,C2DF); | |
595 | return TopOpeBRepTool_TOOL::Tg2dApp(iv,E,C2DF,factor); | |
596 | } | |
597 | ||
598 | //======================================================================= | |
599 | //function : OriEinF | |
600 | //purpose : | |
601 | //======================================================================= | |
602 | ||
603 | Standard_Integer TopOpeBRepTool_TOOL::tryOriEinF(const Standard_Real par, const TopoDS_Edge& e, const TopoDS_Face& f) | |
604 | { | |
605 | // ------------------------------------------------------------ | |
606 | // 1) <e> is a subshape of <f> | |
607 | // 2) else, compute oriEinF, using <e>'s 2d rep on <f> | |
608 | // PREQUESITORY : <e> must have a pcurve on <f>. | |
609 | // ------------------------------------------------------------ | |
610 | Standard_Boolean checkclo = Standard_True; Standard_Integer oeinf = TopOpeBRepTool_TOOL::OriinSor(e,f,checkclo); | |
611 | if (oeinf != 0) return oeinf; | |
612 | ||
613 | Handle(Geom2d_Curve) pc; Standard_Real pf,pl,tol; | |
614 | Standard_Boolean hasold = FC2D_HasOldCurveOnSurface(e,f,pc); | |
615 | if (!hasold) return 0; | |
616 | pc = FC2D_EditableCurveOnSurface(e,f,pf,pl,tol); | |
617 | ||
618 | // n2d is such that (p2d,oop2d) is oriented INSIDE F | |
619 | gp_Pnt2d uv; gp_Vec2d tg2d; pc->D1(par,uv,tg2d); | |
620 | gp_Vec2d n2d(gp_Dir2d(-tg2d.Y(), tg2d.X())); | |
621 | ||
622 | Standard_Real delta = TopOpeBRepTool_TOOL::minDUV(f); delta *= 1.e-1; | |
623 | gp_Pnt2d ouv = uv.Translated(delta*n2d); | |
624 | Standard_Boolean outuvbounds = TopOpeBRepTool_TOOL::outUVbounds(ouv,f); | |
625 | oeinf = (outuvbounds) ? 2 : 1; | |
626 | return oeinf; | |
627 | } | |
628 | ||
629 | //======================================================================= | |
630 | //function : NgApp | |
631 | //purpose : | |
632 | //======================================================================= | |
633 | ||
634 | Standard_Boolean TopOpeBRepTool_TOOL::NgApp(const Standard_Real par,const TopoDS_Edge& e, const TopoDS_Face& f,const Standard_Real tola, | |
635 | gp_Dir& ngApp) | |
636 | { | |
637 | // Give us an edge <e>, a face <f>, <e> has its geometry on <f>. | |
638 | // | |
639 | // P is the point of <par> on <e> | |
640 | // purpose : the compute of <neinsidef>, at a point P' on <F>, near P | |
641 | // direction pp' is normal to <e>. | |
642 | // return false if the compute fails, or <neinsidef> is closed to <newneinsidef> | |
643 | // | |
644 | // PREQUESITORY : <e> must have a pcurve on <f>. | |
645 | // -------------- | |
646 | ||
647 | Handle(Geom_Surface) S = TopOpeBRepTool_ShapeTool::BASISSURFACE(f); | |
648 | if (S.IsNull()) return Standard_False; | |
649 | ||
650 | Standard_Boolean fplane = FUN_tool_plane(f); | |
651 | if (fplane) return Standard_False; | |
652 | ||
653 | // NYI : for bspline surfaces, use a evolutive parameter | |
654 | // on curve to find out "significant" tangents | |
655 | Standard_Boolean fquad = FUN_tool_quad(f); | |
656 | if (!fquad) return Standard_False; | |
657 | // <pc> : | |
658 | Handle(Geom2d_Curve) pc; Standard_Real pf,pl,tol; | |
659 | Standard_Boolean hasold = FC2D_HasOldCurveOnSurface(e,f,pc); | |
660 | if (!hasold) return Standard_False; | |
661 | pc = FC2D_EditableCurveOnSurface(e,f,pf,pl,tol); | |
662 | // <orieinf> : | |
663 | TopoDS_Shape aLocalShape = f.Oriented(TopAbs_FORWARD); | |
664 | Standard_Integer orieinf = TopOpeBRepTool_TOOL::tryOriEinF(par,e,TopoDS::Face(aLocalShape)); | |
665 | // Standard_Integer orieinf = TopOpeBRepTool_TOOL::tryOriEinF(par,e,TopoDS::Face(f.Oriented(TopAbs_FORWARD))); | |
666 | if (orieinf == 0) return Standard_False; | |
667 | // <uv> : | |
668 | gp_Pnt2d uv; Standard_Boolean ok = FUN_tool_paronEF(e,par,f,uv); | |
669 | if (!ok) return Standard_False; | |
670 | // <ng> : | |
671 | gp_Dir ng = FUN_tool_ngS(uv,S); | |
672 | if (!ok) return Standard_False; | |
673 | ||
674 | // <n2dinsideS> : | |
675 | gp_Vec2d tg2d; pc->D1(par,uv,tg2d); | |
676 | gp_Dir2d n2dinsideS = FUN_tool_nC2dINSIDES( gp_Dir2d(tg2d) ); | |
677 | if (orieinf == 2) n2dinsideS.Reverse(); | |
678 | //<duv> : ' | |
679 | Standard_Real eps = 0.45678; | |
680 | gp_Vec2d duv = gp_Vec2d(n2dinsideS).Multiplied(eps); | |
681 | ||
682 | // cto009S4 : we need an iterative process to get other normal vector | |
683 | Standard_Integer nmax = 5; Standard_Boolean same = Standard_False; Standard_Real delta = 0.45678; | |
684 | for (Standard_Integer i=1; i<=nmax; i++) { | |
685 | ||
686 | gp_Pnt2d newuv = uv.Translated(duv); | |
687 | gp_Vec newng = FUN_tool_ngS(newuv,S); | |
688 | same = ng.IsEqual(newng,tola); | |
689 | Standard_Boolean okk = (newng.Magnitude() > tola); | |
690 | if (!same && okk) {ngApp = gp_Dir(newng); break;} | |
691 | delta *= 1.25; // NYI | |
692 | duv = gp_Vec2d(n2dinsideS).Multiplied(delta); | |
693 | ||
694 | }//i=1..nmax | |
695 | return !same; | |
696 | } | |
697 | ||
698 | //======================================================================= | |
699 | //function : tryNgApp | |
700 | //purpose : | |
701 | //======================================================================= | |
702 | ||
703 | Standard_Boolean TopOpeBRepTool_TOOL::tryNgApp(const Standard_Real par,const TopoDS_Edge& e, const TopoDS_Face& f,const Standard_Real tola, | |
704 | gp_Dir& Ng) | |
705 | { | |
706 | gp_Pnt2d uv; Standard_Boolean ok = FUN_tool_paronEF(e,par,f,uv); | |
707 | if (!ok) return Standard_False; | |
708 | gp_Dir ng( FUN_tool_nggeomF(uv,f) ); | |
709 | #ifdef DEB | |
710 | gp_Dir ngApp; | |
711 | #endif | |
712 | ok = TopOpeBRepTool_TOOL::NgApp(par,e,f,tola,Ng); | |
713 | if (!ok) Ng = ng; | |
714 | return Standard_True; | |
715 | } | |
716 | ||
717 | //======================================================================= | |
718 | //function : IsQuad | |
719 | //purpose : | |
720 | //======================================================================= | |
721 | ||
722 | Standard_Boolean TopOpeBRepTool_TOOL::IsQuad(const TopoDS_Edge& E) | |
723 | { | |
724 | BRepAdaptor_Curve bc(E); | |
725 | return ( FUN_quadCT(bc.GetType()) ); | |
726 | } | |
727 | ||
728 | ||
729 | //======================================================================= | |
730 | //function : IsQuad | |
731 | //purpose : | |
732 | //======================================================================= | |
733 | ||
734 | Standard_Boolean TopOpeBRepTool_TOOL::IsQuad(const TopoDS_Face& F) | |
735 | { | |
736 | Handle(Geom_Surface) S = TopOpeBRepTool_ShapeTool::BASISSURFACE(F); | |
737 | return ( FUN_tool_quad(S) ); | |
738 | } | |
739 | ||
740 | ||
741 | ||
742 | //======================================================================= | |
743 | //function : CurvE | |
744 | //purpose : | |
745 | //======================================================================= | |
746 | ||
747 | Standard_Boolean TopOpeBRepTool_TOOL::CurvE(const TopoDS_Edge& E,const Standard_Real par,const gp_Dir& tg0, | |
748 | Standard_Real& curv) | |
749 | { | |
750 | curv = 0.; | |
751 | BRepAdaptor_Curve BAC(E); | |
752 | GeomAbs_CurveType CT = BAC.GetType(); | |
753 | Standard_Boolean line = (CT == GeomAbs_Line); | |
754 | Standard_Real tola = Precision::Angular()*1.e3;//NYITOLXPU | |
755 | if (line) { | |
756 | gp_Dir dir = BAC.Line().Direction(); | |
757 | Standard_Real dot = dir.Dot(tg0); | |
758 | if (Abs(1-dot) < tola) return Standard_False; | |
759 | return Standard_True; | |
760 | } | |
761 | ||
762 | BRepLProp_CLProps clprops(BAC,par,2,Precision::Confusion()); | |
763 | Standard_Boolean tgdef = clprops.IsTangentDefined(); | |
764 | if (!tgdef) return Standard_False; | |
765 | curv = Abs(clprops.Curvature()); | |
766 | ||
767 | Standard_Real tol = Precision::Confusion()*1.e+2;//NYITOLXPU | |
768 | Standard_Boolean nullcurv = (curv < tol); | |
769 | if (nullcurv) {curv = 0.; return Standard_True;} | |
770 | ||
771 | gp_Dir N; clprops.Normal(N); | |
772 | gp_Dir T; clprops.Tangent(T); | |
773 | gp_Dir axis = N^T; | |
774 | Standard_Real dot = Abs(axis.Dot(tg0)); | |
775 | nullcurv = dot < tola; | |
776 | Standard_Boolean maxcurv = Abs(1-dot) < tola; | |
777 | if (nullcurv) { | |
778 | curv = 0.; | |
779 | return Standard_True; | |
780 | } | |
781 | if (maxcurv) { | |
782 | return Standard_True; | |
783 | } | |
784 | return Standard_False; // nyi general case | |
785 | } | |
786 | ||
787 | ||
788 | // ================================================================================ | |
789 | // In 3d space, give us a curve <C> and a surface <S>, | |
790 | // <C> is tangent to <S> at point P0 = <uv0> on <S> , | |
791 | // <tgC> = C's tangent at P0, | |
792 | // <ngS> = <S>'s normal at P0. | |
793 | ||
794 | // These define a plane thePlane = (O = P0, XY = (<ngS>,<tgC>)), | |
795 | // the projection of <S> in thePlane describes an apparent contour theContour. | |
796 | ||
797 | // In thePlane : | |
798 | // P0 -> p2d0 | |
799 | // <ngS> -> 2d axis x | |
800 | // <tgC> -> 2d axis y | |
801 | ||
802 | // <C> -> C2d (same curvature) | |
803 | // <S>'s contour -> theContour | |
804 | // - the half3dspace described by (<S>,<ngS>) -> the half2dspace described by (theContour,x) | |
805 | ||
806 | // if (<tgC>.<ngS> = 0.) : (X,Y) are normal vectors | |
807 | // (x,y) are normal vectors | |
808 | // ================================================================================ | |
809 | static Standard_Boolean FUN_analyticcS(const gp_Pnt2d& uv0, const Handle(Geom_Surface)& S, const gp_Dir& ngS, | |
810 | const gp_Dir& tg0, | |
811 | Standard_Real& curv, Standard_Boolean& direct) // dummy if !analyticcontour | |
812 | { | |
813 | curv = 0.; direct = Standard_True; | |
814 | // purpose : Returns true if theContour is analytic, and | |
815 | // then computes its curvature <curv>. | |
816 | Handle(Geom_Surface) su = TopOpeBRepTool_ShapeTool::BASISSURFACE(S); | |
817 | if (S.IsNull()) return Standard_True; | |
818 | GeomAdaptor_Surface GS(su); | |
819 | GeomAbs_SurfaceType ST = GS.GetType(); | |
820 | Standard_Boolean plane = (ST == GeomAbs_Plane); | |
821 | Standard_Boolean cyl = (ST == GeomAbs_Cylinder); | |
822 | Standard_Boolean cone = (ST == GeomAbs_Cone); | |
823 | Standard_Boolean sphe = (ST == GeomAbs_Sphere); | |
824 | Standard_Boolean torus = (ST == GeomAbs_Torus); | |
825 | ||
826 | Standard_Boolean curvdone = Standard_False; | |
827 | if (plane) {curv = 0.; curvdone = Standard_True;} | |
828 | if (cyl || cone || torus){ | |
829 | gp_Dir axis; | |
830 | if (cyl) { | |
831 | const gp_Cylinder& cycy = GS.Cylinder(); | |
832 | axis = cycy.Axis().Direction(); | |
833 | direct = cycy.Direct(); | |
834 | } | |
835 | if (cone) { | |
836 | const gp_Cone& coco = GS.Cone(); | |
837 | axis = coco.Axis().Direction(); | |
838 | direct = coco.Direct(); | |
839 | } | |
840 | if (torus) { | |
841 | const gp_Torus& toto = GS.Torus(); | |
842 | axis = toto.Axis().Direction(); | |
843 | direct = toto.Direct(); | |
844 | } | |
845 | Standard_Real prod = axis.Dot(tg0); | |
846 | Standard_Boolean maxAcurv = FUN_nullprodv(1-Abs(prod)); | |
847 | Standard_Boolean nullcurv = FUN_nullprodv(prod); | |
848 | ||
849 | Standard_Real prod2 = ngS.Dot(tg0); | |
850 | if (cyl || cone) nullcurv = nullcurv || FUN_nullprodv(1-Abs(prod2)); | |
851 | ||
852 | if (nullcurv) {curv = 0.; curvdone = Standard_True;} | |
853 | if (maxAcurv) { | |
854 | GeomLProp_SLProps slprops(S,uv0.X(),uv0.Y(),2,Precision::Confusion()); | |
855 | Standard_Boolean curdef = slprops.IsCurvatureDefined(); | |
856 | if (curdef) { | |
857 | Standard_Real minAcurv = Abs(slprops.MinCurvature()); | |
858 | Standard_Real maxAcurv = Abs(slprops.MaxCurvature()); | |
859 | Standard_Boolean isAmax = (maxAcurv > minAcurv); | |
860 | curv = isAmax ? maxAcurv : minAcurv; | |
861 | } | |
862 | curvdone = Standard_True; | |
863 | } | |
864 | } | |
865 | if (sphe) { | |
866 | const gp_Sphere& spsp = GS.Sphere(); | |
867 | curv = 1./spsp.Radius(); curvdone = Standard_True; | |
868 | direct = spsp.Direct(); | |
869 | } | |
870 | ||
871 | return curvdone; | |
872 | } | |
873 | //======================================================================= | |
874 | //function : CurvF | |
875 | //purpose : | |
876 | //======================================================================= | |
877 | ||
878 | Standard_Boolean TopOpeBRepTool_TOOL::CurvF(const TopoDS_Face& F,const gp_Pnt2d& uv,const gp_Dir& tg0, | |
879 | Standard_Real& curv,Standard_Boolean& direct) | |
880 | { | |
881 | curv = 0.; | |
882 | gp_Dir ngS = FUN_tool_nggeomF(uv,F); | |
883 | Handle(Geom_Surface) S = TopOpeBRepTool_ShapeTool::BASISSURFACE(F); | |
884 | if (S.IsNull()) return Standard_False; | |
885 | // purpose : Computes theContour's curvature, | |
886 | // returns false if the compute fails. | |
887 | ||
888 | Standard_Real tola = 1.e-6;//NYITOLXPU | |
889 | ||
890 | Standard_Boolean analyticcontour = FUN_analyticcS(uv,S,ngS,tg0,curv,direct); | |
891 | if (analyticcontour) return Standard_True; | |
892 | ||
893 | GeomLProp_SLProps slprops(S,uv.X(),uv.Y(),2,Precision::Confusion()); | |
894 | Standard_Boolean curdef = slprops.IsCurvatureDefined(); | |
895 | if (curdef) { | |
896 | gp_Dir npl = tg0; | |
897 | ||
898 | gp_Dir MaxD, MinD; slprops.CurvatureDirections(MaxD, MinD); | |
899 | Standard_Real mincurv = slprops.MinCurvature(); | |
900 | Standard_Real maxcurv = slprops.MaxCurvature(); | |
901 | ||
902 | gp_Vec Dmax=ngS^MaxD, Dmin=ngS^MinD; //xpu180898 : cto015G2 | |
903 | Standard_Real dotmax = Dmax.Dot(npl);//MaxD.Dot(npl); -xpu180898 | |
904 | Standard_Boolean iscurmax = Abs(1-dotmax)<tola; | |
905 | if (iscurmax) {direct = (maxcurv < 0.); curv = Abs(maxcurv);} | |
906 | Standard_Real dotmin = Dmin.Dot(npl);//MinD.Dot(npl); -xpu180898 | |
907 | Standard_Boolean iscurmin = Abs(1-dotmin)<tola; | |
908 | if (iscurmin) {direct = (mincurv < 0.); curv = Abs(mincurv);} | |
909 | curdef = iscurmax || iscurmin; | |
910 | // ------------- | |
911 | // NYI : !curdef | |
912 | // ------------- | |
913 | } | |
914 | return curdef; | |
915 | } | |
916 | ||
917 | ||
918 | ||
919 | //======================================================================= | |
920 | //function : UVISO | |
921 | //purpose : | |
922 | //======================================================================= | |
923 | ||
924 | Standard_Boolean TopOpeBRepTool_TOOL::UVISO(const Handle(Geom2d_Curve)& PC, | |
925 | Standard_Boolean& isoU, Standard_Boolean& isoV, gp_Dir2d& d2d, gp_Pnt2d& o2d) | |
926 | { | |
927 | isoU = isoV = Standard_False; | |
928 | if (PC.IsNull()) return Standard_False; | |
929 | Handle(Geom2d_Curve) LLL = BASISCURVE2D(PC); | |
930 | Handle(Standard_Type) T2 = LLL->DynamicType(); | |
931 | Standard_Boolean isline2d = (T2 == STANDARD_TYPE(Geom2d_Line)); | |
932 | if (!isline2d) return Standard_False; | |
933 | ||
934 | Handle(Geom2d_Line) L = Handle(Geom2d_Line)::DownCast(LLL); | |
935 | d2d = L->Direction(); | |
936 | isoU = (Abs(d2d.X()) < Precision::Parametric(Precision::Confusion())); | |
937 | isoV = (Abs(d2d.Y()) < Precision::Parametric(Precision::Confusion())); | |
938 | Standard_Boolean isoUV = isoU || isoV; | |
939 | if (!isoUV) return Standard_False; | |
940 | ||
941 | o2d = L->Location(); | |
942 | return Standard_True; | |
943 | } | |
944 | ||
945 | Standard_Boolean TopOpeBRepTool_TOOL::UVISO(const TopoDS_Edge& E, const TopoDS_Face& F, | |
946 | Standard_Boolean & isoU, Standard_Boolean& isoV, gp_Dir2d& d2d, gp_Pnt2d& o2d) | |
947 | { | |
948 | // Standard_Real f,l,tol; Handle(Geom2d_Curve) PC = FC2D_CurveOnSurface(E,F,f,l,tol); | |
949 | Handle(Geom2d_Curve) PC; Standard_Real f,l,tol; | |
950 | Standard_Boolean hasold = FC2D_HasOldCurveOnSurface(E,F,PC); | |
951 | #ifdef DEB | |
952 | Standard_Boolean hasnew = | |
953 | #endif | |
954 | FC2D_HasNewCurveOnSurface(E,F,PC); | |
955 | PC = FC2D_EditableCurveOnSurface(E,F,f,l,tol); | |
956 | if (!hasold) FC2D_AddNewCurveOnSurface(PC,E,F,f,l,tol); | |
957 | ||
958 | Standard_Boolean iso = UVISO(PC,isoU,isoV,d2d,o2d); | |
959 | return iso; | |
960 | } | |
961 | ||
962 | Standard_Boolean TopOpeBRepTool_TOOL::UVISO(const TopOpeBRepTool_C2DF& C2DF, | |
963 | Standard_Boolean & isoU, Standard_Boolean& isoV, gp_Dir2d& d2d, gp_Pnt2d& o2d) | |
964 | { | |
965 | Standard_Real f,l,tol; const Handle(Geom2d_Curve)& PC = C2DF.PC(f,l,tol); | |
966 | //#ifdef DEB | |
967 | // const iso = UVISO(PC,isoU,isoV,d2d,o2d); | |
968 | //#else | |
969 | const Standard_Boolean iso = UVISO(PC,isoU,isoV,d2d,o2d); | |
970 | //#endif | |
971 | return iso; | |
972 | } | |
973 | ||
974 | ||
975 | //======================================================================= | |
976 | //function : IsonCLO | |
977 | //purpose : | |
978 | //======================================================================= | |
979 | ||
980 | Standard_Boolean TopOpeBRepTool_TOOL::IsonCLO(const Handle(Geom2d_Curve)& PC, | |
981 | const Standard_Boolean onU, const Standard_Real xfirst, const Standard_Real xperiod, const Standard_Real xtol) | |
982 | { | |
983 | Standard_Boolean isou,isov; gp_Pnt2d o2d; gp_Dir2d d2d; | |
984 | Standard_Boolean isouv = UVISO(PC,isou,isov,d2d,o2d); | |
985 | if (!isouv) return Standard_False; | |
986 | Standard_Boolean onX = (onU && isou) || ((!onU) && isov); | |
987 | if (!onX) return Standard_False; | |
988 | Standard_Real dxx=0; | |
989 | if (onU) dxx = Abs(o2d.X()-xfirst); | |
990 | else dxx = Abs(o2d.Y()-xfirst); | |
991 | ||
992 | Standard_Boolean onclo = (dxx < xtol); | |
993 | onclo = onclo || (Abs(xperiod-dxx) < xtol); | |
994 | return onclo; | |
995 | } | |
996 | Standard_Boolean TopOpeBRepTool_TOOL::IsonCLO(const TopOpeBRepTool_C2DF& C2DF, | |
997 | const Standard_Boolean onU, const Standard_Real xfirst, const Standard_Real xperiod, const Standard_Real xtol) | |
998 | { | |
999 | Standard_Real f,l,tol; const Handle(Geom2d_Curve)& PC = C2DF.PC(f,l,tol); | |
1000 | Standard_Boolean onclo = IsonCLO(PC,onU,xfirst,xperiod,xtol); | |
1001 | return onclo; | |
1002 | } | |
1003 | ||
1004 | //======================================================================= | |
1005 | //function : TrslUV | |
1006 | //purpose : | |
1007 | //======================================================================= | |
1008 | ||
1009 | void TopOpeBRepTool_TOOL::TrslUV(const gp_Vec2d& t2d, TopOpeBRepTool_C2DF& C2DF) | |
1010 | { | |
1011 | Standard_Real f,l,tol; Handle(Geom2d_Curve) PC = C2DF.PC(f,l,tol); | |
1012 | PC->Translate(t2d); | |
1013 | C2DF.SetPC(PC,f,l,tol); | |
1014 | } | |
1015 | ||
1016 | Standard_Boolean TopOpeBRepTool_TOOL::TrslUVModifE(const gp_Vec2d& t2d, const TopoDS_Face& F, TopoDS_Edge& E) | |
1017 | { | |
1018 | Standard_Real f,l,tol; Handle(Geom2d_Curve) PC = FC2D_CurveOnSurface(E,F,f,l,tol); | |
1019 | // Handle(Geom2d_Curve) PC; Standard_Real f,l,tol; | |
1020 | ||
1021 | if (PC.IsNull()) return Standard_False; | |
1022 | PC->Translate(t2d); | |
1023 | // Handle(Geom2d_Curve) toclear; BB.UpdateEdge(E,toclear,F,tole); | |
1024 | BRep_Builder BB; BB.UpdateEdge(E,PC,F,tol); | |
1025 | return Standard_True; | |
1026 | } | |
1027 | ||
1028 | //======================================================================= | |
1029 | //function : Matter | |
1030 | //purpose : | |
1031 | //======================================================================= | |
1032 | ||
1033 | Standard_Real TopOpeBRepTool_TOOL::Matter(const gp_Vec& d1, const gp_Vec& dR2, const gp_Vec& Ref) | |
1034 | { | |
1035 | gp_Vec d2 = dR2.Reversed(); | |
1036 | ||
1037 | Standard_Real tola = Precision::Angular(); | |
1038 | Standard_Real ang = d1.Angle(d2); | |
1039 | Standard_Boolean equal = (ang < tola); | |
1040 | if (equal) return 0.; | |
c6541a0c D |
1041 | Standard_Boolean oppo = ((M_PI-ang) < tola); |
1042 | if (oppo) return M_PI; | |
7fd59977 | 1043 | |
1044 | ang = d1.AngleWithRef(d2,Ref); | |
c6541a0c | 1045 | if (ang < 0) ang = 2.*M_PI+ang; |
7fd59977 | 1046 | return ang; |
1047 | } | |
1048 | ||
1049 | //======================================================================= | |
1050 | //function : Matter | |
1051 | //purpose : | |
1052 | //======================================================================= | |
1053 | ||
1054 | Standard_Real TopOpeBRepTool_TOOL::Matter(const gp_Vec2d& d1, const gp_Vec2d& dR2) | |
1055 | { | |
1056 | gp_Vec v1 = gp_Vec(d1.X(),d1.Y(),0.); | |
1057 | gp_Vec vR2 = gp_Vec(dR2.X(),dR2.Y(),0.); | |
1058 | gp_Vec Ref(0.,0.,1.); | |
1059 | ||
1060 | Standard_Real ang = TopOpeBRepTool_TOOL::Matter(v1,vR2,Ref); | |
1061 | return ang; | |
1062 | } | |
1063 | ||
1064 | //======================================================================= | |
1065 | //function : Matter | |
1066 | //purpose : | |
1067 | //======================================================================= | |
1068 | ||
1069 | Standard_Boolean TopOpeBRepTool_TOOL::Matter(const gp_Dir& xx1,const gp_Dir& nt1, | |
1070 | const gp_Dir& xx2,const gp_Dir& nt2, | |
1071 | const Standard_Real tola, Standard_Real& ang) | |
1072 | // purpose : the compute of MatterAng(f1,f2) | |
1073 | { | |
1074 | // -------------------------------------------------- | |
1075 | // Give us a face f1 and one edge e of f1, pone=pnt(e,pare) | |
1076 | // We project the problem in a plane normal to e, at point pone | |
1077 | // ie we see the problem in space (x,y), with RONd (x,y,z), z tangent to e at pone. | |
1078 | // RONd (x,y,z) = (xx1,nt1,x^y) | |
1079 | // | |
1080 | // Make the analogy : | |
1081 | // f <-> Ef, e <-> Ve, | |
1082 | // In view (x,y), f1 is seen as an edge Ef, e is seen as a vertex Ve, | |
1083 | // the matter delimited by f can be seen as the one delimited by Ef. | |
1084 | // -------------------------------------------------- | |
1085 | ||
1086 | // Sign( (v1^nt1).z ) describes Ve's orientation in Ef1 | |
1087 | // (v1^nt1).z > 0. => Ve is oriented REVERSED in Ef1. | |
1088 | // - ori(Ve,Ef1) == REVERSED : the matter delimited by <f1> | |
1089 | // is (y<=0) in (x,y) 2d space - | |
1090 | ||
1091 | gp_Dir z1 = xx1^nt1; | |
1092 | gp_Dir z2 = xx2^nt2; | |
1093 | Standard_Real dot = z2.Dot(z1); | |
1094 | Standard_Boolean oppo = (dot < 0.); | |
1095 | if (!oppo) return Standard_False; | |
1096 | ||
1097 | // -nti points towards 3dmatter(fi) | |
1098 | // => zi = xxi^nti gives the opposite sense for the compute of the matter angle | |
1099 | z1.Reverse(); | |
1100 | ang = xx1.AngleWithRef(xx2,z1); | |
1101 | if (Abs(ang) < tola) {ang = 0.; return Standard_True;} | |
c6541a0c | 1102 | if (ang < 0) ang = 2.*M_PI+ang; |
7fd59977 | 1103 | |
1104 | return Standard_True; | |
1105 | } | |
1106 | ||
1107 | //======================================================================= | |
1108 | //function : Getduv | |
1109 | //purpose : | |
1110 | //======================================================================= | |
1111 | ||
1112 | Standard_Boolean TopOpeBRepTool_TOOL::Getduv(const TopoDS_Face& f,const gp_Pnt2d& uv,const gp_Vec& dir, | |
1113 | const Standard_Real factor, gp_Dir2d& duv) | |
1114 | { | |
1115 | Standard_Boolean quad = TopOpeBRepTool_TOOL::IsQuad(f); | |
1116 | if (!quad) return Standard_False; | |
1117 | Bnd_Box bndf; BRepBndLib::AddClose(f,bndf); | |
1118 | Standard_Real f1,f2,f3,l1,l2,l3; bndf.Get(f1,f2,f3,l1,l2,l3); | |
1119 | gp_Vec d123(f1-l1, f2-l2, f3-l3); | |
1120 | #ifdef DEB | |
1121 | Standard_Real dmax = | |
1122 | #endif | |
1123 | d123.Dot(dir); | |
1124 | ||
1125 | gp_Pnt p; FUN_tool_value(uv,f,p); p.Translate(dir.Multiplied(factor)); | |
1126 | Standard_Real d; gp_Pnt2d uvtr; | |
1127 | #ifdef DEB | |
1128 | Standard_Boolean ok = | |
1129 | #endif | |
1130 | FUN_tool_projPonF(p,f, uvtr,d); | |
1131 | Standard_Real tolf = BRep_Tool::Tolerance(f); tolf *= 1.e2; //NYIXPUTOL | |
1132 | if (d > tolf) return Standard_False; | |
1133 | ||
1134 | gp_Vec2d DUV( uv, uvtr ); | |
1135 | Handle(Geom_Surface) S = TopOpeBRepTool_ShapeTool::BASISSURFACE(f); | |
1136 | if ((S->IsUPeriodic()) && (Abs(DUV.X()) > S->UPeriod()/2.)) | |
1137 | { | |
1138 | Standard_Real U1 = uv.X(), U2 = uvtr.X(), period = S->UPeriod(); | |
1139 | ElCLib::AdjustPeriodic( 0., period, Precision::PConfusion(), U1, U2 ); | |
1140 | Standard_Real dx = U2-U1; | |
1141 | if (dx > period/2.) | |
1142 | dx -= period; | |
1143 | DUV.SetX( dx ); | |
1144 | } | |
1145 | if ((S->IsVPeriodic()) && (Abs(DUV.Y()) > S->VPeriod()/2.)) | |
1146 | { | |
1147 | Standard_Real V1 = uv.Y(), V2 = uvtr.Y(), period = S->VPeriod(); | |
1148 | ElCLib::AdjustPeriodic( 0., period, Precision::PConfusion(), V1, V2 ); | |
1149 | Standard_Real dy = V2-V1; | |
1150 | if (dy > period/2.) | |
1151 | dy -= period; | |
1152 | DUV.SetY( dy ); | |
1153 | } | |
1154 | duv = gp_Dir2d( DUV ); | |
1155 | ||
1156 | return Standard_True; | |
1157 | } | |
1158 | ||
1159 | ||
1160 | ||
1161 | //======================================================================= | |
1162 | //function : uvApp | |
1163 | //purpose : | |
1164 | //======================================================================= | |
1165 | ||
1166 | Standard_Boolean TopOpeBRepTool_TOOL::uvApp(const TopoDS_Face& f,const TopoDS_Edge& e,const Standard_Real pare,const Standard_Real eps, | |
1167 | gp_Pnt2d& uvapp) | |
1168 | { | |
1169 | // uv : | |
1170 | Standard_Boolean ok = FUN_tool_paronEF(e,pare,f,uvapp); | |
1171 | if (!ok) return Standard_False; | |
1172 | gp_Vec2d dxx; ok = FUN_tool_getdxx(f,e,pare,dxx); | |
1173 | if (!ok) return Standard_False; | |
1174 | uvapp.Translate(dxx.Multiplied(eps)); | |
1175 | return Standard_True; | |
1176 | } | |
1177 | ||
1178 | //======================================================================= | |
1179 | //function : XX | |
1180 | //purpose : | |
1181 | //======================================================================= | |
1182 | ||
1183 | Standard_Boolean TopOpeBRepTool_TOOL::XX(const gp_Pnt2d& uv, const TopoDS_Face& f, | |
1184 | const Standard_Real par, const TopoDS_Edge& e, | |
1185 | gp_Dir& XX) | |
1186 | { | |
1187 | // ng(uv): | |
1188 | gp_Vec ng = FUN_tool_nggeomF(uv,f); | |
1189 | gp_Vec geomxx = FUN_tool_getgeomxx(f,e,par,ng); | |
1190 | ||
1191 | Standard_Real tol = Precision::Confusion()*1.e2;//NYITOL | |
1192 | Standard_Boolean nullng = (geomxx.Magnitude()<tol); | |
1193 | if (nullng) return Standard_False; | |
1194 | ||
1195 | TopAbs_Orientation oef; Standard_Boolean ok = FUN_tool_orientEinFFORWARD(e,f,oef); | |
1196 | if (!ok) return Standard_False; | |
1197 | XX = gp_Dir(geomxx); | |
1198 | if (M_REVERSED(oef)) XX.Reverse(); | |
1199 | return Standard_True; | |
1200 | } | |
1201 | ||
1202 | //======================================================================= | |
1203 | //function : Nt | |
1204 | //purpose : | |
1205 | //======================================================================= | |
1206 | ||
1207 | Standard_Boolean TopOpeBRepTool_TOOL::Nt(const gp_Pnt2d& uv, const TopoDS_Face& f, | |
1208 | gp_Dir& normt) | |
1209 | { | |
1210 | gp_Vec nggeom; Standard_Boolean ok = TopOpeBRepTool_TOOL::NggeomF(uv,f,nggeom); | |
1211 | if (!ok) return Standard_False; | |
1212 | normt = gp_Dir(nggeom); | |
1213 | if (M_REVERSED(f.Orientation())) normt.Reverse(); | |
1214 | return Standard_True; | |
1215 | } | |
1216 | ||
1217 | //======================================================================= | |
1218 | //function : NggeomF | |
1219 | //purpose : | |
1220 | //======================================================================= | |
1221 | ||
1222 | static Standard_Boolean FUN_ngF(const gp_Pnt2d& uv, const TopoDS_Face& F, gp_Vec& ngF) | |
1223 | { | |
1224 | BRepAdaptor_Surface bs(F); | |
1225 | Standard_Real tol3d = bs.Tolerance(); | |
1226 | Standard_Real tolu = bs.UResolution(tol3d); | |
1227 | Standard_Real tolv = bs.VResolution(tol3d); | |
1228 | ||
1229 | // ############################### | |
1230 | // nyi : all geometries are direct | |
1231 | // ############################### | |
1232 | gp_Pnt p; gp_Vec d1u,d1v; bs.D1(uv.X(),uv.Y(),p,d1u,d1v); | |
1233 | ||
1234 | Standard_Real delta = TopOpeBRepTool_TOOL::minDUV(F); delta *= 1.e-1; | |
1235 | ||
1236 | Standard_Real du = d1u.Magnitude(); | |
1237 | Standard_Real dv = d1v.Magnitude(); | |
1238 | Standard_Boolean kpart = (du < tolu) || (dv < tolv); | |
1239 | if (kpart) { | |
1240 | GeomAbs_SurfaceType ST = bs.GetType(); | |
1241 | if (ST == GeomAbs_Cone) { | |
1242 | Standard_Boolean nullx = (Abs(uv.X()) < tolu); | |
1243 | Standard_Boolean apex = nullx && (Abs(uv.Y()) < tolv); | |
1244 | if (apex) { | |
1245 | const gp_Dir& axis = bs.Cone().Axis().Direction(); | |
1246 | gp_Vec ng(axis); ng.Reverse(); | |
1247 | ngF = ng; return Standard_True; | |
1248 | } | |
1249 | else if (du < tolu) { | |
1250 | Standard_Real x = uv.X(); | |
1251 | ||
1252 | Standard_Real y = uv.Y(); | |
1253 | Standard_Real vf = bs.FirstVParameter(); | |
1254 | ||
1255 | if (Abs(vf-y) < tolu) vf += delta; | |
1256 | else vf -= delta; | |
1257 | ||
1258 | //modified by NIZHNY-MZV Fri Nov 26 12:38:55 1999 | |
1259 | y = vf; | |
1260 | bs.D1(x,y,p,d1u,d1v); | |
1261 | gp_Vec ng = d1u^d1v; | |
1262 | ||
1263 | ngF = ng; return Standard_True; | |
1264 | } | |
1265 | } | |
1266 | if (ST == GeomAbs_Sphere) { | |
c6541a0c | 1267 | Standard_Real pisur2 = M_PI*.5; |
7fd59977 | 1268 | Standard_Real u = uv.X(),v = uv.Y(); |
1269 | Standard_Boolean vpisur2 = (Abs(v-pisur2) < tolv); | |
1270 | Standard_Boolean vmoinspisur2 = (Abs(v+pisur2) < tolv); | |
1271 | Standard_Boolean apex = vpisur2 || vmoinspisur2; | |
1272 | if (apex) { | |
1273 | gp_Pnt center = bs.Sphere().Location(); | |
1274 | gp_Pnt value = bs.Value(u,v); | |
1275 | gp_Vec ng(center,value); | |
1276 | ngF = ng; return Standard_True; | |
1277 | } | |
1278 | } | |
1279 | #ifdef DEB | |
1280 | cout<<"FUN_tool_nggeomF NYI"<<endl; | |
1281 | #endif | |
1282 | return Standard_False; | |
1283 | } //kpart | |
1284 | ||
1285 | gp_Dir udir(d1u); | |
1286 | gp_Dir vdir(d1v); | |
1287 | ngF = gp_Vec(gp_Dir(udir^vdir)); | |
1288 | return Standard_True; | |
1289 | } | |
1290 | ||
1291 | Standard_Boolean TopOpeBRepTool_TOOL::NggeomF(const gp_Pnt2d& uv, const TopoDS_Face& f, | |
1292 | gp_Vec& ng) | |
1293 | { | |
1294 | return FUN_ngF(uv,f,ng); | |
1295 | } | |
1296 | ||
1297 | //======================================================================= | |
1298 | //function : Matter | |
1299 | //purpose : | |
1300 | //======================================================================= | |
1301 | ||
1302 | Standard_Boolean TopOpeBRepTool_TOOL::Matter(const TopoDS_Face& f1,const TopoDS_Face& f2, | |
1303 | const TopoDS_Edge& e,const Standard_Real par, | |
1304 | const Standard_Real tola, Standard_Real& ang) | |
1305 | { | |
1306 | gp_Dir xx1,xx2; | |
1307 | gp_Dir nt1,nt2; | |
1308 | ||
1309 | Standard_Real tolf1 = BRep_Tool::Tolerance(f1)*1.e2;//nyitolxpu | |
1310 | gp_Pnt2d uv1; Standard_Boolean ok1 = FUN_tool_paronEF(e,par,f1,uv1,tolf1); | |
1311 | if (!ok1) return Standard_False; | |
1312 | ok1 = TopOpeBRepTool_TOOL::Nt(uv1,f1,nt1); | |
1313 | if (!ok1) return Standard_False; | |
1314 | ok1 = TopOpeBRepTool_TOOL::XX(uv1,f1,par,e,xx1); | |
1315 | if (!ok1) return Standard_False; | |
1316 | ||
1317 | Standard_Real tolf2 = BRep_Tool::Tolerance(f2)*2.e2;//nyitolxpu | |
1318 | gp_Pnt2d uv2; Standard_Boolean ok2 = FUN_tool_paronEF(e,par,f2,uv2,tolf2); | |
1319 | if (!ok2) return Standard_False; | |
1320 | ok2 = TopOpeBRepTool_TOOL::Nt(uv2,f2,nt2); | |
1321 | if (!ok2) return Standard_False; | |
1322 | ok2 = TopOpeBRepTool_TOOL::XX(uv2,f2,par,e,xx2); | |
1323 | if (!ok2) return Standard_False; | |
1324 | ||
1325 | return (TopOpeBRepTool_TOOL::Matter(xx1,nt1,xx2,nt2,tola,ang)); | |
1326 | } | |
1327 | ||
1328 | ||
1329 | ||
1330 | ||
1331 | //======================================================================= | |
1332 | //function : MatterKPtg | |
1333 | //purpose : | |
1334 | //======================================================================= | |
1335 | ||
1336 | Standard_Boolean TopOpeBRepTool_TOOL::MatterKPtg(const TopoDS_Face& f1,const TopoDS_Face& f2,const TopoDS_Edge& e, | |
1337 | Standard_Real& ang) | |
1338 | { | |
1339 | Standard_Real f,l; FUN_tool_bounds(e,f,l); | |
1340 | Standard_Real x = 0.45678; Standard_Real pare = (1-x)*f+x*l; | |
1341 | ||
1342 | Standard_Real eps = 0.123; //NYIXPU190199 | |
1343 | #ifdef DEB | |
1344 | Standard_Real tola = Precision::Angular()*1.e3; | |
1345 | #endif | |
1346 | ||
1347 | gp_Pnt2d uv1; FUN_tool_paronEF(e,pare,f1,uv1); | |
1348 | gp_Dir nt1; Standard_Boolean ok1 = TopOpeBRepTool_TOOL::Nt(uv1,f1,nt1); | |
1349 | if (!ok1) return Standard_False; | |
1350 | gp_Pnt2d uvapp1; ok1 = TopOpeBRepTool_TOOL::uvApp(f1,e,pare,eps,uvapp1); | |
1351 | if (!ok1) return Standard_False; | |
1352 | gp_Pnt pf1; FUN_tool_value(uvapp1,f1,pf1); | |
1353 | ||
1354 | gp_Pnt2d uv2; Standard_Real d; Standard_Boolean ok2 = FUN_tool_projPonF(pf1,f2,uv2,d); | |
1355 | gp_Pnt pf2; FUN_tool_value(uv2,f2,pf2); | |
1356 | if (!ok2) return Standard_False; | |
1357 | ||
1358 | gp_Dir v12(gp_Vec(pf1,pf2)); | |
1359 | Standard_Real dot = v12.Dot(nt1); | |
c6541a0c | 1360 | ang = (dot < 0.) ? 0. : 2.*M_PI; |
7fd59977 | 1361 | |
1362 | // gp_Dir nt1; ok1 = TopOpeBRepTool_TOOL::Nt(uv1,f1,nt1); | |
1363 | // if (!ok1) return Standard_False; | |
1364 | // gp_Dir xx1; ok1 = TopOpeBRepTool_TOOL::XX(uv1,f1,pare,e,xx1); | |
1365 | // if (!ok1) return Standard_False; | |
1366 | // gp_Pnt2d uv2; Standard_Boolean ok2 = TopOpeBRepTool_TOOL::uvApp(f2,e,pare,eps,uv2); | |
1367 | // if (!ok2) return Standard_False; | |
1368 | // gp_Dir nt2; ok2 = TopOpeBRepTool_TOOL::Nt(uv2,f2,nt2); | |
1369 | // if (!ok2) return Standard_False; | |
1370 | // gp_Dir xx2; ok2 = TopOpeBRepTool_TOOL::XX(uv2,f2,pare,e,xx2); | |
1371 | // if (!ok2) return Standard_False; | |
1372 | // Standard_Real angapp; Standard_Boolean ok = TopOpeBRepTool_TOOL::Matter(xx1,nt1, xx2,nt2,tola,angapp); | |
1373 | // if (!ok) return Standard_False; | |
c6541a0c D |
1374 | // Standard_Boolean is0 = (Abs(angapp) < Abs(2.*M_PI-angapp)); |
1375 | // ang = is0 ? 0. : 2.*M_PI; | |
7fd59977 | 1376 | return Standard_True; |
1377 | } | |
1378 | ||
1379 | //======================================================================= | |
1380 | //function : Getstp3dF | |
1381 | //purpose : | |
1382 | //======================================================================= | |
1383 | ||
1384 | Standard_Boolean TopOpeBRepTool_TOOL::Getstp3dF(const gp_Pnt& p, const TopoDS_Face& f, gp_Pnt2d& uv, TopAbs_State& st) | |
1385 | // classification solide de <P> / <F> | |
1386 | { | |
1387 | st = TopAbs_UNKNOWN; | |
1388 | Standard_Real tol3d = BRep_Tool::Tolerance(f); | |
1389 | // EXPENSIVE : calls an extrema | |
1390 | Standard_Real d; Standard_Boolean ok = FUN_tool_projPonF(p,f,uv,d); | |
1391 | if (!ok) return Standard_False; | |
1392 | if (d < tol3d) {st = TopAbs_ON; return Standard_True;} | |
1393 | ||
1394 | gp_Pnt ppr; ok = FUN_tool_value(uv,f,ppr); | |
1395 | if (!ok) return Standard_False; | |
1396 | ||
1397 | gp_Dir ntf; ok = TopOpeBRepTool_TOOL::Nt(uv,f, ntf); | |
1398 | if (!ok) return Standard_False; | |
1399 | ||
1400 | gp_Dir dppr(gp_Vec(p,ppr)); | |
1401 | Standard_Real dot = dppr.Dot(ntf); | |
1402 | Standard_Boolean isOUT = (dot < 0.); | |
1403 | st = (isOUT ? TopAbs_OUT : TopAbs_IN); | |
1404 | return Standard_True; | |
1405 | } | |
1406 | ||
1407 | ||
1408 | ||
1409 | //======================================================================= | |
1410 | //function : MkShell | |
1411 | //purpose : | |
1412 | //======================================================================= | |
1413 | ||
1414 | void TopOpeBRepTool_TOOL::MkShell(const TopTools_ListOfShape& lF, TopoDS_Shape& She) | |
1415 | { | |
1416 | BRep_Builder BB; BB.MakeShell(TopoDS::Shell(She)); | |
1417 | for (TopTools_ListIteratorOfListOfShape li(lF); li.More(); li.Next()) BB.Add(She,li.Value()); | |
1418 | } | |
1419 | ||
1420 | //======================================================================= | |
1421 | //function : Remove | |
1422 | //purpose : | |
1423 | //======================================================================= | |
1424 | ||
1425 | Standard_Boolean TopOpeBRepTool_TOOL::Remove(TopTools_ListOfShape& loS, const TopoDS_Shape& toremove) | |
1426 | { | |
1427 | TopTools_ListIteratorOfListOfShape it(loS); | |
1428 | Standard_Boolean found = Standard_False; | |
1429 | while (it.More()) { | |
1430 | if (it.Value().IsEqual(toremove)) {loS.Remove(it);found = Standard_True;} | |
1431 | else it.Next(); | |
1432 | } | |
1433 | return found; | |
1434 | } | |
1435 | ||
1436 | //======================================================================= | |
1437 | //function : minDUV | |
1438 | //purpose : | |
1439 | //======================================================================= | |
1440 | ||
1441 | Standard_Real TopOpeBRepTool_TOOL::minDUV(const TopoDS_Face& F) | |
1442 | { | |
1443 | BRepAdaptor_Surface BS(F); | |
1444 | Standard_Real delta = BS.LastUParameter() - BS.FirstUParameter(); | |
1445 | Standard_Real tmp = BS.LastVParameter() - BS.FirstVParameter(); | |
1446 | delta = (tmp < delta) ? tmp : delta; | |
1447 | return delta; | |
1448 | } | |
1449 | ||
1450 | ||
1451 | //======================================================================= | |
1452 | //function : stuvF | |
1453 | //purpose : | |
1454 | //======================================================================= | |
1455 | #define INFFIRST (-1) | |
1456 | #define SUPLAST (-2) | |
1457 | #define ONFIRST (1) | |
1458 | #define ONLAST (2) | |
1459 | void TopOpeBRepTool_TOOL::stuvF(const gp_Pnt2d& uv,const TopoDS_Face& f, Standard_Integer& onU,Standard_Integer& onV) | |
1460 | { | |
1461 | BRepAdaptor_Surface bs(f); | |
1462 | onU = onV = 0; | |
1463 | Standard_Real tolf = bs.Tolerance(); | |
1464 | Standard_Real tolu = bs.UResolution(tolf), tolv = bs.VResolution(tolf); | |
1465 | Standard_Real u=uv.X(),v = uv.Y(); | |
1466 | Standard_Real uf=bs.FirstUParameter(),ul=bs.LastUParameter(),vf=bs.FirstVParameter(),vl=bs.LastVParameter(); | |
1467 | Standard_Boolean onuf = (Abs(uf-u)<tolu), onul = (Abs(ul-u)<tolu); | |
1468 | Standard_Boolean onvf = (Abs(vf-v)<tolv), onvl = (Abs(vl-v)<tolv); | |
1469 | if (onuf) onU = ONFIRST; if (onul) onU = ONLAST; | |
1470 | if (onvf) onV = ONFIRST; if (onvl) onV = ONLAST; | |
1471 | if (u < (uf-tolu)) onU = INFFIRST; if (u > (ul+tolu)) onU = SUPLAST; | |
1472 | if (v < (vf-tolv)) onV = INFFIRST; if (v > (vl+tolv)) onV = SUPLAST; | |
1473 | } | |
1474 | ||
1475 | //======================================================================= | |
1476 | //function : outUVbounds | |
1477 | //purpose : | |
1478 | //======================================================================= | |
1479 | ||
1480 | Standard_Boolean TopOpeBRepTool_TOOL::outUVbounds(const gp_Pnt2d& uv, const TopoDS_Face& F) | |
1481 | { | |
1482 | BRepAdaptor_Surface BS(F); | |
1483 | Standard_Boolean outofboundU = (uv.X() > BS.LastUParameter())||(uv.X() < BS.FirstUParameter()); | |
1484 | Standard_Boolean outofboundV = (uv.Y() > BS.LastVParameter())||(uv.Y() < BS.FirstVParameter()); | |
1485 | return outofboundU || outofboundV; | |
1486 | } | |
1487 | ||
1488 | //======================================================================= | |
1489 | //function : TolUV | |
1490 | //purpose : | |
1491 | //======================================================================= | |
1492 | ||
1493 | Standard_Real TopOpeBRepTool_TOOL::TolUV(const TopoDS_Face& F, const Standard_Real tol3d) | |
1494 | { | |
1495 | BRepAdaptor_Surface bs(F); | |
1496 | Standard_Real tol2d = bs.UResolution(tol3d); | |
1497 | tol2d = Max(tol2d,bs.VResolution(tol3d)); | |
1498 | return tol2d; | |
1499 | } | |
1500 | ||
1501 | //======================================================================= | |
1502 | //function : TolP | |
1503 | //purpose : | |
1504 | //======================================================================= | |
1505 | ||
1506 | Standard_Real TopOpeBRepTool_TOOL::TolP(const TopoDS_Edge& E, const TopoDS_Face& F) | |
1507 | { | |
1508 | BRepAdaptor_Curve2d BC2d(E,F); | |
1509 | return ( BC2d.Resolution(BRep_Tool::Tolerance(E)) ); | |
1510 | } | |
1511 | ||
1512 | //======================================================================= | |
1513 | //function : WireToFace | |
1514 | //purpose : | |
1515 | //======================================================================= | |
1516 | ||
1517 | Standard_Boolean TopOpeBRepTool_TOOL::WireToFace(const TopoDS_Face& Fref, const TopTools_DataMapOfShapeListOfShape& mapWlow, | |
1518 | TopTools_ListOfShape& lFs) | |
1519 | { | |
1520 | BRep_Builder BB; | |
1521 | TopoDS_Shape aLocalShape = Fref.Oriented(TopAbs_FORWARD); | |
1522 | TopoDS_Face F = TopoDS::Face(aLocalShape); | |
1523 | // TopoDS_Face F = TopoDS::Face(Fref.Oriented(TopAbs_FORWARD)); | |
1524 | Standard_Boolean toreverse = M_REVERSED(Fref.Orientation()); | |
1525 | TopTools_DataMapIteratorOfDataMapOfShapeListOfShape itm(mapWlow); | |
1526 | for (; itm.More(); itm.Next()) { | |
1527 | TopoDS_Shape FF = F.EmptyCopied(); | |
1528 | const TopoDS_Wire& wi = TopoDS::Wire(itm.Key()); | |
1529 | BB.Add(FF,wi); | |
1530 | TopTools_ListIteratorOfListOfShape itw(itm.Value()); | |
1531 | for (; itw.More(); itw.Next()) { | |
1532 | const TopoDS_Wire& wwi = TopoDS::Wire(itw.Value()); | |
1533 | BB.Add(FF,wwi); | |
1534 | } | |
1535 | if (toreverse) FF.Orientation(TopAbs_REVERSED); | |
1536 | lFs.Append(FF); | |
1537 | } | |
1538 | return Standard_True; | |
1539 | } | |
1540 | ||
1541 | //======================================================================= | |
1542 | //function : EdgeONFace | |
1543 | //purpose : | |
1544 | //======================================================================= | |
1545 | ||
1546 | Standard_Boolean TopOpeBRepTool_TOOL::EdgeONFace(const Standard_Real par,const TopoDS_Edge& ed, | |
1547 | const gp_Pnt2d& uv,const TopoDS_Face& fa, | |
1548 | Standard_Boolean& isonfa) | |
1549 | { | |
1550 | isonfa = Standard_False; | |
1551 | // prequesitory : pnt(par,ed) = pnt(uv,f) | |
1552 | Standard_Boolean dge = BRep_Tool::Degenerated(ed); | |
1553 | if (dge) { | |
1554 | isonfa = Standard_True; | |
1555 | return Standard_True; | |
1556 | } | |
1557 | ||
1558 | Standard_Real tola = Precision::Angular()*1.e2;//NYITOLXPU | |
1559 | gp_Vec tge; Standard_Boolean ok = TopOpeBRepTool_TOOL::TggeomE(par,ed,tge); | |
1560 | if (!ok) return Standard_False; | |
1561 | gp_Vec ngf = FUN_tool_nggeomF(uv,fa); | |
1562 | Standard_Real prod = tge.Dot(ngf); | |
1563 | Standard_Boolean etgf = Abs(prod) < tola; | |
1564 | if (!etgf) return Standard_True; | |
1565 | ||
1566 | BRepAdaptor_Surface bs(fa); | |
1567 | GeomAbs_SurfaceType st = bs.GetType(); | |
1568 | Standard_Boolean plane = (st == GeomAbs_Plane); | |
1569 | Standard_Boolean cylinder = (st == GeomAbs_Cylinder); | |
1570 | ||
1571 | BRepAdaptor_Curve bc(ed); | |
1572 | GeomAbs_CurveType ct = bc.GetType(); | |
1573 | Standard_Boolean line = (ct == GeomAbs_Line); | |
1574 | Standard_Boolean circle = (ct == GeomAbs_Circle); | |
1575 | ||
1576 | Standard_Real tole = bc.Tolerance(); Standard_Real tol1de = bc.Resolution(tole); | |
1577 | Standard_Real tolf = bs.Tolerance(); | |
1578 | Standard_Real tol3d = Max(tole,tolf)*1.e2;//NYITOLXPU | |
1579 | ||
1580 | // NYIxpu100299 : for other analytic geometries | |
1581 | if (plane && line) {isonfa = Standard_True; return Standard_True;} | |
1582 | if (plane) { | |
1583 | gp_Dir ne; | |
1584 | Standard_Boolean det = Standard_True; | |
1585 | if (circle) ne = bc.Circle().Axis().Direction(); | |
1586 | else if (ct == GeomAbs_Ellipse) ne = bc.Ellipse().Axis().Direction(); | |
1587 | else if (ct == GeomAbs_Hyperbola) ne = bc.Hyperbola().Axis().Direction(); | |
1588 | else if (ct == GeomAbs_Parabola)ne = bc.Parabola().Axis().Direction(); | |
1589 | else det = Standard_False; | |
1590 | if (det) { | |
1591 | Standard_Real prod = ne.Dot(ngf); | |
1592 | isonfa = ( Abs(1-Abs(prod)) < tola ); | |
1593 | return Standard_True; | |
1594 | } | |
1595 | }//plane | |
1596 | else if (cylinder) { | |
1597 | gp_Dir ne; Standard_Boolean det = Standard_True; | |
1598 | if (line) ne = tge; | |
1599 | else if (circle)ne = bc.Circle().Axis().Direction(); | |
1600 | else det = Standard_False; | |
1601 | gp_Dir axicy = bs.Cylinder().Axis().Direction(); | |
1602 | ||
1603 | if (det) { | |
1604 | Standard_Real prod = ne.Dot(axicy); | |
1605 | isonfa = ( Abs(1-Abs(prod)) < tola ); | |
1606 | if (isonfa && circle) { | |
1607 | Standard_Real radci = bc.Circle().Radius(); | |
1608 | Standard_Real radcy = bs.Cylinder().Radius(); | |
1609 | isonfa = ( Abs(radci-radcy)<tol3d ); | |
1610 | } | |
1611 | return Standard_True; | |
1612 | } | |
1613 | }//cylinder | |
1614 | ||
1615 | // !!!!!!!!!!!!!!!! NOT STILL OK !!!!!!!!!!!!!! | |
1616 | // projecting point of <ed> on <fa> | |
1617 | Standard_Real x = 0.12345; | |
1618 | Standard_Real f,l; FUN_tool_bounds(ed,f,l); | |
1619 | Standard_Boolean onf = ( Abs(par-f)<tol1de ); | |
1620 | Standard_Real opar = onf ? ((1-x)*f+x*l) : ((1-x)*f+x*par); | |
1621 | gp_Pnt opc = bc.Value(opar); | |
1622 | ||
1623 | gp_Pnt2d ouv; ok = FUN_tool_parF(ed,opar,fa,ouv,tolf); | |
1624 | if (!ok) return Standard_False; | |
1625 | gp_Pnt ops = bs.Value(ouv.X(),ouv.Y()); | |
1626 | ||
1627 | Standard_Real dd = opc.Distance(ops); | |
1628 | isonfa = (dd < tol3d); | |
1629 | return Standard_True; | |
1630 | } |