projects / occt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
0022792: Globally defined symbol PI conflicts with VTK definition (Intel compiler)
[occt.git] / src / TopOpeBRepTool / TopOpeBRepTool_TOOL.cxx
CommitLineData
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
58static 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
64static 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//=======================================================================
77static 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
119Standard_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
158Standard_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
183Standard_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
207Standard_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
221Standard_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
236Standard_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
251void 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
281TopoDS_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
293Standard_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
304Standard_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
324static 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
360Standard_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
409gp_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
421Standard_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
440Standard_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
468Standard_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
494Standard_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
526Standard_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
546gp_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
561gp_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
587gp_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
603Standard_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
634Standard_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
703Standard_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
722Standard_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
734Standard_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
747Standard_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// ================================================================================
809static 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
878Standard_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
924Standard_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
945Standard_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
962Standard_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
980Standard_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}
996Standard_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
1009void 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
1016Standard_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
1033Standard_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
1054Standard_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
1069Standard_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
1112Standard_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
1166Standard_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
1183Standard_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
1207Standard_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
1222static 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
1291Standard_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
1302Standard_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
1336Standard_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
1384Standard_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
1414void 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
1425Standard_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
1441Standard_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)
1459void 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
1480Standard_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
1493Standard_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
1506Standard_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
1517Standard_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
1546Standard_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}
Open CASCADE Technology repository