1 // Created on: 1998-10-06
2 // Created by: Jean Yves LEBEY
3 // Copyright (c) 1998-1999 Matra Datavision
4 // Copyright (c) 1999-2012 OPEN CASCADE SAS
6 // The content of this file is subject to the Open CASCADE Technology Public
7 // License Version 6.5 (the "License"). You may not use the content of this file
8 // except in compliance with the License. Please obtain a copy of the License
9 // at http://www.opencascade.org and read it completely before using this file.
11 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
12 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
14 // The Original Code and all software distributed under the License is
15 // distributed on an "AS IS" basis, without warranty of any kind, and the
16 // Initial Developer hereby disclaims all such warranties, including without
17 // limitation, any warranties of merchantability, fitness for a particular
18 // purpose or non-infringement. Please see the License for the specific terms
19 // and conditions governing the rights and limitations under the License.
22 #include <Geom_Curve.hxx>
23 #include <Geom_TrimmedCurve.hxx>
24 #include <Geom_Surface.hxx>
25 #include <GeomAdaptor_Surface.hxx>
26 #include <Bnd_Box2d.hxx>
27 #include <Bnd_Box.hxx>
28 #include <BRepBndLib.hxx>
29 #include <BndLib_Add2dCurve.hxx>
30 #include <BRepAdaptor_Surface.hxx>
31 #include <gp_Pnt2d.hxx>
34 #include <gp_Dir2d.hxx>
37 #include <gp_Cylinder.hxx>
38 #include <gp_Cone.hxx>
39 #include <gp_Sphere.hxx>
40 #include <gp_Torus.hxx>
42 #include <TopExp_Explorer.hxx>
44 #include <TopoDS_Wire.hxx>
45 #include <BRep_Tool.hxx>
46 #include <BRep_Builder.hxx>
48 #include <Precision.hxx>
49 #include <TColStd_Array1OfReal.hxx>
50 #include <TopOpeBRepTool_CurveTool.hxx>
51 #include <TopOpeBRepTool_ShapeTool.hxx>
52 #include <TopOpeBRepTool_2d.hxx>
54 #include <TopOpeBRepTool_GEOMETRY.hxx>
55 #include <TopOpeBRepTool_PROJECT.hxx>
56 #include <TopOpeBRepTool_TOPOLOGY.hxx>
57 #include <TopOpeBRepTool_TOOL.hxx>
59 //---------------------------------------------
60 #define M_FORWARD(ori) (ori == TopAbs_FORWARD)
61 #define M_REVERSED(ori) (ori == TopAbs_REVERSED)
62 #define M_INTERNAL(ori) (ori == TopAbs_INTERNAL)
63 #define M_EXTERNAL(ori) (ori == TopAbs_EXTERNAL)
64 // ----------------------------------------------------------------------
66 // ----------------------------------------------------------------------
67 Standard_EXPORT void FUN_tool_tolUV(const TopoDS_Face& F,Standard_Real& tolu,Standard_Real& tolv)
69 Standard_Real tolF = BRep_Tool::Tolerance(TopoDS::Face(F));
70 BRepAdaptor_Surface BS(TopoDS::Face(F));
71 tolu = BS.UResolution(tolF);
72 tolv = BS.VResolution(tolF);
75 // ----------------------------------------------------------------------
76 Standard_EXPORT Standard_Boolean FUN_tool_direct(const TopoDS_Face& F,Standard_Boolean& direct)
78 BRepAdaptor_Surface BS(TopoDS::Face(F));
79 GeomAbs_SurfaceType ST = BS.GetType();
80 Standard_Boolean plane = (ST == GeomAbs_Plane);
81 Standard_Boolean cyl = (ST == GeomAbs_Cylinder);
82 Standard_Boolean cone = (ST == GeomAbs_Cone);
83 Standard_Boolean sphe = (ST == GeomAbs_Sphere);
84 Standard_Boolean torus = (ST == GeomAbs_Torus);
85 if (plane) {const gp_Pln& plpl = BS.Plane(); direct = plpl.Direct();}
86 if (cyl) {const gp_Cylinder& cycy = BS.Cylinder(); direct = cycy.Direct();}
87 if (cone) {const gp_Cone& coco = BS.Cone(); direct = coco.Direct();}
88 if (sphe) {const gp_Sphere& spsp = BS.Sphere(); direct = spsp.Direct();}
89 if (torus) {const gp_Torus& toto = BS.Torus(); direct = toto.Direct();}
90 Standard_Boolean ok = plane || cyl || cone || sphe || torus;
94 /*// ----------------------------------------------------------------------
95 Standard_EXPORT Standard_Boolean FUN_tool_IsUViso(const TopoDS_Shape& E,const TopoDS_Shape& F,
96 Standard_Boolean& isoU,Standard_Boolean& isoV,
97 gp_Dir2d& d2d,gp_Pnt2d& o2d)
99 isoU = isoV = Standard_False; Standard_Real f,l,tol;
100 Handle(Geom2d_Curve) PC =
101 FC2D_CurveOnSurface(TopoDS::Edge(E),TopoDS::Face(F),f,l,tol);
102 if (PC.IsNull()) return Standard_False;
103 Standard_Boolean iso = FUN_tool_IsUViso(PC,isoU,isoV,d2d,o2d);
107 // ----------------------------------------------------------------------
108 Standard_EXPORT Standard_Boolean FUN_tool_geombounds(const TopoDS_Face& F,
109 Standard_Real& u1,Standard_Real& u2,Standard_Real& v1,Standard_Real& v2)
111 const Handle(Geom_Surface)& S = BRep_Tool::Surface(F);
112 if (S.IsNull()) return Standard_False;
113 S->Bounds(u1,u2,v1,v2);
114 return Standard_True;
117 // ----------------------------------------------------------------------
118 Standard_EXPORT Standard_Boolean FUN_tool_bounds(const TopoDS_Shape& Sh,
122 // Standard_Real& v2)
126 const TopoDS_Face& F = TopoDS::Face(Sh);
127 TopExp_Explorer ex(F,TopAbs_WIRE);
128 for (; ex.More(); ex.Next()){
129 const TopoDS_Wire W = TopoDS::Wire(ex.Current());
130 Bnd_Box2d newB2d; FUN_tool_mkBnd2d(W,F,newB2d);
133 B2d.Get(u1,v1,u2,v1);
134 return Standard_True;
137 // ----------------------------------------------------------------------
138 Standard_EXPORT Standard_Boolean FUN_tool_isobounds(const TopoDS_Shape& Sh,
139 Standard_Real& u1,Standard_Real& u2,Standard_Real& v1,Standard_Real& v2)
141 const TopoDS_Face& F = TopoDS::Face(Sh);
142 u1 = v1 = 1.e7; u2 = v2 = -1.e7;
144 const Handle(Geom_Surface)& S = BRep_Tool::Surface(F);
145 if (S.IsNull()) return Standard_False;
147 Standard_Boolean uclosed,vclosed; Standard_Real uperiod,vperiod;
149 // Standard_Boolean uvclosed =
151 FUN_tool_closedS(F,uclosed,uperiod,vclosed,vperiod);
153 // Standard_Real uf,ul,vf,vl; S->Bounds(uf,ul,vf,vl);
156 // u1 = uf; v1 = vf; u2 = ul; v2 = vl;
157 // return Standard_True;
159 TopExp_Explorer ex(F,TopAbs_EDGE);
160 for (; ex.More(); ex.Next()){
161 const TopoDS_Edge& E = TopoDS::Edge(ex.Current());
162 Standard_Real f,l,tol; Handle(Geom2d_Curve) PC = FC2D_CurveOnSurface(E,F,f,l,tol);
163 if (PC.IsNull()) return Standard_False;
165 Standard_Boolean isou,isov; gp_Pnt2d o2d; gp_Dir2d d2d;
166 Standard_Boolean isouv = TopOpeBRepTool_TOOL::UVISO(PC,isou,isov,d2d,o2d);
169 gp_Pnt2d p2df = PC->Value(f); gp_Pnt2d p2dl = PC->Value(l);
170 u1 = Min(p2df.X(),u1); u2 = Max(p2df.X(),u2); v1 = Min(p2df.Y(),v1); v2 = Max(p2df.Y(),v2);
171 u1 = Min(p2dl.X(),u1); u2 = Max(p2dl.X(),u2); v1 = Min(p2dl.Y(),v1); v2 = Max(p2dl.Y(),v2);
173 if (!isouv) return Standard_False;
174 // ====================
176 return Standard_True;
179 // ----------------------------------------------------------------------
180 Standard_EXPORT Standard_Boolean FUN_tool_outbounds(const TopoDS_Shape& Sh,
181 Standard_Real& u1,Standard_Real& u2,Standard_Real& v1,Standard_Real& v2,Standard_Boolean& outbounds)
183 Handle(Geom_Surface) S = TopOpeBRepTool_ShapeTool::BASISSURFACE(TopoDS::Face(Sh));
184 if (S.IsNull()) return Standard_False;
185 Standard_Real uf,ul,vf,vl; S->Bounds(uf,ul,vf,vl);
187 outbounds = Standard_False;
188 Standard_Boolean ok = FUN_tool_bounds(Sh,u1,u2,v1,v2);
189 if (!ok) return Standard_False;
191 const TopoDS_Face& F = TopoDS::Face(Sh);
192 Standard_Boolean uclosed,vclosed; Standard_Real uperiod,vperiod;
193 FUN_tool_closedS(F,uclosed,uperiod,vclosed,vperiod);
194 Standard_Real tolp = 1.e-6;
197 Standard_Real dd = u2-u1;
198 if (dd > uperiod + tolp) {u1 = uf; v1 = vf; u2 = ul; v2 = vl; outbounds=Standard_True;}
201 Standard_Real dd = v2-v1;
202 if (dd > vperiod + tolp) {u1 = uf; v1 = vf; u2 = ul; v2 = vl; outbounds=Standard_True;}
204 return Standard_True;
207 // ----------------------------------------------------------------------
208 Standard_EXPORT Standard_Boolean FUN_tool_PinC(const gp_Pnt& P,
209 const BRepAdaptor_Curve& BAC,
210 const Standard_Real pmin,const Standard_Real pmax,
211 const Standard_Real tol)
213 // returns true if <P> is on <C> under a given tolerance <tol>
214 Standard_Boolean PinC = Standard_False;
215 Extrema_ExtPC ponc(P,BAC,pmin,pmax);
216 Standard_Boolean ok = ponc.IsDone();
218 if ( ponc.NbExt() ) {
219 Standard_Integer i = FUN_tool_getindex(ponc);
220 Standard_Real d2 = ponc.SquareDistance(i);
221 PinC = (d2 <= tol * tol);
227 // ----------------------------------------------------------------------
228 Standard_EXPORT Standard_Boolean FUN_tool_PinC(const gp_Pnt& P,
229 const BRepAdaptor_Curve& BAC,
230 const Standard_Real tol)
232 // returns true if <P> is on <C> under a given tolerance <tol>
233 Standard_Boolean PinC = Standard_False;
234 Standard_Real pmin = BAC.FirstParameter();
235 Standard_Real pmax = BAC.LastParameter();
236 PinC = FUN_tool_PinC(P,BAC,pmin,pmax,tol);
240 // ----------------------------------------------------------------------
241 Standard_EXPORT Standard_Boolean FUN_tool_value(const Standard_Real par,const TopoDS_Edge& E,gp_Pnt& P)
243 BRepAdaptor_Curve BAC(E);
244 Standard_Real f = BAC.FirstParameter();
245 Standard_Real l = BAC.LastParameter();
246 Standard_Boolean ok = (f <= par) && (par <= l);
247 if (!ok) return Standard_False;
249 return Standard_True;
252 // ----------------------------------------------------------------------
253 Standard_EXPORT Standard_Boolean FUN_tool_value(const gp_Pnt2d& UV,const TopoDS_Face& F,gp_Pnt& P)
255 BRepAdaptor_Surface BS(F);
256 P = BS.Value(UV.X(),UV.Y());
257 return Standard_True;
260 // ----------------------------------------------------------------------
261 Standard_EXPORT TopAbs_State FUN_tool_staPinE(const gp_Pnt& P,const TopoDS_Edge& E,const Standard_Real tol)
263 // project point on curve,
264 // if projection fails,returns UNKNOWN.
265 // finds a point <pnear> on edge <E> / d(<pnear>,<P>) < tol
268 TopAbs_State sta = TopAbs_UNKNOWN;
269 BRepAdaptor_Curve BAC(E);
270 Extrema_ExtPC ProjonBAC(P,BAC);
271 if (ProjonBAC.IsDone() && ProjonBAC.NbExt()>0) {
272 Standard_Integer i = FUN_tool_getindex(ProjonBAC);
273 gp_Pnt Pnear = ProjonBAC.Point(i).Value();
274 Standard_Real d = Pnear.Distance(P);
275 sta = (d < tol)? TopAbs_IN: TopAbs_OUT;
279 // ----------------------------------------------------------------------
280 Standard_EXPORT TopAbs_State FUN_tool_staPinE(const gp_Pnt& P,const TopoDS_Edge& E)
282 // Standard_Real tol = Precision::Confusion()*10.;
283 Standard_Real tol3d = BRep_Tool::Tolerance(E)*1.e2;//KKKKK a revoir xpu(CTS21118,f14ou,GI13)
284 TopAbs_State sta = FUN_tool_staPinE(P,E,tol3d);
288 // ----------------------------------------------------------------------
289 // subshape's orientation :
290 // - vertex orientation in edge
291 // - edge's orientation in face.Oriented(FORWARD)
292 // ----------------------------------------------------------------------
298 // ----------------------------------------------------------------------
299 Standard_EXPORT Standard_Integer FUN_tool_orientVinE(const TopoDS_Vertex& v,const TopoDS_Edge& e)
301 Standard_Integer result = 0;
302 TopoDS_Vertex vf,vl; TopExp::Vertices(e,vf,vl);
303 Standard_Boolean visf = v.IsSame(vf);
304 Standard_Boolean visl = v.IsSame(vl);
305 if (visf) result = FIRST;
306 if (visl) result = LAST;
307 if (visf && visl) result = CLOSING;
311 // ----------------------------------------------------------------------
312 Standard_EXPORT Standard_Boolean FUN_tool_orientEinF(const TopoDS_Edge& E,const TopoDS_Face& F,TopAbs_Orientation& oriEinF)
314 oriEinF = TopAbs_FORWARD;
315 TopExp_Explorer e(F,TopAbs_EDGE);
316 for (;e.More();e.Next()) {
317 const TopoDS_Shape& EF = e.Current();
319 oriEinF=EF.Orientation();
323 Standard_Boolean ok=e.More();
327 // ----------------------------------------------------------------------
328 Standard_EXPORT Standard_Boolean FUN_tool_orientEinFFORWARD(const TopoDS_Edge& E,const TopoDS_Face& F,TopAbs_Orientation& oriEinF)
330 // <oriEinF> : dummy for closing edge <E> of <F>.
331 // returns false if <E> is not bound of <F>
332 // else,<oriEinF> = orientation of the edge in <F> oriented FORWARD.
333 TopoDS_Shape aLocalShape = F.Oriented(TopAbs_FORWARD);
334 TopoDS_Face FF = TopoDS::Face(aLocalShape);
335 // TopoDS_Face FF = TopoDS::Face(F.Oriented(TopAbs_FORWARD));
336 oriEinF = TopAbs_EXTERNAL;
337 TopAbs_Orientation reso; Standard_Boolean ok = ::FUN_tool_orientEinF(E,FF,reso);
338 if (ok) oriEinF = reso;
342 // ----------------------------------------------------------------------
343 Standard_EXPORT Standard_Boolean FUN_tool_EboundF(const TopoDS_Edge& E,const TopoDS_Face& F)
345 TopAbs_Orientation ori; Standard_Boolean ok = FUN_tool_orientEinFFORWARD(E,F,ori);
346 if (!ok) return Standard_False;
347 Standard_Boolean closingE = BRep_Tool::IsClosed(E,F);
348 if (closingE) return Standard_True;
349 Standard_Boolean notbound = (ori == TopAbs_INTERNAL) || (ori == TopAbs_EXTERNAL);
353 // ----------------------------------------------------------------------
354 Standard_EXPORT gp_Vec FUN_tool_nggeomF(const gp_Pnt2d& p2d,const TopoDS_Face& F)
356 Handle(Geom_Surface) S = BRep_Tool::Surface(F);
357 gp_Vec ngF(FUN_tool_ngS(p2d,S));
361 // ----------------------------------------------------------------------
362 Standard_EXPORT Standard_Boolean FUN_tool_nggeomF(const Standard_Real& paronE,const TopoDS_Edge& E,const TopoDS_Face& F,
363 gp_Vec& nggeomF,const Standard_Real tol)
366 Standard_Real f,l; gp_Pnt2d p2d;
367 Standard_Boolean project = Standard_True;
368 TopAbs_Orientation oef;
369 Standard_Boolean edonfa = FUN_tool_orientEinFFORWARD(E,F,oef);
372 Handle(Geom2d_Curve) c2d = FC2D_CurveOnSurface(E,F,f,l,ttol);
373 project = c2d.IsNull();
375 p2d = c2d->Value(paronE);
378 BRepAdaptor_Curve BC(E);
379 gp_Pnt p3d = BC.Value(paronE);
380 Standard_Real d; Standard_Boolean ok = FUN_tool_projPonF(p3d,F,p2d,d);
382 //modified by NIZHNY-MZV Wed Dec 1 13:55:08 1999
383 //if !ok try to compute new pcurve
386 Handle(Geom2d_Curve) c2d = FC2D_CurveOnSurface(E,F,f,l,ttol);
389 p2d = c2d->Value(paronE);
391 if (!ok) return Standard_False;
392 //modified by NIZHNY-MZV Wed Dec 1 13:56:14 1999
394 gp_Pnt p3duv; FUN_tool_value(p2d,F,p3duv);
395 Standard_Real dd = p3duv.Distance(p3d);
396 if (dd > tol) return Standard_False;
399 nggeomF = FUN_tool_nggeomF(p2d,F);
400 return Standard_True;
403 // ----------------------------------------------------------------------
404 Standard_EXPORT Standard_Boolean FUN_tool_nggeomF(const Standard_Real& paronE,const TopoDS_Edge& E,const TopoDS_Face& F,
407 Standard_Real tol3d = BRep_Tool::Tolerance(F);
409 Standard_Boolean ok = FUN_tool_nggeomF(paronE,E,F,nggeomF,tol3d);
413 // ----------------------------------------------------------------------
414 Standard_EXPORT Standard_Boolean FUN_tool_EtgF(const Standard_Real& paronE,const TopoDS_Edge& E,
415 const gp_Pnt2d& p2d,const TopoDS_Face& F,
416 const Standard_Real tola)
418 gp_Vec tgE; Standard_Boolean ok = TopOpeBRepTool_TOOL::TggeomE(paronE,E,tgE);
419 if (!ok) return Standard_False;//NYIRAISE
421 gp_Vec ngF = FUN_tool_nggeomF(p2d,F);
422 Standard_Real prod = tgE.Dot(ngF);
423 Standard_Boolean tgt = Abs(prod) < tola;
427 // ----------------------------------------------------------------------
428 Standard_EXPORT Standard_Boolean FUN_tool_EtgOOE(const Standard_Real& paronE,const TopoDS_Edge& E,
429 const Standard_Real& paronOOE,const TopoDS_Edge& OOE,
430 const Standard_Real tola)
432 gp_Vec tgOOE; Standard_Boolean ok = TopOpeBRepTool_TOOL::TggeomE(paronOOE,OOE,tgOOE);
433 if (!ok) return Standard_False;//NYIRAISE
434 gp_Vec tgE; ok = TopOpeBRepTool_TOOL::TggeomE(paronE,E,tgE);
435 if (!ok) return Standard_False;//NYIRAISE
436 Standard_Real prod = tgOOE.Dot(tgE);
437 Standard_Boolean tg = (Abs(1- Abs(prod)) < tola);
441 // ----------------------------------------------------------------------
442 Standard_EXPORT Standard_Boolean FUN_nearestISO(const TopoDS_Face& F,const Standard_Real xpar,const Standard_Boolean isoU,Standard_Real& xinf,Standard_Real& xsup)
444 // IMPORTANT : xinf=xf,xsup=xl are INITIALIZED with first and last x
445 // parameters of F (x = u,v )
446 // purpose : finding greater xinf : xinf <= xpar
447 // smaller xsup : xpar <=xsup
448 Standard_Real tol2d = 1.e-6;
449 Standard_Real df = xpar-xinf; Standard_Boolean onf = (Abs(df)<tol2d);
450 Standard_Real dl = xpar-xsup; Standard_Boolean onl = (Abs(dl)<tol2d);
451 if (onf || onl) return Standard_True;
453 Standard_Boolean isoV = !isoU;
454 TopExp_Explorer ex(F,TopAbs_EDGE);
455 for (; ex.More(); ex.Next()){
456 const TopoDS_Edge& E = TopoDS::Edge(ex.Current());
457 Standard_Boolean isou,isov; gp_Pnt2d o2d; gp_Dir2d d2d;
458 Standard_Boolean isouv = TopOpeBRepTool_TOOL::UVISO(E,F,isou,isov,d2d,o2d);
459 if (!isouv) return Standard_False;
461 Standard_Boolean compare = (isoU && isou) || (isoV && isov);
462 if (!compare) return Standard_False;
463 Standard_Real xvalue = isou ? o2d.X() : o2d.Y();
466 if (xinf < xvalue) xinf = xvalue;
468 if (xvalue < xsup) xsup = xvalue;
470 return Standard_True;
473 // ----------------------------------------------------------------------
474 Standard_EXPORT Standard_Boolean FUN_tool_EitangenttoFe(const gp_Dir& ngFe,const TopoDS_Edge& Ei,
475 const Standard_Real parOnEi)
477 // returns true if <Ei> is tangent to Fe at point
478 // p3d of param <parOnEi>,<ngFe> is normal to Fe at p3d.
479 gp_Vec tgEi; Standard_Boolean ok = TopOpeBRepTool_TOOL::TggeomE(parOnEi,Ei,tgEi);
480 if (!ok) return Standard_False;//NYIRAISE
482 Standard_Real prod = ngFe.Dot(tgEi);
483 Standard_Real tol = Precision::Parametric(Precision::Confusion());
484 Standard_Boolean tangent = (Abs(prod) <= tol);
488 // ----------------------------------------------------------------------
489 Standard_EXPORT GeomAbs_CurveType FUN_tool_typ(const TopoDS_Edge& E)
491 BRepAdaptor_Curve BC(E);
492 GeomAbs_CurveType typ = BC.GetType();
496 // ----------------------------------------------------------------------
497 Standard_EXPORT Standard_Boolean FUN_tool_line(const TopoDS_Edge& E)
499 BRepAdaptor_Curve BC(E);
500 Standard_Boolean line = (BC.GetType() == GeomAbs_Line);
504 // ----------------------------------------------------------------------
505 Standard_EXPORT Standard_Boolean FUN_tool_plane(const TopoDS_Shape& F)
507 Handle(Geom_Surface) S = TopOpeBRepTool_ShapeTool::BASISSURFACE(TopoDS::Face(F));
508 GeomAdaptor_Surface GS(S);
509 return (GS.GetType() == GeomAbs_Plane);
512 // ----------------------------------------------------------------------
513 Standard_EXPORT Standard_Boolean FUN_tool_cylinder(const TopoDS_Shape& F)
515 Handle(Geom_Surface) S = TopOpeBRepTool_ShapeTool::BASISSURFACE(TopoDS::Face(F));
516 GeomAdaptor_Surface GS(S);
517 return (GS.GetType() == GeomAbs_Cylinder);
520 // ----------------------------------------------------------------------
521 Standard_EXPORT Standard_Boolean FUN_tool_closedS(const TopoDS_Shape& F,
522 Standard_Boolean& uclosed,Standard_Real& uperiod,
523 Standard_Boolean& vclosed,Standard_Real& vperiod)
525 // const Handle(Geom_Surface)& S = BRep_Tool::Surface(TopoDS::Face(F));
526 Handle(Geom_Surface) S =TopOpeBRepTool_ShapeTool::BASISSURFACE(TopoDS::Face(F));
527 if (S.IsNull()) return Standard_False;
528 Standard_Boolean closed = FUN_tool_closed(S,uclosed,uperiod,vclosed,vperiod);
532 // ----------------------------------------------------------------------
533 Standard_EXPORT Standard_Boolean FUN_tool_closedS(const TopoDS_Shape& F)
535 Standard_Boolean uclosed=Standard_False,vclosed=Standard_False; Standard_Real uperiod=0.,vperiod=0.;
536 Standard_Boolean closed = FUN_tool_closedS(F,uclosed,uperiod,vclosed,vperiod);
540 // ----------------------------------------------------------------------
541 Standard_EXPORT Standard_Boolean FUN_tool_closedS(const TopoDS_Shape& F,
542 Standard_Boolean& inU, Standard_Real& xmin, Standard_Real& xper)
544 Standard_Boolean uclosed,vclosed; Standard_Real uperiod,vperiod;
545 Handle(Geom_Surface) S =TopOpeBRepTool_ShapeTool::BASISSURFACE(TopoDS::Face(F));
546 if (S.IsNull()) return Standard_False;
547 Standard_Boolean closed = FUN_tool_closed(S,uclosed,uperiod,vclosed,vperiod);
548 if (!closed) return Standard_False;
549 Standard_Real u1,u2,v1,v2; S->Bounds(u1,u2,v1,v2);
552 xper = inU ? uperiod : vperiod;
553 xmin = inU ? u1 : v1;
554 return Standard_False ;
556 // ----------------------------------------------------------------------
557 Standard_EXPORT void FUN_tool_mkBnd2d(const TopoDS_Shape& W,const TopoDS_Shape& FF,Bnd_Box2d& B2d)
559 // greater <B> with <W>'s UV representation on <F>
560 Standard_Real tol = 1.e-8;
563 for (ex.Init(W,TopAbs_EDGE); ex.More(); ex.Next()) {
564 // for (TopExp_Explorer ex(W,TopAbs_EDGE); ex.More(); ex.Next()) {
565 const TopoDS_Edge& E = TopoDS::Edge(ex.Current());
566 const TopoDS_Face& F = TopoDS::Face(FF);
567 Standard_Real f,l,tolpc; Handle(Geom2d_Curve) pc;
568 Standard_Boolean haspc = FC2D_HasCurveOnSurface(E,F);
570 Standard_Real tolE = BRep_Tool::Tolerance(E);
571 pc = FC2D_CurveOnSurface(E,F,f,l,tolpc);
572 Standard_Real newtol = Max(tolE,tolpc);
573 BRep_Builder BB; BB.UpdateEdge(E,pc,F,newtol);
575 BRepAdaptor_Curve2d BC2d(E,F);
576 BndLib_Add2dCurve::Add(BC2d,tol,newB2d);
579 FUN_tool_UpdateBnd2d(B2d,newB2d);
582 // ----------------------------------------------------------------------
583 // closing topologies :
584 // ----------------------------------------------------------------------
586 // ----------------------------------------------------------------------
587 Standard_EXPORT Standard_Boolean FUN_tool_IsClosingE(const TopoDS_Edge& E,const TopoDS_Shape& S,const TopoDS_Face& F)
589 Standard_Integer nbocc = 0;
591 for (exp.Init(S,TopAbs_EDGE);exp.More();exp.Next())
592 // for (TopExp_Explorer exp(S,TopAbs_EDGE);exp.More();exp.Next())
593 if (exp.Current().IsSame(E)) nbocc++;
594 if (nbocc != 2) return Standard_False;
595 return BRep_Tool::IsClosed(E,F);
598 // ----------------------------------------------------------------------
599 Standard_EXPORT Standard_Boolean FUN_tool_ClosingE(const TopoDS_Edge& E,const TopoDS_Wire& W,const TopoDS_Face& F)
601 Standard_Boolean clo = FUN_tool_IsClosingE(E,W,F);
605 /*// ----------------------------------------------------------------------
606 Standard_EXPORT Standard_Boolean FUN_tool_ClosedE(const TopoDS_Edge& E,TopoDS_Shape& vclosing)
608 // returns true if <E> has a closing vertex <vclosing>
609 // return E.IsClosed();
610 Standard_Boolean isdgE = BRep_Tool::Degenerated(E);
611 if (isdgE) return Standard_False;
613 TopoDS_Shape vv; vclosing.Nullify();
614 TopExp_Explorer ex(E,TopAbs_VERTEX);
615 for (; ex.More(); ex.Next()) {
616 const TopoDS_Shape& v = ex.Current();
617 if (M_INTERNAL(v.Orientation())) continue;
618 if (vv.IsNull()) vv = v;
619 else if (v.IsSame(vv))
620 {vclosing = vv; return Standard_True;}
622 return Standard_False;
625 // ----------------------------------------------------------------------
626 // shared topologies :
627 // ----------------------------------------------------------------------
629 // ----------------------------------------------------------------------
630 Standard_EXPORT Standard_Boolean FUN_tool_inS(const TopoDS_Shape& subshape,const TopoDS_Shape& shape)
632 TopAbs_ShapeEnum sstyp = subshape.ShapeType();
633 TopTools_IndexedMapOfShape M; TopExp::MapShapes(shape,sstyp,M);
634 Standard_Boolean isbound = M.Contains(subshape);
638 // ----------------------------------------------------------------------
639 Standard_EXPORT Standard_Boolean FUN_tool_Eshared(const TopoDS_Shape& v,const TopoDS_Shape& F1,const TopoDS_Shape& F2,
640 TopoDS_Shape& Eshared)
641 //purpose : finds out <Eshared> shared by <F1> and <F2>,
642 // with <V> bound of <Eshared>
644 TopTools_ListOfShape e1s;
645 TopExp_Explorer ex(F1,TopAbs_EDGE);
646 for (; ex.More(); ex.Next()){
647 const TopoDS_Shape& e1 = ex.Current();
648 Standard_Boolean e1ok = Standard_False;
649 TopExp_Explorer exv(e1,TopAbs_VERTEX);
650 for (; exv.More(); exv.Next())
651 if (exv.Current().IsSame(v)) {e1ok = Standard_True; break;}
652 if (e1ok) e1s.Append(e1);
654 ex.Init(F2,TopAbs_EDGE);
655 for (; ex.More(); ex.Next()){
656 const TopoDS_Shape& e2 = ex.Current();
657 TopTools_ListIteratorOfListOfShape it1(e1s);
658 for (; it1.More(); it1.Next())
659 if (it1.Value().IsSame(e2)) {Eshared = e2; return Standard_True;}
661 return Standard_False;
664 // ----------------------------------------------------------------------
665 Standard_EXPORT Standard_Boolean FUN_tool_parVonE(const TopoDS_Vertex& v,const TopoDS_Edge& E,Standard_Real& par)
667 Standard_Real tol = Precision::Confusion();
668 Standard_Boolean isVofE = Standard_False;;
670 for (ex.Init(E,TopAbs_VERTEX); ex.More(); ex.Next()) {
671 // for (TopExp_Explorer ex(E,TopAbs_VERTEX); ex.More(); ex.Next()) {
672 isVofE = ex.Current().IsSame(v);
674 par = BRep_Tool::Parameter(TopoDS::Vertex(ex.Current()),E);
679 gp_Pnt pt = BRep_Tool::Pnt(v);
680 // <v> can share same domain with a vertex of <E>
681 for (ex.Init(E,TopAbs_VERTEX); ex.More(); ex.Next()) {
682 const TopoDS_Vertex& vex = TopoDS::Vertex(ex.Current());
683 gp_Pnt ptex = BRep_Tool::Pnt(vex);
684 if (ptex.IsEqual(pt,tol)) {
685 par = BRep_Tool::Parameter(vex,E);
686 return Standard_True;
690 // Standard_Real f,l;
691 BRepAdaptor_Curve BAC(E);
692 Extrema_ExtPC pro(pt,BAC);
693 Standard_Boolean done = pro.IsDone() && (pro.NbExt() >0);
694 if (!done) return Standard_False;
695 Standard_Integer i = FUN_tool_getindex(pro);
696 par = pro.Point(i).Parameter();
698 return Standard_True;
701 // ----------------------------------------------------------------------
702 Standard_EXPORT Standard_Boolean FUN_tool_parE(const TopoDS_Edge& E0,const Standard_Real& par0,
703 const TopoDS_Edge& E,Standard_Real& par,const Standard_Real tol)
705 gp_Pnt P; Standard_Boolean ok = FUN_tool_value(par0,E0,P);
706 if (!ok) return Standard_False;
708 Standard_Real dist; ok = FUN_tool_projPonE(P,E,par,dist);
709 if (!ok) return Standard_False;
714 // ----------------------------------------------------------------------
715 Standard_EXPORT Standard_Boolean FUN_tool_parE(const TopoDS_Edge& E0,const Standard_Real& par0,
716 const TopoDS_Edge& E,Standard_Real& par)
717 // ? <par> : P -> <par0> on <E0>,<par> on <E>
718 // prequesitory : point(par0 ,E0) is IN 1d(E)
720 Standard_Real tol3d = BRep_Tool::Tolerance(E)*1.e2;//KKKKK a revoir xpu(CTS21118,f14ou,GI13)
721 Standard_Boolean ok = FUN_tool_parE(E0,par0,E,par,tol3d);
725 // ----------------------------------------------------------------------
726 Standard_EXPORT Standard_Boolean FUN_tool_parF(const TopoDS_Edge& E,const Standard_Real& par,
727 const TopoDS_Face& F,gp_Pnt2d& UV, const Standard_Real tol3d)
728 // ? <UV> : P -> <par> on <E>,<UV> on <F>
730 gp_Pnt P; Standard_Boolean ok = FUN_tool_value(par,E,P);
731 if (!ok) return Standard_False;
733 Standard_Real dist; ok = FUN_tool_projPonF(P,F,UV,dist);
734 if (!ok) return Standard_False;
739 Standard_EXPORT Standard_Boolean FUN_tool_parF(const TopoDS_Edge& E,const Standard_Real& par,
740 const TopoDS_Face& F,gp_Pnt2d& UV)
742 Standard_Real tol3d = BRep_Tool::Tolerance(F)*1.e2; //KK xpu
743 Standard_Boolean ok = FUN_tool_parF(E,par,F,UV,tol3d);
747 // ----------------------------------------------------------------------
748 Standard_EXPORT Standard_Boolean FUN_tool_paronEF(const TopoDS_Edge& E,const Standard_Real& par,
749 const TopoDS_Face& F,gp_Pnt2d& UV, const Standard_Real tol3d)
750 // <E> is on <F> ? <UV> : P -> <par> on <E>,<UV> on <F>
752 Standard_Real f,l,tol; Handle(Geom2d_Curve) PC = FC2D_CurveOnSurface(E,F,f,l,tol);
754 Standard_Boolean ok = FUN_tool_parF(E,par,F,UV,tol3d);
757 Standard_Boolean ok = (f <= par) && (par <= l);
758 if (!ok) return Standard_False;
760 return Standard_True;
762 Standard_EXPORT Standard_Boolean FUN_tool_paronEF(const TopoDS_Edge& E,const Standard_Real& par,
763 const TopoDS_Face& F,gp_Pnt2d& UV)
765 Standard_Real tol3d = BRep_Tool::Tolerance(F)*1.e2; // KKxpu
766 Standard_Boolean ok = FUN_tool_paronEF(E,par,F,UV,tol3d);
770 // ----------------------------------------------------------------------
771 Standard_EXPORT gp_Dir FUN_tool_dirC(const Standard_Real par,const BRepAdaptor_Curve& BAC)
773 gp_Pnt p; gp_Vec tgE; BAC.D1(par,p,tgE);
778 // ----------------------------------------------------------------------
779 Standard_EXPORT gp_Vec FUN_tool_tggeomE(const Standard_Real paronE,const TopoDS_Edge& E)
781 Standard_Boolean isdgE = BRep_Tool::Degenerated(E);
782 if (isdgE) return gp_Vec(0,0,0);
783 gp_Vec dirE(FUN_tool_dirC(paronE,E));
787 // ----------------------------------------------------------------------
788 Standard_EXPORT Standard_Boolean FUN_tool_line(const BRepAdaptor_Curve& BAC)
790 Standard_Boolean line = (BAC.GetType() == GeomAbs_Line);
794 // ----------------------------------------------------------------------
795 Standard_EXPORT Standard_Boolean FUN_tool_quad(const TopoDS_Edge& E)
797 BRepAdaptor_Curve BC(E);
798 GeomAbs_CurveType CT = BC.GetType();
799 Standard_Boolean quad = FUN_quadCT(CT);
803 // ----------------------------------------------------------------------
804 Standard_EXPORT Standard_Boolean FUN_tool_quad(const BRepAdaptor_Curve& BAC)
806 GeomAbs_CurveType CT = BAC.GetType();
807 Standard_Boolean isquad = Standard_False;
808 if (CT == GeomAbs_Line) isquad = Standard_True;
809 if (CT == GeomAbs_Circle) isquad = Standard_True;
810 if (CT == GeomAbs_Ellipse) isquad = Standard_True;
811 if (CT == GeomAbs_Hyperbola) isquad = Standard_True;
812 if (CT == GeomAbs_Parabola) isquad = Standard_True;
816 // ----------------------------------------------------------------------
817 Standard_EXPORT Standard_Boolean FUN_tool_quad(const TopoDS_Face& F)
819 Handle(Geom_Surface) S = TopOpeBRepTool_ShapeTool::BASISSURFACE(F);
820 Standard_Boolean quad = FUN_tool_quad(S);
824 // ----------------------------------------------------------------------
825 Standard_EXPORT Standard_Boolean FUN_tool_findPinBAC(const BRepAdaptor_Curve& BAC,gp_Pnt& P,Standard_Real& par)
827 FUN_tool_findparinBAC(BAC,par);
829 return Standard_True;
832 // ----------------------------------------------------------------------
833 Standard_EXPORT Standard_Boolean FUN_tool_findparinBAC(const BRepAdaptor_Curve& BAC,Standard_Real& par)
835 Standard_Real fE = BAC.FirstParameter(),lE = BAC.LastParameter();
836 Standard_Real t = 0.34567237; par = (1-t)*fE + t*lE;
837 return Standard_True;
840 // ----------------------------------------------------------------------
841 Standard_EXPORT Standard_Boolean FUN_tool_findparinE(const TopoDS_Shape& E,Standard_Real& par)
843 BRepAdaptor_Curve BAC(TopoDS::Edge(E));
844 Standard_Boolean r = FUN_tool_findparinBAC(BAC,par);
848 // ----------------------------------------------------------------------
849 Standard_EXPORT Standard_Boolean FUN_tool_findPinE(const TopoDS_Shape& E,gp_Pnt& P,Standard_Real& par)
851 BRepAdaptor_Curve BAC(TopoDS::Edge(E));
852 Standard_Boolean r = FUN_tool_findPinBAC(BAC,P,par);
856 // ----------------------------------------------------------------------
858 // ----------------------------------------------------------------------
860 // ----------------------------------------------------------------------
861 Standard_EXPORT Standard_Boolean FUN_tool_maxtol(const TopoDS_Shape& S,const TopAbs_ShapeEnum& typ,Standard_Real& maxtol)
862 // purpose : returns maxtol of <S>'s shapes of type <typ>
865 Standard_Boolean face = (typ == TopAbs_FACE);
866 Standard_Boolean edge = (typ == TopAbs_EDGE);
867 Standard_Boolean vertex = (typ == TopAbs_VERTEX);
868 TopExp_Explorer ex(S,typ);
869 Standard_Boolean hasshatyp = ex.More();
870 for (; ex.More(); ex.Next()){
871 const TopoDS_Shape& ss = ex.Current();
872 Standard_Real tolss = 0.;
873 if (face) tolss = BRep_Tool::Tolerance(TopoDS::Face(ss));
874 if (edge) tolss = BRep_Tool::Tolerance(TopoDS::Edge(ss));
875 if (vertex) tolss = BRep_Tool::Tolerance(TopoDS::Vertex(ss));
876 if (tolss > maxtol) maxtol = tolss;
881 // ----------------------------------------------------------------------
882 Standard_EXPORT Standard_Real FUN_tool_maxtol(const TopoDS_Shape& S)
883 // purpose : returns maxtol between <S>'s shapes.
885 Standard_Real maxtol = 0.;
886 if (S.IsNull()) return maxtol;
887 Standard_Boolean hasfa = FUN_tool_maxtol(S,TopAbs_FACE,maxtol);
889 TopExp_Explorer exf(S,TopAbs_FACE);
890 for (; exf.More(); exf.Next()){
891 const TopoDS_Shape& ff = exf.Current();
892 Standard_Boolean hasedge = FUN_tool_maxtol(ff,TopAbs_EDGE,maxtol);
894 TopExp_Explorer exe(S,TopAbs_FACE);
895 for (; exe.More(); exe.Next())
897 const TopoDS_Shape& ee = exe.Current();
898 FUN_tool_maxtol(ee,TopAbs_VERTEX,maxtol);
904 Standard_Boolean hasedge = FUN_tool_maxtol(S,TopAbs_EDGE,maxtol);
906 TopExp_Explorer exe(S,TopAbs_FACE);
907 for (; exe.More(); exe.Next())
909 const TopoDS_Shape& ee = exe.Current();
910 FUN_tool_maxtol(ee,TopAbs_VERTEX,maxtol);
914 FUN_tool_maxtol(S,TopAbs_VERTEX,maxtol);
920 // ----------------------------------------------------------------------
921 Standard_EXPORT Standard_Integer FUN_tool_nbshapes(const TopoDS_Shape& S,const TopAbs_ShapeEnum& typ)
923 TopExp_Explorer ex(S,typ);
924 Standard_Integer i = 0;
925 for (; ex.More(); ex.Next()) i++;
929 // ----------------------------------------------------------------------
930 Standard_EXPORT void FUN_tool_shapes(const TopoDS_Shape& S,const TopAbs_ShapeEnum& typ,
931 TopTools_ListOfShape& ltyp)
933 TopExp_Explorer ex(S,typ);
934 for (; ex.More(); ex.Next()) ltyp.Append(ex.Current());
937 // ----------------------------------------------------------------------
938 Standard_EXPORT Standard_Integer FUN_tool_comparebndkole(const TopoDS_Shape& sh1,const TopoDS_Shape& sh2)
939 // purpose: comparing bounding boxes of <sh1> and <sh2>,
940 // returns k =1,2 if shi is contained in shk
943 Bnd_Box bnd1; BRepBndLib::Add(sh1,bnd1); bnd1.SetGap(0.);
944 Bnd_Box bnd2; BRepBndLib::Add(sh2,bnd2); bnd2.SetGap(0.);
946 if(bnd1.IsOut(bnd2)) return 0;
947 TColStd_Array1OfReal xyz1(1,6),xyz2(1,6);
948 bnd1.Get(xyz1(1),xyz1(2),xyz1(3),xyz1(4),xyz1(5),xyz1(6));
949 bnd2.Get(xyz2(1),xyz2(2),xyz2(3),xyz2(4),xyz2(5),xyz2(6));
950 Standard_Real tol = Precision::Confusion();
952 Standard_Integer neq,n2sup; neq=n2sup=0;
953 // for (Standard_Integer i = 1; i<=3; i++) {
955 for ( i = 1; i<=3; i++) {
956 Standard_Real d = xyz2(i)-xyz1(i);
957 Standard_Boolean eq = (Abs(d) < tol);
958 if (eq) {neq++; continue;}
961 for (i = 4; i<=6; i++) {
962 Standard_Real d = xyz2(i)-xyz1(i);
963 Standard_Boolean eq = (Abs(d) < tol);
964 if (eq) {neq++; continue;}
967 if (n2sup + neq != 6) return 0;
968 if (neq == 6) return 0;
970 Standard_Integer ires = (n2sup > 0)? 2: 1;
974 // ----------------------------------------------------------------------
975 Standard_EXPORT Standard_Boolean FUN_tool_SameOri(const TopoDS_Edge& E1,const TopoDS_Edge& E2)
976 //prequesitory : 1- <E1> and <E2> share same domain,
977 // 2- C3d<E1> contains C3d<E2>
979 Standard_Real f,l; FUN_tool_bounds(E2,f,l);
980 Standard_Real x = 0.345;
981 Standard_Real mid = x*f + (1-x)*l;
982 gp_Pnt Pmid; FUN_tool_value(mid,E2,Pmid);
983 gp_Vec tmp; Standard_Boolean ok = TopOpeBRepTool_TOOL::TggeomE(mid,E2,tmp);
984 if (!ok) return Standard_False;
986 TopAbs_Orientation oriE2 = E2.Orientation();
987 if (M_REVERSED(oriE2)) tgE2.Reverse();
989 Standard_Real pE1,dist; ok = FUN_tool_projPonE(Pmid,E1,pE1,dist);
990 Standard_Real tol1 = BRep_Tool::Tolerance(E1);
991 Standard_Real tol2 = BRep_Tool::Tolerance(E2);
992 Standard_Real tol = Max(tol1,tol2)* 10.;
993 if (dist > tol) return Standard_False;
994 if (!ok) return Standard_False;
995 ok = TopOpeBRepTool_TOOL::TggeomE(pE1,E1,tmp);
996 if (!ok) return Standard_False;
998 TopAbs_Orientation oriE1 = E1.Orientation();
999 if (M_REVERSED(oriE1)) tgE1.Reverse();
1001 Standard_Boolean sameori = (tgE2.Dot(tgE1) > 0.);
1005 // ----------------------------------------------------------------------
1006 Standard_EXPORT Standard_Boolean FUN_tool_haspc(const TopoDS_Edge& E,const TopoDS_Face& F)
1008 Standard_Real f,l,tol; Handle(Geom2d_Curve) C2d = FC2D_CurveOnSurface(E,F,f,l,tol);
1009 Standard_Boolean null = C2d.IsNull();
1013 // ----------------------------------------------------------------------
1014 Standard_EXPORT Standard_Boolean FUN_tool_pcurveonF(const TopoDS_Face& F,TopoDS_Edge& E)
1016 Standard_Real f,l; Handle(Geom_Curve) C3d = BRep_Tool::Curve(E,f,l);
1017 if (C3d.IsNull()) return Standard_False;
1018 Standard_Real tolReached2d;
1019 Handle(Geom2d_Curve) C2d =
1020 TopOpeBRepTool_CurveTool::MakePCurveOnFace(F,C3d,tolReached2d,f,l);
1021 if (C2d.IsNull()) return Standard_False;
1023 Standard_Real tolE = BRep_Tool::Tolerance(E);
1025 BB.UpdateEdge(E,C2d,F,tolE);
1026 return Standard_True;
1029 // ----------------------------------------------------------------------
1030 Standard_EXPORT Standard_Boolean FUN_tool_pcurveonF(const TopoDS_Face& fF,TopoDS_Edge& faultyE,
1031 const Handle(Geom2d_Curve)& C2d,
1035 TopExp_Explorer exw(fF,TopAbs_WIRE);
1036 TopTools_ListOfShape low;
1037 Standard_Boolean hasnewf = Standard_False;
1038 for (; exw.More(); exw.Next()){
1039 const TopoDS_Shape& w = exw.Current();
1041 TopTools_ListOfShape loe; Standard_Boolean hasneww = Standard_False;
1042 TopExp_Explorer exe(w,TopAbs_EDGE);
1043 for (; exe.More(); exe.Next()){
1044 const TopoDS_Edge& e = TopoDS::Edge(exe.Current());
1045 Standard_Boolean equal = e.IsEqual(faultyE);
1046 if (!equal) {loe.Append(e); continue;}
1048 Standard_Real tole = BRep_Tool::Tolerance(e);
1049 TopoDS_Vertex vf,vl; TopExp::Vertices(e,vf,vl);
1051 TopoDS_Edge newe = faultyE;
1052 // TopoDS_Edge newe; FUN_ds_CopyEdge(e,newe); newe.Orientation(TopAbs_FORWARD);
1053 // vf.Orientation(TopAbs_FORWARD); BB.Add(newe,vf); FUN_ds_Parameter(newe,vf,parf);
1054 // vl.Orientation(TopAbs_REVERSED); BB.Add(newe,vl); FUN_ds_Parameter(newe,vl,parl);
1055 BB.UpdateEdge(newe,C2d,fF,tole);
1056 newe.Orientation(e.Orientation());
1058 hasneww = Standard_True;
1059 hasnewf = Standard_True;
1062 TopoDS_Wire neww; Standard_Boolean ok = FUN_tool_MakeWire(loe,neww);
1063 if (!ok) return Standard_False;
1069 TopoDS_Shape aLocalShape = fF.EmptyCopied();
1070 newf = TopoDS::Face(aLocalShape);
1071 // newf = TopoDS::Face(fF.EmptyCopied());
1072 for (TopTools_ListIteratorOfListOfShape itw(low); itw.More(); itw.Next()){
1073 const TopoDS_Shape w = itw.Value();
1076 return Standard_True;
1078 return Standard_False;
1081 // ----------------------------------------------------------------------
1082 // shared geometry :
1083 // ----------------------------------------------------------------------
1085 // ----------------------------------------------------------------------
1086 Standard_EXPORT Standard_Boolean FUN_tool_curvesSO(const TopoDS_Edge& E1,const Standard_Real p1,const TopoDS_Edge& E2,const Standard_Real p2,
1087 Standard_Boolean& so)
1089 BRepAdaptor_Curve BAC1(E1);
1090 BRepAdaptor_Curve BAC2(E2);
1091 gp_Vec tg1; Standard_Boolean ok = TopOpeBRepTool_TOOL::TggeomE(p1,E1,tg1);
1092 if (!ok) return Standard_False;//NYIRAISE
1093 gp_Vec tg2; ok = TopOpeBRepTool_TOOL::TggeomE(p2,E2,tg2);
1094 if (!ok) return Standard_False;//NYIRAISE
1095 Standard_Real tola = Precision::Angular()*1.e3;
1096 Standard_Boolean oppo = tg1.IsOpposite(tg2,tola);
1097 Standard_Boolean samo = tg1.IsParallel(tg2,tola);
1098 if (oppo) so = Standard_False;
1099 else if (samo) so = Standard_True;
1100 else return Standard_False;
1101 return Standard_True;
1103 Standard_EXPORT Standard_Boolean FUN_tool_curvesSO(const TopoDS_Edge& E1,const Standard_Real p1,const TopoDS_Edge& E2,Standard_Boolean& so)
1105 // prequesitory : P3d(E1,p1) is IN 1d(E2)
1106 Standard_Real p2 = 0.; Standard_Boolean ok = FUN_tool_parE(E1,p1,E2,p2);
1107 if (!ok) return Standard_False;
1108 ok = FUN_tool_curvesSO(E1,p1,E2,p2,so);
1112 // ----------------------------------------------------------------------
1113 Standard_EXPORT Standard_Boolean FUN_tool_curvesSO(const TopoDS_Edge& E1,const TopoDS_Edge& E2,Standard_Boolean& so)
1115 // prequesitory : E1 is IN 1d(E2)
1116 TopoDS_Vertex vf1,vl1; TopExp::Vertices(E1,vf1,vl1);
1117 Standard_Boolean closed1 = vf1.IsSame(vl1);
1118 TopoDS_Vertex vf2,vl2; TopExp::Vertices(E2,vf2,vl2);
1119 Standard_Boolean closed2 = vf2.IsSame(vl2);
1120 Standard_Boolean project = Standard_False;
1121 if (closed1 || closed2) project = Standard_True;
1123 if (vf1.IsSame(vf2)) so = Standard_True;
1124 else if (vl1.IsSame(vl2)) so = Standard_True;
1125 else if (vf1.IsSame(vl2)) so = Standard_False;
1126 else if (vl1.IsSame(vf2)) so = Standard_False;
1127 else project = Standard_True;
1130 Standard_Real f,l; FUN_tool_bounds(E1,f,l);
1131 Standard_Real x = 0.45678; Standard_Real p1 = (1-x)*l + x*f;
1132 Standard_Boolean ok = FUN_tool_curvesSO(E1,p1,E2,so);
1135 return Standard_True;
1138 // ----------------------------------------------------------------------
1139 Standard_EXPORT Standard_Boolean FUN_tool_findAncestor(const TopTools_ListOfShape& lF,const TopoDS_Edge& E,TopoDS_Face& Fanc)
1141 TopTools_ListIteratorOfListOfShape it(lF);
1142 for (; it.More(); it.Next()){
1143 const TopoDS_Face& F = TopoDS::Face(it.Value());
1144 TopAbs_Orientation dummy; Standard_Boolean found = FUN_tool_orientEinF(E,F,dummy);
1145 if (found) {Fanc = F; return Standard_True;}
1147 return Standard_False;
1150 // ----------------------------------------------------------------------
1152 // ----------------------------------------------------------------------
1154 // FUN_ds_* methods are methods of TopOpeBRepDS_BuildTool
1155 // that cannot be called (cyclic dependencies)
1157 // ----------------------------------------------------------------------
1158 Standard_EXPORT void FUN_ds_CopyEdge(const TopoDS_Shape& Ein,TopoDS_Shape& Eou)
1161 TopoDS_Edge E1 = TopoDS::Edge(Ein);
1162 BRep_Tool::Range(E1,f,l);
1163 Eou = Ein.EmptyCopied();
1164 TopoDS_Edge E2 = TopoDS::Edge(Eou);
1169 // ----------------------------------------------------------------------
1170 Standard_EXPORT void FUN_ds_Parameter(const TopoDS_Shape& E,const TopoDS_Shape& V,const Standard_Real P)
1173 const TopoDS_Edge& e = TopoDS::Edge(E);
1174 const TopoDS_Vertex& v = TopoDS::Vertex(V);
1175 Standard_Real p = P;
1176 TopLoc_Location loc; Standard_Real f,l;
1177 Handle(Geom_Curve) C = BRep_Tool::Curve(e,loc,f,l);
1178 if ( !C.IsNull() && C->IsPeriodic()) {
1179 Standard_Real per = C->Period();
1181 TopAbs_Orientation oV=TopAbs_FORWARD;
1183 TopExp_Explorer exV(e,TopAbs_VERTEX);
1184 for (; exV.More(); exV.Next()) {
1185 const TopoDS_Vertex& vofe = TopoDS::Vertex(exV.Current());
1186 if ( vofe.IsSame(v) ) {
1187 oV = vofe.Orientation();
1192 if ( oV == TopAbs_REVERSED ) {
1194 Standard_Real pp = ElCLib::InPeriod(p,f,f+per);
1200 BB.UpdateVertex(v,p,e,0);
1203 // ----------------------------------------------------------------------
1204 Standard_EXPORT Standard_Boolean FUN_tool_MakeWire(const TopTools_ListOfShape& loE,TopoDS_Wire& newW)
1209 TopTools_ListIteratorOfListOfShape itloE(loE);
1210 for (; itloE.More(); itloE.Next()) {
1211 const TopoDS_Edge& E = TopoDS::Edge(itloE.Value());
1214 return Standard_True;
1217 // ----------------------------------------------------------------------
1218 Standard_EXPORT Standard_Boolean FUN_tool_getEclo(const TopoDS_Face& F, const Standard_Boolean UISO, TopoDS_Edge& Eclo)
1219 // purpose : get first edge Eclo / Eclo is uiso
1220 // F has closing edge Eclo
1222 TopExp_Explorer ex(F, TopAbs_EDGE);
1223 for (; ex.More(); ex.Next()){
1224 const TopoDS_Edge& E = TopoDS::Edge(ex.Current());
1225 Standard_Boolean clo = BRep_Tool::IsClosed(E,F);
1227 Standard_Boolean isou,isov; gp_Pnt2d o2d; gp_Dir2d d2d;
1228 Standard_Real f,l,tol; Handle(Geom2d_Curve) PC = FC2D_CurveOnSurface(E,F,f,l,tol);
1229 TopOpeBRepTool_TOOL::UVISO(PC,isou,isov,d2d,o2d);
1232 return Standard_True;
1236 return Standard_False;