0031007: Coding - eliminate warnings issued while compiling with -pedantic flag
[occt.git] / src / TopOpeBRepTool / TopOpeBRepTool_TOPOLOGY.cxx
1 // Created on: 1998-10-06
2 // Created by: Jean Yves LEBEY
3 // Copyright (c) 1998-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 #include <Geom_Curve.hxx>
18 #include <Geom_TrimmedCurve.hxx>
19 #include <Geom_Surface.hxx>
20 #include <GeomAdaptor_Surface.hxx>
21 #include <Bnd_Box2d.hxx>
22 #include <Bnd_Box.hxx>
23 #include <BRepBndLib.hxx>
24 #include <BndLib_Add2dCurve.hxx>
25 #include <BRepAdaptor_Surface.hxx>
26 #include <gp_Pnt2d.hxx>
27 #include <gp_Pnt.hxx>
28 #include <gp_Dir.hxx>
29 #include <gp_Dir2d.hxx>
30 #include <gp_Vec.hxx>
31 #include <gp_Pln.hxx>
32 #include <gp_Cylinder.hxx>
33 #include <gp_Cone.hxx>
34 #include <gp_Sphere.hxx>
35 #include <gp_Torus.hxx>
36 #include <TopExp.hxx>
37 #include <TopExp_Explorer.hxx>
38 #include <TopoDS.hxx>
39 #include <TopoDS_Wire.hxx>
40 #include <BRep_Tool.hxx>
41 #include <BRep_Builder.hxx>
42 #include <ElCLib.hxx>
43 #include <Precision.hxx>
44 #include <TColStd_Array1OfReal.hxx>
45 #include <TopOpeBRepTool_CurveTool.hxx>
46 #include <TopOpeBRepTool_ShapeTool.hxx>
47 #include <TopOpeBRepTool_2d.hxx>
48
49 #include <TopOpeBRepTool_GEOMETRY.hxx>
50 #include <TopOpeBRepTool_PROJECT.hxx>
51 #include <TopOpeBRepTool_TOPOLOGY.hxx>
52 #include <TopOpeBRepTool_TOOL.hxx>
53
54 //---------------------------------------------
55 #define  M_FORWARD(ori) (ori == TopAbs_FORWARD) 
56 #define M_REVERSED(ori) (ori == TopAbs_REVERSED) 
57 #define M_INTERNAL(ori) (ori == TopAbs_INTERNAL) 
58 #define M_EXTERNAL(ori) (ori == TopAbs_EXTERNAL) 
59 // ----------------------------------------------------------------------
60
61 // ----------------------------------------------------------------------
62 Standard_EXPORT void FUN_tool_tolUV(const TopoDS_Face& F,Standard_Real& tolu,Standard_Real& tolv)
63 {
64   Standard_Real tolF = BRep_Tool::Tolerance(TopoDS::Face(F));
65   BRepAdaptor_Surface BS(TopoDS::Face(F));
66   tolu = BS.UResolution(tolF);
67   tolv = BS.VResolution(tolF); 
68 }
69
70 // ----------------------------------------------------------------------
71 Standard_EXPORT Standard_Boolean FUN_tool_direct(const TopoDS_Face& F,Standard_Boolean& direct)
72 {
73   BRepAdaptor_Surface BS(TopoDS::Face(F));
74   GeomAbs_SurfaceType ST = BS.GetType();
75   Standard_Boolean plane = (ST == GeomAbs_Plane);
76   Standard_Boolean cyl   = (ST == GeomAbs_Cylinder);
77   Standard_Boolean cone  = (ST == GeomAbs_Cone);
78   Standard_Boolean sphe  = (ST == GeomAbs_Sphere);
79   Standard_Boolean torus  = (ST == GeomAbs_Torus);
80   if (plane) {const gp_Pln& plpl = BS.Plane(); direct = plpl.Direct();}
81   if (cyl)   {const gp_Cylinder& cycy = BS.Cylinder(); direct = cycy.Direct();}
82   if (cone)  {const gp_Cone& coco = BS.Cone(); direct = coco.Direct();}
83   if (sphe)  {const gp_Sphere& spsp = BS.Sphere(); direct = spsp.Direct();}
84   if (torus) {const gp_Torus& toto = BS.Torus(); direct = toto.Direct();}  
85   Standard_Boolean ok = plane || cyl || cone || sphe || torus;
86   return ok;
87 }
88
89 /*// ----------------------------------------------------------------------
90 Standard_EXPORT Standard_Boolean FUN_tool_IsUViso(const TopoDS_Shape& E,const TopoDS_Shape& F,
91                                      Standard_Boolean& isoU,Standard_Boolean& isoV,
92                                      gp_Dir2d& d2d,gp_Pnt2d& o2d)
93 {
94   isoU = isoV = Standard_False; Standard_Real f,l,tol; 
95   Handle(Geom2d_Curve) PC = 
96     FC2D_CurveOnSurface(TopoDS::Edge(E),TopoDS::Face(F),f,l,tol);
97   if (PC.IsNull()) return Standard_False;
98   Standard_Boolean iso = FUN_tool_IsUViso(PC,isoU,isoV,d2d,o2d);
99   return iso;
100 }*/
101
102 // ----------------------------------------------------------------------
103 Standard_EXPORT Standard_Boolean FUN_tool_geombounds(const TopoDS_Face& F,
104                                         Standard_Real& u1,Standard_Real& u2,Standard_Real& v1,Standard_Real& v2)
105 {
106   const Handle(Geom_Surface)& S = BRep_Tool::Surface(F);
107   if (S.IsNull()) return Standard_False;
108   S->Bounds(u1,u2,v1,v2);
109   return Standard_True;
110 }
111
112 // ----------------------------------------------------------------------
113 Standard_EXPORT Standard_Boolean FUN_tool_bounds(const TopoDS_Shape& Sh,
114                                                  Standard_Real& u1,
115                                                  Standard_Real& u2,
116                                                  Standard_Real& v1,
117 //                                               Standard_Real& v2)
118                                                  Standard_Real& )
119 {
120   Bnd_Box2d B2d;
121   const TopoDS_Face& F = TopoDS::Face(Sh);
122   TopExp_Explorer ex(F,TopAbs_WIRE);
123   for (; ex.More(); ex.Next()){
124     const TopoDS_Wire W = TopoDS::Wire(ex.Current());
125     Bnd_Box2d newB2d; FUN_tool_mkBnd2d(W,F,newB2d);
126     B2d.Add(newB2d);
127   }
128   B2d.Get(u1,v1,u2,v1);
129   return Standard_True;
130 }
131
132 // ----------------------------------------------------------------------
133 Standard_EXPORT Standard_Boolean FUN_tool_isobounds(const TopoDS_Shape& Sh,
134                                        Standard_Real& u1,Standard_Real& u2,Standard_Real& v1,Standard_Real& v2)
135 {
136   const TopoDS_Face& F = TopoDS::Face(Sh);
137   u1 = v1 = 1.e7;  u2 = v2 = -1.e7;
138
139   const Handle(Geom_Surface)& S = BRep_Tool::Surface(F);
140   if (S.IsNull()) return Standard_False;
141
142   Standard_Boolean uclosed,vclosed; Standard_Real uperiod,vperiod; 
143
144 //  Standard_Boolean uvclosed =
145
146   FUN_tool_closedS(F,uclosed,uperiod,vclosed,vperiod);
147
148 //  Standard_Real uf,ul,vf,vl; S->Bounds(uf,ul,vf,vl);
149
150 //  if (!uvclosed) {
151 //    u1 = uf; v1 = vf; u2 = ul; v2 = vl;
152 //    return Standard_True;
153 //  }
154   TopExp_Explorer ex(F,TopAbs_EDGE);
155   for (; ex.More(); ex.Next()){
156     const TopoDS_Edge& E = TopoDS::Edge(ex.Current());
157     Standard_Real f,l,tol; Handle(Geom2d_Curve) PC = FC2D_CurveOnSurface(E,F,f,l,tol);
158     if (PC.IsNull()) return Standard_False;
159     
160     Standard_Boolean isou,isov; gp_Pnt2d o2d; gp_Dir2d d2d;
161     Standard_Boolean isouv = TopOpeBRepTool_TOOL::UVISO(PC,isou,isov,d2d,o2d);
162
163     if (isouv) {
164       gp_Pnt2d p2df = PC->Value(f); gp_Pnt2d p2dl = PC->Value(l);
165       u1 = Min(p2df.X(),u1); u2 = Max(p2df.X(),u2); v1 = Min(p2df.Y(),v1); v2 = Max(p2df.Y(),v2); 
166       u1 = Min(p2dl.X(),u1); u2 = Max(p2dl.X(),u2); v1 = Min(p2dl.Y(),v1); v2 = Max(p2dl.Y(),v2); 
167     }
168     if (!isouv) return Standard_False;
169     // ====================
170   }
171   return Standard_True;
172 }
173
174 // ----------------------------------------------------------------------
175 Standard_EXPORT Standard_Boolean FUN_tool_outbounds(const TopoDS_Shape& Sh,
176                                        Standard_Real& u1,Standard_Real& u2,Standard_Real& v1,Standard_Real& v2,Standard_Boolean& outbounds)
177 {
178   Handle(Geom_Surface) S = TopOpeBRepTool_ShapeTool::BASISSURFACE(TopoDS::Face(Sh));
179   if (S.IsNull()) return Standard_False;
180   Standard_Real uf,ul,vf,vl; S->Bounds(uf,ul,vf,vl);
181
182   outbounds = Standard_False;
183   Standard_Boolean ok = FUN_tool_bounds(Sh,u1,u2,v1,v2);
184   if (!ok) return Standard_False;
185
186   const TopoDS_Face& F = TopoDS::Face(Sh);
187   Standard_Boolean uclosed,vclosed; Standard_Real uperiod,vperiod; 
188   FUN_tool_closedS(F,uclosed,uperiod,vclosed,vperiod);
189   Standard_Real tolp = 1.e-6;
190   
191   if (uclosed) {
192     Standard_Real dd = u2-u1;
193     if (dd > uperiod + tolp) {u1 = uf; v1 = vf; u2 = ul; v2 = vl; outbounds=Standard_True;}
194   }
195   if (vclosed) {
196     Standard_Real dd = v2-v1;
197     if (dd > vperiod + tolp) {u1 = uf; v1 = vf; u2 = ul; v2 = vl; outbounds=Standard_True;}
198   }
199   return Standard_True;
200 }
201
202 // ----------------------------------------------------------------------
203 Standard_EXPORT Standard_Boolean FUN_tool_PinC(const gp_Pnt& P,
204                                   const BRepAdaptor_Curve& BAC,
205                                   const Standard_Real pmin,const Standard_Real pmax,
206                                   const Standard_Real tol)
207 {
208   // returns true if <P> is on <C> under a given tolerance <tol>
209   Standard_Boolean PinC = Standard_False; 
210   Extrema_ExtPC ponc(P,BAC,pmin,pmax);
211   Standard_Boolean ok = ponc.IsDone();
212   if ( ok ) {
213     if ( ponc.NbExt() ) {
214       Standard_Integer i = FUN_tool_getindex(ponc);
215       Standard_Real d2 = ponc.SquareDistance(i);
216       PinC = (d2 <= tol * tol);
217     }
218   }
219   return PinC;
220 }
221
222 // ----------------------------------------------------------------------
223 Standard_EXPORT Standard_Boolean FUN_tool_PinC(const gp_Pnt& P,
224                                   const BRepAdaptor_Curve& BAC,
225                                   const Standard_Real tol)
226 {
227   // returns true if <P> is on <C> under a given tolerance <tol>
228   Standard_Boolean PinC = Standard_False;
229   Standard_Real pmin = BAC.FirstParameter();
230   Standard_Real pmax = BAC.LastParameter();
231   PinC = FUN_tool_PinC(P,BAC,pmin,pmax,tol);
232   return PinC;
233 }
234
235 // ----------------------------------------------------------------------
236 Standard_EXPORT Standard_Boolean FUN_tool_value(const Standard_Real par,const TopoDS_Edge& E,gp_Pnt& P)
237 {
238   BRepAdaptor_Curve BAC(E);
239   Standard_Real f = BAC.FirstParameter();
240   Standard_Real l = BAC.LastParameter();
241   Standard_Boolean ok = (f <= par) && (par <= l);
242   if (!ok) return Standard_False;
243   P = BAC.Value(par);
244   return Standard_True;
245 }
246
247 // ----------------------------------------------------------------------
248 Standard_EXPORT Standard_Boolean FUN_tool_value(const gp_Pnt2d& UV,const TopoDS_Face& F,gp_Pnt& P)
249 {
250   BRepAdaptor_Surface BS(F);
251   P = BS.Value(UV.X(),UV.Y());
252   return Standard_True;
253 }
254
255 // ----------------------------------------------------------------------
256 Standard_EXPORT TopAbs_State FUN_tool_staPinE(const gp_Pnt& P,const TopoDS_Edge& E,const Standard_Real tol)
257 {
258   // project point on curve,
259   // if projection fails,returns UNKNOWN.
260   // finds a point <pnear> on edge <E> / d(<pnear>,<P>) < tol
261   //   => returns IN
262   // else,returns OUT.
263   TopAbs_State sta = TopAbs_UNKNOWN;
264   BRepAdaptor_Curve BAC(E);
265   Extrema_ExtPC ProjonBAC(P,BAC);
266   if (ProjonBAC.IsDone() && ProjonBAC.NbExt()>0) {
267     Standard_Integer i = FUN_tool_getindex(ProjonBAC);
268     gp_Pnt Pnear = ProjonBAC.Point(i).Value();
269     Standard_Real d = Pnear.Distance(P);
270     sta = (d < tol)? TopAbs_IN: TopAbs_OUT;
271   }
272   return sta;
273 }
274 // ----------------------------------------------------------------------
275 Standard_EXPORT TopAbs_State FUN_tool_staPinE(const gp_Pnt& P,const TopoDS_Edge& E)
276 {
277 //  Standard_Real tol = Precision::Confusion()*10.;
278   Standard_Real tol3d = BRep_Tool::Tolerance(E)*1.e2;//KKKKK a revoir xpu(CTS21118,f14ou,GI13)
279   TopAbs_State sta = FUN_tool_staPinE(P,E,tol3d);
280   return sta;
281 }
282
283 // ----------------------------------------------------------------------
284 //  subshape's orientation :
285 //    - vertex orientation in edge 
286 //    - edge's orientation in face.Oriented(FORWARD)
287 // ----------------------------------------------------------------------
288
289 #define FIRST   (1)
290 #define LAST    (2)
291 #define CLOSING (3)
292
293 // ----------------------------------------------------------------------
294 Standard_EXPORT Standard_Integer FUN_tool_orientVinE(const TopoDS_Vertex& v,const TopoDS_Edge& e)
295 {
296   Standard_Integer result = 0;
297   TopoDS_Vertex vf,vl; TopExp::Vertices(e,vf,vl);
298   Standard_Boolean visf = v.IsSame(vf);
299   Standard_Boolean visl = v.IsSame(vl);
300   if (visf) result = FIRST;
301   if (visl) result = LAST;
302   if (visf && visl) result = CLOSING;
303   return result;
304 }
305
306 // ----------------------------------------------------------------------
307 Standard_EXPORT Standard_Boolean FUN_tool_orientEinF(const TopoDS_Edge& E,const TopoDS_Face& F,TopAbs_Orientation& oriEinF)
308 {
309   oriEinF = TopAbs_FORWARD;
310   TopExp_Explorer e(F,TopAbs_EDGE);
311   for (;e.More();e.Next()) {
312     const TopoDS_Shape& EF = e.Current(); 
313     if (EF.IsSame(E)) { 
314       oriEinF=EF.Orientation();
315       break;
316     }
317   }
318   Standard_Boolean ok=e.More();
319   return ok;
320 }
321
322 // ----------------------------------------------------------------------
323 Standard_EXPORT Standard_Boolean FUN_tool_orientEinFFORWARD(const TopoDS_Edge& E,const TopoDS_Face& F,TopAbs_Orientation& oriEinF)
324 {
325   // <oriEinF> : dummy for closing edge <E> of <F>.
326   // returns false if <E> is not bound of <F>
327   // else,<oriEinF> = orientation of the edge in <F> oriented FORWARD.
328   TopoDS_Shape aLocalShape = F.Oriented(TopAbs_FORWARD);
329   TopoDS_Face FF = TopoDS::Face(aLocalShape);
330 //  TopoDS_Face FF = TopoDS::Face(F.Oriented(TopAbs_FORWARD));
331   oriEinF = TopAbs_EXTERNAL;
332   TopAbs_Orientation reso; Standard_Boolean ok = ::FUN_tool_orientEinF(E,FF,reso);
333   if (ok) oriEinF = reso;
334   return ok;
335 }
336
337 // ----------------------------------------------------------------------
338 Standard_EXPORT Standard_Boolean FUN_tool_EboundF(const TopoDS_Edge& E,const TopoDS_Face& F)
339 {
340   TopAbs_Orientation ori; Standard_Boolean ok = FUN_tool_orientEinFFORWARD(E,F,ori);
341   if (!ok) return Standard_False;
342   Standard_Boolean closingE = BRep_Tool::IsClosed(E,F);
343   if (closingE) return Standard_True;
344   Standard_Boolean notbound = (ori == TopAbs_INTERNAL) || (ori == TopAbs_EXTERNAL);
345   return notbound;
346 }
347
348 // ----------------------------------------------------------------------
349 Standard_EXPORT gp_Vec FUN_tool_nggeomF(const gp_Pnt2d& p2d,const TopoDS_Face& F)
350 {
351   Handle(Geom_Surface) S = BRep_Tool::Surface(F);
352   gp_Vec ngF(FUN_tool_ngS(p2d,S));
353   return ngF;
354 }
355
356 // ----------------------------------------------------------------------
357 Standard_EXPORT Standard_Boolean FUN_tool_nggeomF(const Standard_Real& paronE,const TopoDS_Edge& E,const TopoDS_Face& F,
358                                      gp_Vec& nggeomF,const Standard_Real tol)
359 {
360   // <p2d> :
361   Standard_Real f,l; gp_Pnt2d p2d;
362   Standard_Boolean project = Standard_True;
363   TopAbs_Orientation oef; 
364   Standard_Boolean edonfa = FUN_tool_orientEinFFORWARD(E,F,oef);
365   if (edonfa) {
366     Standard_Real ttol; 
367     Handle(Geom2d_Curve) c2d = FC2D_CurveOnSurface(E,F,f,l,ttol);
368     project = c2d.IsNull();
369     if (!project) 
370       p2d = c2d->Value(paronE);
371   } 
372   if (project) {
373     BRepAdaptor_Curve BC(E);
374     gp_Pnt p3d = BC.Value(paronE);
375     Standard_Real d;  Standard_Boolean ok = FUN_tool_projPonF(p3d,F,p2d,d);
376
377     //modified by NIZHNY-MZV  Wed Dec  1 13:55:08 1999
378     //if !ok try to compute new pcurve 
379     if(!ok) {
380       Standard_Real ttol; 
381       Handle(Geom2d_Curve) c2d = FC2D_CurveOnSurface(E,F,f,l,ttol);
382       ok = !c2d.IsNull();
383       if (ok) 
384         p2d = c2d->Value(paronE);
385     }
386     if (!ok) return Standard_False;
387     //modified by NIZHNY-MZV  Wed Dec  1 13:56:14 1999
388     //xpu010698
389     gp_Pnt p3duv; FUN_tool_value(p2d,F,p3duv);
390     Standard_Real dd = p3duv.Distance(p3d);
391     if (dd > tol) return Standard_False;
392     //xpu010698
393   }  
394   nggeomF = FUN_tool_nggeomF(p2d,F);
395   return Standard_True;
396 }
397
398 // ----------------------------------------------------------------------
399 Standard_EXPORT Standard_Boolean FUN_tool_nggeomF(const Standard_Real& paronE,const TopoDS_Edge& E,const TopoDS_Face& F,
400                                      gp_Vec& nggeomF)
401 {
402   Standard_Real tol3d = BRep_Tool::Tolerance(F);
403   tol3d *= 1.e2;
404   Standard_Boolean ok = FUN_tool_nggeomF(paronE,E,F,nggeomF,tol3d);
405   return ok;
406 }
407
408 // ----------------------------------------------------------------------
409 Standard_EXPORT Standard_Boolean FUN_tool_EtgF(const Standard_Real& paronE,const TopoDS_Edge& E,
410                                   const gp_Pnt2d& p2d,const TopoDS_Face& F,
411                                   const Standard_Real tola)
412 {
413   gp_Vec tgE; Standard_Boolean ok = TopOpeBRepTool_TOOL::TggeomE(paronE,E,tgE);
414   if (!ok) return Standard_False;//NYIRAISE
415
416   gp_Vec ngF = FUN_tool_nggeomF(p2d,F);
417   Standard_Real prod = tgE.Dot(ngF);
418   Standard_Boolean tgt = Abs(prod) < tola;
419   return tgt;
420 }
421
422 // ----------------------------------------------------------------------
423 Standard_EXPORT Standard_Boolean FUN_tool_EtgOOE(const Standard_Real& paronE,const TopoDS_Edge& E,
424                                     const Standard_Real& paronOOE,const TopoDS_Edge& OOE,
425                                     const Standard_Real  tola)
426 {
427   gp_Vec tgOOE; Standard_Boolean ok = TopOpeBRepTool_TOOL::TggeomE(paronOOE,OOE,tgOOE);
428   if (!ok) return Standard_False;//NYIRAISE
429   gp_Vec tgE;       ok = TopOpeBRepTool_TOOL::TggeomE(paronE,E,tgE);
430   if (!ok) return Standard_False;//NYIRAISE
431   Standard_Real prod = tgOOE.Dot(tgE);
432   Standard_Boolean tg = (Abs(1- Abs(prod)) < tola);
433   return tg;
434 }
435
436 // ----------------------------------------------------------------------
437 Standard_EXPORT Standard_Boolean FUN_nearestISO(const TopoDS_Face& F,const Standard_Real xpar,const Standard_Boolean isoU,Standard_Real& xinf,Standard_Real& xsup)
438 {  
439   // IMPORTANT : xinf=xf,xsup=xl are INITIALIZED with first and last x 
440   //             parameters of F (x = u,v )
441   // purpose : finding greater xinf : xinf <= xpar
442   //                   smaller xsup :        xpar <=xsup
443   Standard_Real tol2d = 1.e-6;
444   Standard_Real df = xpar-xinf; Standard_Boolean onf = (Abs(df)<tol2d);
445   Standard_Real dl = xpar-xsup; Standard_Boolean onl = (Abs(dl)<tol2d);
446   if (onf || onl) return Standard_True;
447
448   Standard_Boolean isoV = !isoU;
449   TopExp_Explorer ex(F,TopAbs_EDGE);
450   for (; ex.More(); ex.Next()){
451     const TopoDS_Edge& E = TopoDS::Edge(ex.Current());
452     Standard_Boolean isou,isov; gp_Pnt2d o2d; gp_Dir2d d2d;
453     Standard_Boolean isouv = TopOpeBRepTool_TOOL::UVISO(E,F,isou,isov,d2d,o2d);
454     if (!isouv) return Standard_False;
455     
456     Standard_Boolean compare = (isoU && isou) || (isoV && isov);
457     if (!compare) return Standard_False;
458     Standard_Real xvalue = isou ? o2d.X() : o2d.Y(); 
459
460     if (xvalue < xpar) 
461       if (xinf < xvalue) xinf = xvalue;
462     if (xpar < xvalue)
463       if (xvalue < xsup) xsup = xvalue;
464   }
465   return Standard_True;
466 }
467
468 // ----------------------------------------------------------------------
469 Standard_EXPORT Standard_Boolean FUN_tool_EitangenttoFe(const gp_Dir& ngFe,const TopoDS_Edge& Ei,
470                                            const Standard_Real parOnEi)
471 {
472   // returns true if <Ei> is tangent to Fe at point
473   // p3d of param <parOnEi>,<ngFe> is normal to Fe at p3d.    
474   gp_Vec tgEi; Standard_Boolean ok = TopOpeBRepTool_TOOL::TggeomE(parOnEi,Ei,tgEi);  
475   if (!ok) return Standard_False;//NYIRAISE
476
477   Standard_Real prod = ngFe.Dot(tgEi);
478   Standard_Real tol = Precision::Parametric(Precision::Confusion());
479   Standard_Boolean tangent = (Abs(prod) <= tol);
480   return tangent;
481 }
482
483 // ----------------------------------------------------------------------
484 Standard_EXPORT GeomAbs_CurveType FUN_tool_typ(const TopoDS_Edge& E)
485 {
486   BRepAdaptor_Curve BC(E); 
487   GeomAbs_CurveType typ = BC.GetType();
488   return typ;
489 }
490
491 // ----------------------------------------------------------------------
492 Standard_EXPORT Standard_Boolean FUN_tool_line(const TopoDS_Edge& E)
493 {
494   BRepAdaptor_Curve BC(E);
495   Standard_Boolean line = (BC.GetType() == GeomAbs_Line);
496   return line;
497 }
498
499 // ----------------------------------------------------------------------
500 Standard_EXPORT Standard_Boolean FUN_tool_plane(const TopoDS_Shape& F)
501 {
502   Handle(Geom_Surface) S = TopOpeBRepTool_ShapeTool::BASISSURFACE(TopoDS::Face(F));
503   GeomAdaptor_Surface GS(S);
504   return (GS.GetType() == GeomAbs_Plane);
505 }
506
507 // ----------------------------------------------------------------------
508 Standard_EXPORT Standard_Boolean FUN_tool_cylinder(const TopoDS_Shape& F)
509 {
510   Handle(Geom_Surface) S = TopOpeBRepTool_ShapeTool::BASISSURFACE(TopoDS::Face(F));
511   GeomAdaptor_Surface GS(S);
512   return (GS.GetType() == GeomAbs_Cylinder);
513 }
514
515 // ----------------------------------------------------------------------
516 Standard_EXPORT Standard_Boolean FUN_tool_closedS(const TopoDS_Shape& F,
517                                      Standard_Boolean& uclosed,Standard_Real& uperiod,
518                                      Standard_Boolean& vclosed,Standard_Real& vperiod)
519 {
520 //  const Handle(Geom_Surface)& S = BRep_Tool::Surface(TopoDS::Face(F));
521   Handle(Geom_Surface) S =TopOpeBRepTool_ShapeTool::BASISSURFACE(TopoDS::Face(F));
522   if (S.IsNull()) return Standard_False;
523   Standard_Boolean closed = FUN_tool_closed(S,uclosed,uperiod,vclosed,vperiod);
524   return closed;
525 }
526
527 // ----------------------------------------------------------------------
528 Standard_EXPORT Standard_Boolean FUN_tool_closedS(const TopoDS_Shape& F)
529 {
530   Standard_Boolean uclosed=Standard_False,vclosed=Standard_False; Standard_Real uperiod=0.,vperiod=0.;
531   Standard_Boolean closed = FUN_tool_closedS(F,uclosed,uperiod,vclosed,vperiod);
532   return closed;
533 }
534
535 // ----------------------------------------------------------------------
536 Standard_EXPORT Standard_Boolean FUN_tool_closedS(const TopoDS_Shape& F, 
537                                      Standard_Boolean& inU, Standard_Real& xmin, Standard_Real& xper)
538 {
539   Standard_Boolean uclosed,vclosed; Standard_Real uperiod,vperiod; 
540   Handle(Geom_Surface) S =TopOpeBRepTool_ShapeTool::BASISSURFACE(TopoDS::Face(F));
541   if (S.IsNull()) return Standard_False;
542   Standard_Boolean closed = FUN_tool_closed(S,uclosed,uperiod,vclosed,vperiod);
543   if (!closed) return Standard_False;
544   Standard_Real u1,u2,v1,v2; S->Bounds(u1,u2,v1,v2);
545
546   inU = uclosed;
547   xper = inU ? uperiod : vperiod;
548   xmin = inU ? u1 : v1;
549   return Standard_False ;
550 }
551 // ----------------------------------------------------------------------
552 Standard_EXPORT void FUN_tool_mkBnd2d(const TopoDS_Shape& W,const TopoDS_Shape& FF,Bnd_Box2d& B2d)
553 {
554   // greater <B> with <W>'s UV representation on <F>
555   Standard_Real tol = 1.e-8;
556   Bnd_Box2d newB2d;
557   TopExp_Explorer ex;
558   for (ex.Init(W,TopAbs_EDGE); ex.More(); ex.Next()) {
559 //  for (TopExp_Explorer ex(W,TopAbs_EDGE); ex.More(); ex.Next()) {
560     const TopoDS_Edge& E = TopoDS::Edge(ex.Current());
561     const TopoDS_Face& F = TopoDS::Face(FF);
562     Standard_Real f,l,tolpc; Handle(Geom2d_Curve) pc; 
563     Standard_Boolean haspc = FC2D_HasCurveOnSurface(E,F);
564     if (!haspc) { 
565       Standard_Real tolE = BRep_Tool::Tolerance(E); 
566       pc = FC2D_CurveOnSurface(E,F,f,l,tolpc);
567       Standard_Real newtol = Max(tolE,tolpc);
568       BRep_Builder BB; BB.UpdateEdge(E,pc,F,newtol); 
569     } 
570     BRepAdaptor_Curve2d BC2d(E,F); 
571     BndLib_Add2dCurve::Add(BC2d,tol,newB2d);
572   } //ex(W,EDGE)
573
574   FUN_tool_UpdateBnd2d(B2d,newB2d);
575 }
576
577 // ----------------------------------------------------------------------
578 //  closing topologies :
579 // ----------------------------------------------------------------------
580
581 // ----------------------------------------------------------------------
582 Standard_EXPORT Standard_Boolean FUN_tool_IsClosingE(const TopoDS_Edge& E,const TopoDS_Shape& S,const TopoDS_Face& F)
583 {   
584   Standard_Integer nbocc = 0;
585   TopExp_Explorer exp;
586   for (exp.Init(S,TopAbs_EDGE);exp.More();exp.Next()) 
587 //  for (TopExp_Explorer exp(S,TopAbs_EDGE);exp.More();exp.Next()) 
588     if (exp.Current().IsSame(E)) nbocc++;
589   if (nbocc != 2) return Standard_False;
590   return BRep_Tool::IsClosed(E,F);
591 }
592
593 // ----------------------------------------------------------------------
594 Standard_EXPORT Standard_Boolean FUN_tool_ClosingE(const TopoDS_Edge& E,const TopoDS_Wire& W,const TopoDS_Face& F)
595 {
596   Standard_Boolean clo = FUN_tool_IsClosingE(E,W,F); 
597   return clo;
598 }
599
600 /*// ----------------------------------------------------------------------
601 Standard_EXPORT Standard_Boolean FUN_tool_ClosedE(const TopoDS_Edge& E,TopoDS_Shape& vclosing)
602 {
603   // returns true if <E> has a closing vertex <vclosing>
604 //  return E.IsClosed();
605   Standard_Boolean isdgE = BRep_Tool::Degenerated(E);
606   if (isdgE) return Standard_False;
607
608   TopoDS_Shape vv; vclosing.Nullify();
609   TopExp_Explorer ex(E,TopAbs_VERTEX);
610   for (; ex.More(); ex.Next()) {
611     const TopoDS_Shape& v = ex.Current();
612     if (M_INTERNAL(v.Orientation())) continue;
613     if (vv.IsNull()) vv = v;
614     else if (v.IsSame(vv))
615       {vclosing = vv; return Standard_True;}
616   }
617   return Standard_False;
618 }*/
619
620 // ----------------------------------------------------------------------
621 //  shared topologies :
622 // ----------------------------------------------------------------------
623
624 // ----------------------------------------------------------------------
625 Standard_EXPORT Standard_Boolean FUN_tool_inS(const TopoDS_Shape& subshape,const TopoDS_Shape& shape)
626 {
627   TopAbs_ShapeEnum sstyp = subshape.ShapeType();
628   TopTools_IndexedMapOfShape M; TopExp::MapShapes(shape,sstyp,M);
629   Standard_Boolean isbound = M.Contains(subshape);
630   return isbound;
631 }
632
633 // ----------------------------------------------------------------------
634 Standard_EXPORT Standard_Boolean FUN_tool_Eshared(const TopoDS_Shape& v,const TopoDS_Shape& F1,const TopoDS_Shape& F2,
635                                      TopoDS_Shape& Eshared)
636 //purpose : finds out <Eshared> shared by <F1> and <F2>,
637 //          with <V> bound of <Eshared>
638 {
639   TopTools_ListOfShape e1s;
640   TopExp_Explorer ex(F1,TopAbs_EDGE);
641   for (; ex.More(); ex.Next()){
642     const TopoDS_Shape& e1 = ex.Current();
643     Standard_Boolean e1ok = Standard_False;
644     TopExp_Explorer exv(e1,TopAbs_VERTEX);
645     for (; exv.More(); exv.Next())
646       if (exv.Current().IsSame(v)) {e1ok = Standard_True; break;}
647     if (e1ok) e1s.Append(e1);
648   }
649   ex.Init(F2,TopAbs_EDGE);  
650   for (; ex.More(); ex.Next()){
651     const TopoDS_Shape& e2 = ex.Current();
652     TopTools_ListIteratorOfListOfShape it1(e1s);
653     for (; it1.More(); it1.Next())
654       if (it1.Value().IsSame(e2)) {Eshared = e2; return Standard_True;}
655   }
656   return Standard_False;
657 }
658
659 // ----------------------------------------------------------------------
660 Standard_EXPORT Standard_Boolean FUN_tool_parVonE(const TopoDS_Vertex& v,const TopoDS_Edge& E,Standard_Real& par) 
661 {
662   Standard_Real tol = Precision::Confusion();
663   Standard_Boolean isVofE = Standard_False;
664   TopExp_Explorer ex;
665   for (ex.Init(E,TopAbs_VERTEX); ex.More(); ex.Next()) {
666 //  for (TopExp_Explorer ex(E,TopAbs_VERTEX); ex.More(); ex.Next()) {
667     isVofE = ex.Current().IsSame(v);
668     if (isVofE) {
669       par = BRep_Tool::Parameter(TopoDS::Vertex(ex.Current()),E);
670       break; 
671     }
672   }
673   if (!isVofE) { 
674     gp_Pnt pt = BRep_Tool::Pnt(v);
675     // <v> can share same domain with a vertex of <E>
676     for (ex.Init(E,TopAbs_VERTEX); ex.More(); ex.Next()) {
677       const TopoDS_Vertex& vex = TopoDS::Vertex(ex.Current());
678       gp_Pnt ptex = BRep_Tool::Pnt(vex);
679       if (ptex.IsEqual(pt,tol)) {
680         par = BRep_Tool::Parameter(vex,E);
681         return Standard_True;
682       }
683     }
684
685 //    Standard_Real f,l; 
686     BRepAdaptor_Curve BAC(E);
687     Extrema_ExtPC pro(pt,BAC);
688     Standard_Boolean done = pro.IsDone() && (pro.NbExt() >0);
689     if (!done) return Standard_False;
690     Standard_Integer i = FUN_tool_getindex(pro);
691     par = pro.Point(i).Parameter();
692   }
693   return Standard_True;
694
695
696 // ----------------------------------------------------------------------
697 Standard_EXPORT Standard_Boolean FUN_tool_parE(const TopoDS_Edge& E0,const Standard_Real& par0,
698                                   const TopoDS_Edge& E,Standard_Real& par,const Standard_Real tol)
699 {
700   gp_Pnt P; Standard_Boolean ok = FUN_tool_value(par0,E0,P);
701   if (!ok) return Standard_False;
702
703   Standard_Real dist; ok = FUN_tool_projPonE(P,E,par,dist);
704   if (!ok) return Standard_False;
705
706   ok = (dist < tol);
707   return ok;
708 }
709 // ----------------------------------------------------------------------
710 Standard_EXPORT Standard_Boolean FUN_tool_parE(const TopoDS_Edge& E0,const Standard_Real& par0,
711                                   const TopoDS_Edge& E,Standard_Real& par)
712 // ? <par> :  P -> <par0> on <E0>,<par> on <E>
713 // prequesitory : point(par0 ,E0) is IN 1d(E)
714 {
715   Standard_Real tol3d = BRep_Tool::Tolerance(E)*1.e2;//KKKKK a revoir xpu(CTS21118,f14ou,GI13)
716   Standard_Boolean ok = FUN_tool_parE(E0,par0,E,par,tol3d);
717   return ok;
718 }
719
720 // ----------------------------------------------------------------------
721 Standard_EXPORT Standard_Boolean FUN_tool_parF(const TopoDS_Edge& E,const Standard_Real& par,
722                                   const TopoDS_Face& F,gp_Pnt2d& UV, const Standard_Real tol3d)
723 // ? <UV> : P -> <par> on <E>,<UV> on <F>
724 {
725   gp_Pnt P; Standard_Boolean ok = FUN_tool_value(par,E,P);
726   if (!ok) return Standard_False;
727  
728   Standard_Real dist; ok = FUN_tool_projPonF(P,F,UV,dist);
729   if (!ok) return Standard_False;
730
731   ok = (dist < tol3d);
732   return ok;
733 }
734 Standard_EXPORT Standard_Boolean FUN_tool_parF(const TopoDS_Edge& E,const Standard_Real& par,
735                                   const TopoDS_Face& F,gp_Pnt2d& UV)
736 {  
737   Standard_Real tol3d = BRep_Tool::Tolerance(F)*1.e2; //KK xpu
738   Standard_Boolean ok = FUN_tool_parF(E,par,F,UV,tol3d);
739   return ok;
740 }
741
742 // ----------------------------------------------------------------------
743 Standard_EXPORT Standard_Boolean FUN_tool_paronEF(const TopoDS_Edge& E,const Standard_Real& par,
744                                      const TopoDS_Face& F,gp_Pnt2d& UV, const Standard_Real tol3d)
745 // <E> is on <F> ? <UV> : P -> <par> on <E>,<UV> on <F>
746 {
747   Standard_Real f,l,tol; Handle(Geom2d_Curve) PC = FC2D_CurveOnSurface(E,F,f,l,tol);
748   if (PC.IsNull()) {
749     Standard_Boolean ok = FUN_tool_parF(E,par,F,UV,tol3d);
750     return ok;
751   }  
752   Standard_Boolean ok = (f <= par) && (par <= l);
753   if (!ok) return Standard_False;
754   UV = PC->Value(par);
755   return Standard_True;
756 }
757 Standard_EXPORT Standard_Boolean FUN_tool_paronEF(const TopoDS_Edge& E,const Standard_Real& par,
758                                      const TopoDS_Face& F,gp_Pnt2d& UV)
759 {
760   Standard_Real tol3d = BRep_Tool::Tolerance(F)*1.e2; // KKxpu
761   Standard_Boolean ok = FUN_tool_paronEF(E,par,F,UV,tol3d);
762   return ok;
763 }
764
765 // ----------------------------------------------------------------------
766 Standard_EXPORT gp_Dir FUN_tool_dirC(const Standard_Real par,const BRepAdaptor_Curve& BAC)
767 {
768   gp_Pnt p; gp_Vec tgE; BAC.D1(par,p,tgE); 
769   gp_Dir dirC(tgE);
770   return dirC;
771 }
772
773 // ----------------------------------------------------------------------
774 Standard_EXPORT gp_Vec FUN_tool_tggeomE(const Standard_Real paronE,const TopoDS_Edge& E)
775 {
776   Standard_Boolean isdgE = BRep_Tool::Degenerated(E); 
777   if (isdgE) return gp_Vec(0,0,0);
778   gp_Vec dirE(FUN_tool_dirC(paronE,E)); 
779   return dirE;
780 }
781
782 // ----------------------------------------------------------------------
783 Standard_EXPORT Standard_Boolean FUN_tool_line(const BRepAdaptor_Curve& BAC)
784 {
785   Standard_Boolean line = (BAC.GetType() == GeomAbs_Line);
786   return line;
787 }
788
789 // ----------------------------------------------------------------------
790 Standard_EXPORT Standard_Boolean FUN_tool_quad(const TopoDS_Edge& E)
791 {
792   BRepAdaptor_Curve BC(E);
793   GeomAbs_CurveType CT = BC.GetType();
794   Standard_Boolean quad = FUN_quadCT(CT);
795   return quad;
796 }
797
798 // ----------------------------------------------------------------------
799 Standard_EXPORT Standard_Boolean FUN_tool_quad(const BRepAdaptor_Curve& BAC)
800 {
801   GeomAbs_CurveType CT = BAC.GetType();
802   Standard_Boolean isquad = Standard_False;
803   if (CT == GeomAbs_Line) isquad = Standard_True;
804   if (CT == GeomAbs_Circle) isquad = Standard_True;
805   if (CT == GeomAbs_Ellipse) isquad = Standard_True;
806   if (CT == GeomAbs_Hyperbola) isquad = Standard_True;
807   if (CT == GeomAbs_Parabola) isquad = Standard_True;
808   return isquad;
809 }
810
811 // ----------------------------------------------------------------------
812 Standard_EXPORT Standard_Boolean FUN_tool_quad(const TopoDS_Face& F)
813 {
814   Handle(Geom_Surface) S = TopOpeBRepTool_ShapeTool::BASISSURFACE(F);
815   Standard_Boolean quad = FUN_tool_quad(S);
816   return quad;
817 }
818
819 // ----------------------------------------------------------------------
820 Standard_EXPORT Standard_Boolean FUN_tool_findPinBAC(const BRepAdaptor_Curve& BAC,gp_Pnt& P,Standard_Real& par)
821 {
822   FUN_tool_findparinBAC(BAC,par);
823   BAC.D0(par,P);
824   return Standard_True;
825 }
826
827 // ----------------------------------------------------------------------
828 Standard_EXPORT Standard_Boolean FUN_tool_findparinBAC(const BRepAdaptor_Curve& BAC,Standard_Real& par)
829 {
830   Standard_Real fE = BAC.FirstParameter(),lE = BAC.LastParameter();
831   Standard_Real t = 0.34567237; par = (1-t)*fE + t*lE;
832   return Standard_True;
833 }
834
835 // ----------------------------------------------------------------------
836 Standard_EXPORT Standard_Boolean FUN_tool_findparinE(const TopoDS_Shape& E,Standard_Real& par)
837
838   BRepAdaptor_Curve BAC(TopoDS::Edge(E)); 
839   Standard_Boolean r = FUN_tool_findparinBAC(BAC,par);
840   return r;
841 }
842
843 // ----------------------------------------------------------------------
844 Standard_EXPORT Standard_Boolean FUN_tool_findPinE(const TopoDS_Shape& E,gp_Pnt& P,Standard_Real& par)
845
846   BRepAdaptor_Curve BAC(TopoDS::Edge(E)); 
847   Standard_Boolean r = FUN_tool_findPinBAC(BAC,P,par);
848   return r;
849 }
850
851 // ----------------------------------------------------------------------
852 //  tolerances :
853 // ----------------------------------------------------------------------
854
855 // ----------------------------------------------------------------------
856 Standard_EXPORT Standard_Boolean FUN_tool_maxtol(const TopoDS_Shape& S,const TopAbs_ShapeEnum& typ,Standard_Real& maxtol)
857 // purpose : returns maxtol of <S>'s shapes of type <typ> 
858 {
859   Standard_Boolean face   = (typ == TopAbs_FACE);
860   Standard_Boolean edge   = (typ == TopAbs_EDGE);
861   Standard_Boolean vertex = (typ == TopAbs_VERTEX);
862   TopExp_Explorer ex(S,typ);
863   Standard_Boolean hasshatyp = ex.More();
864   for (; ex.More(); ex.Next()){
865     const TopoDS_Shape& ss = ex.Current();
866     Standard_Real tolss = 0.;
867     if (face)   tolss =  BRep_Tool::Tolerance(TopoDS::Face(ss));
868     if (edge)   tolss =  BRep_Tool::Tolerance(TopoDS::Edge(ss));
869     if (vertex) tolss =  BRep_Tool::Tolerance(TopoDS::Vertex(ss));
870     if (tolss > maxtol) maxtol = tolss;
871   }
872   return hasshatyp;
873 }
874
875 // ----------------------------------------------------------------------
876 Standard_EXPORT Standard_Real FUN_tool_maxtol(const TopoDS_Shape& S)
877 // purpose : returns maxtol between <S>'s shapes.
878 {
879   Standard_Real maxtol = 0.;
880   FUN_tool_maxtol(S,TopAbs_FACE,maxtol);
881   FUN_tool_maxtol(S,TopAbs_EDGE,maxtol);
882   FUN_tool_maxtol(S,TopAbs_VERTEX,maxtol);
883   return maxtol;
884 }
885
886 // ----------------------------------------------------------------------
887 Standard_EXPORT Standard_Integer FUN_tool_nbshapes(const TopoDS_Shape& S,const TopAbs_ShapeEnum& typ)
888 {
889   TopExp_Explorer ex(S,typ);
890   Standard_Integer i = 0;
891   for (; ex.More(); ex.Next()) i++;
892   return i; 
893 }
894
895 // ----------------------------------------------------------------------
896 Standard_EXPORT void FUN_tool_shapes(const TopoDS_Shape& S,const TopAbs_ShapeEnum& typ,
897                                      TopTools_ListOfShape& ltyp)
898 {
899   TopExp_Explorer ex(S,typ);
900   for (; ex.More(); ex.Next()) ltyp.Append(ex.Current());
901 }
902
903 // ----------------------------------------------------------------------
904 Standard_EXPORT Standard_Integer FUN_tool_comparebndkole(const TopoDS_Shape& sh1,const TopoDS_Shape& sh2)  
905 // purpose: comparing bounding boxes of <sh1> and <sh2>,
906 //          returns k =1,2 if shi is contained in shk
907 //          else returns 0
908 {
909   Bnd_Box bnd1; BRepBndLib::Add(sh1,bnd1); bnd1.SetGap(0.);
910   Bnd_Box bnd2; BRepBndLib::Add(sh2,bnd2); bnd2.SetGap(0.);
911
912   if(bnd1.IsOut(bnd2)) return 0;
913   TColStd_Array1OfReal xyz1(1,6),xyz2(1,6);
914   bnd1.Get(xyz1(1),xyz1(2),xyz1(3),xyz1(4),xyz1(5),xyz1(6)); 
915   bnd2.Get(xyz2(1),xyz2(2),xyz2(3),xyz2(4),xyz2(5),xyz2(6)); 
916   Standard_Real tol = Precision::Confusion();
917   
918   Standard_Integer neq,n2sup; neq=n2sup=0;
919 //  for (Standard_Integer i = 1; i<=3; i++) {
920   Standard_Integer i ;
921   for ( i = 1; i<=3; i++) {
922     Standard_Real d = xyz2(i)-xyz1(i);
923     Standard_Boolean eq = (Abs(d) < tol);
924     if (eq) {neq++; continue;}
925     if (d<0.) n2sup++;
926   }
927   for (i = 4; i<=6; i++) {
928     Standard_Real d = xyz2(i)-xyz1(i);
929     Standard_Boolean eq = (Abs(d) < tol);
930     if (eq) {neq++; continue;}
931     if (d>0.) n2sup++;
932   }  
933   if (n2sup + neq != 6) return 0;
934   if (neq == 6) return 0;
935
936   Standard_Integer ires = (n2sup > 0)? 2: 1;
937   return ires;
938 }
939
940 // ----------------------------------------------------------------------
941 Standard_EXPORT Standard_Boolean FUN_tool_SameOri(const TopoDS_Edge& E1,const TopoDS_Edge& E2)
942 //prequesitory : 1- <E1> and <E2> share same domain,
943 //               2- C3d<E1> contains C3d<E2>
944 {
945   Standard_Real f,l; FUN_tool_bounds(E2,f,l);  
946   Standard_Real x = 0.345;
947   Standard_Real mid = x*f + (1-x)*l;
948   gp_Pnt Pmid; FUN_tool_value(mid,E2,Pmid);
949   gp_Vec tmp; Standard_Boolean ok = TopOpeBRepTool_TOOL::TggeomE(mid,E2,tmp);
950   if (!ok) return Standard_False;
951   gp_Dir tgE2(tmp);
952   TopAbs_Orientation oriE2 = E2.Orientation();
953   if (M_REVERSED(oriE2)) tgE2.Reverse();
954
955   Standard_Real pE1,dist; ok = FUN_tool_projPonE(Pmid,E1,pE1,dist);
956   Standard_Real tol1 = BRep_Tool::Tolerance(E1); 
957   Standard_Real tol2 = BRep_Tool::Tolerance(E2); 
958   Standard_Real tol  = Max(tol1,tol2)* 10.;
959   if (dist > tol) return Standard_False;
960   if (!ok) return Standard_False;
961   ok = TopOpeBRepTool_TOOL::TggeomE(pE1,E1,tmp);
962   if (!ok) return Standard_False;
963   gp_Dir tgE1(tmp);
964   TopAbs_Orientation oriE1 = E1.Orientation();
965   if (M_REVERSED(oriE1)) tgE1.Reverse();
966   
967   Standard_Boolean sameori = (tgE2.Dot(tgE1) > 0.);
968   return sameori;
969 }
970
971 // ----------------------------------------------------------------------
972 Standard_EXPORT Standard_Boolean FUN_tool_haspc(const TopoDS_Edge& E,const TopoDS_Face& F)
973 {
974   Standard_Real f,l,tol; Handle(Geom2d_Curve) C2d =  FC2D_CurveOnSurface(E,F,f,l,tol);
975   Standard_Boolean null = C2d.IsNull();
976   return !null;
977 }
978
979 // ----------------------------------------------------------------------
980 Standard_EXPORT Standard_Boolean FUN_tool_pcurveonF(const TopoDS_Face& F,TopoDS_Edge& E)
981 {
982   Standard_Real f,l; Handle(Geom_Curve) C3d = BRep_Tool::Curve(E,f,l);
983   if (C3d.IsNull()) return Standard_False;   
984   Standard_Real tolReached2d;
985   Handle(Geom2d_Curve) C2d =
986     TopOpeBRepTool_CurveTool::MakePCurveOnFace(F,C3d,tolReached2d,f,l);
987   if (C2d.IsNull()) return Standard_False;
988
989   Standard_Real tolE = BRep_Tool::Tolerance(E);
990   BRep_Builder BB;
991   BB.UpdateEdge(E,C2d,F,tolE);
992   return Standard_True;
993 }
994
995 // ----------------------------------------------------------------------
996 Standard_EXPORT Standard_Boolean FUN_tool_pcurveonF(const TopoDS_Face& fF,TopoDS_Edge& faultyE,
997                                        const Handle(Geom2d_Curve)& C2d,
998                                        TopoDS_Face& newf)
999 {
1000   BRep_Builder BB;
1001   TopExp_Explorer exw(fF,TopAbs_WIRE);
1002   TopTools_ListOfShape low;
1003   Standard_Boolean hasnewf = Standard_False;
1004   for (; exw.More(); exw.Next()){
1005     const TopoDS_Shape& w = exw.Current();
1006     
1007     TopTools_ListOfShape loe; Standard_Boolean hasneww = Standard_False;
1008     TopExp_Explorer exe(w,TopAbs_EDGE);
1009     for (; exe.More(); exe.Next()){
1010       const TopoDS_Edge& e = TopoDS::Edge(exe.Current());
1011       Standard_Boolean equal = e.IsEqual(faultyE);
1012       if (!equal) {loe.Append(e); continue;}
1013       
1014       Standard_Real tole = BRep_Tool::Tolerance(e);
1015       TopoDS_Vertex vf,vl; TopExp::Vertices(e,vf,vl);
1016
1017       TopoDS_Edge newe = faultyE;
1018 //      TopoDS_Edge newe; FUN_ds_CopyEdge(e,newe); newe.Orientation(TopAbs_FORWARD);
1019 //      vf.Orientation(TopAbs_FORWARD);  BB.Add(newe,vf); FUN_ds_Parameter(newe,vf,parf); 
1020 //      vl.Orientation(TopAbs_REVERSED); BB.Add(newe,vl); FUN_ds_Parameter(newe,vl,parl);
1021       BB.UpdateEdge(newe,C2d,fF,tole);
1022       newe.Orientation(e.Orientation());
1023       loe.Append(newe);  
1024       hasneww = Standard_True;
1025       hasnewf = Standard_True;
1026     }
1027     if (hasneww) {
1028       TopoDS_Wire neww; Standard_Boolean ok = FUN_tool_MakeWire(loe,neww);
1029       if (!ok) return Standard_False;
1030       low.Append(neww);
1031     }
1032     else low.Append(w);
1033   } // exw
1034   if (hasnewf) {
1035     TopoDS_Shape aLocalShape = fF.EmptyCopied();
1036     newf = TopoDS::Face(aLocalShape);
1037 //    newf = TopoDS::Face(fF.EmptyCopied()); 
1038     for (TopTools_ListIteratorOfListOfShape itw(low); itw.More(); itw.Next()){
1039       const TopoDS_Shape w = itw.Value();
1040       BB.Add(newf,w);
1041     }
1042     return Standard_True;
1043   }
1044   return Standard_False;
1045 }
1046
1047 // ----------------------------------------------------------------------
1048 //  shared geometry :
1049 // ----------------------------------------------------------------------
1050
1051 // ----------------------------------------------------------------------
1052 Standard_EXPORT Standard_Boolean FUN_tool_curvesSO(const TopoDS_Edge& E1,const Standard_Real p1,const TopoDS_Edge& E2,const Standard_Real p2,
1053                                       Standard_Boolean& so)
1054 {
1055   BRepAdaptor_Curve BAC1(E1);
1056   BRepAdaptor_Curve BAC2(E2);
1057   gp_Vec tg1; Standard_Boolean ok = TopOpeBRepTool_TOOL::TggeomE(p1,E1,tg1);
1058   if (!ok) return Standard_False;//NYIRAISE
1059   gp_Vec tg2;     ok = TopOpeBRepTool_TOOL::TggeomE(p2,E2,tg2);
1060   if (!ok) return Standard_False;//NYIRAISE
1061   Standard_Real tola = Precision::Angular()*1.e3;
1062   Standard_Boolean oppo = tg1.IsOpposite(tg2,tola);
1063   Standard_Boolean samo = tg1.IsParallel(tg2,tola);
1064   if      (oppo) so = Standard_False;
1065   else if (samo) so = Standard_True;
1066   else return Standard_False;
1067   return Standard_True;
1068 }
1069 Standard_EXPORT Standard_Boolean FUN_tool_curvesSO(const TopoDS_Edge& E1,const Standard_Real p1,const TopoDS_Edge& E2,Standard_Boolean& so)
1070 {
1071   // prequesitory : P3d(E1,p1) is IN 1d(E2)
1072   Standard_Real p2 = 0.; Standard_Boolean ok = FUN_tool_parE(E1,p1,E2,p2);
1073   if (!ok) return Standard_False;
1074   ok = FUN_tool_curvesSO(E1,p1,E2,p2,so);
1075   return ok;
1076 }
1077
1078 // ----------------------------------------------------------------------
1079 Standard_EXPORT Standard_Boolean FUN_tool_curvesSO(const TopoDS_Edge& E1,const TopoDS_Edge& E2,Standard_Boolean& so)
1080 {
1081   // prequesitory : E1 is IN 1d(E2)
1082   TopoDS_Vertex vf1,vl1; TopExp::Vertices(E1,vf1,vl1);
1083   Standard_Boolean closed1 = vf1.IsSame(vl1);
1084   TopoDS_Vertex vf2,vl2; TopExp::Vertices(E2,vf2,vl2);
1085   Standard_Boolean closed2 = vf2.IsSame(vl2);
1086   Standard_Boolean project = Standard_False;
1087   if (closed1 || closed2) project = Standard_True;
1088   else {
1089     if      (vf1.IsSame(vf2)) so = Standard_True;
1090     else if (vl1.IsSame(vl2)) so = Standard_True;
1091     else if (vf1.IsSame(vl2)) so = Standard_False;
1092     else if (vl1.IsSame(vf2)) so = Standard_False;
1093     else project = Standard_True;      
1094   }
1095   if (project) {
1096     Standard_Real f,l; FUN_tool_bounds(E1,f,l);
1097     Standard_Real x = 0.45678; Standard_Real p1 = (1-x)*l + x*f;
1098     Standard_Boolean ok = FUN_tool_curvesSO(E1,p1,E2,so);
1099     return ok;
1100   }
1101   return Standard_True;
1102 }
1103
1104 // ----------------------------------------------------------------------
1105 Standard_EXPORT Standard_Boolean FUN_tool_findAncestor(const TopTools_ListOfShape& lF,const TopoDS_Edge& E,TopoDS_Face& Fanc)
1106 {
1107   TopTools_ListIteratorOfListOfShape it(lF);
1108   for (; it.More(); it.Next()){
1109     const TopoDS_Face& F = TopoDS::Face(it.Value());
1110     TopAbs_Orientation dummy; Standard_Boolean found = FUN_tool_orientEinF(E,F,dummy);
1111     if (found) {Fanc = F; return Standard_True;}
1112   }
1113   return Standard_False;
1114
1115
1116 // ----------------------------------------------------------------------
1117 //  new topologies : 
1118 // ----------------------------------------------------------------------
1119
1120 // FUN_ds_* methods are methods of TopOpeBRepDS_BuildTool
1121 // that cannot be called (cyclic dependencies)
1122
1123 // ----------------------------------------------------------------------
1124 Standard_EXPORT void FUN_ds_CopyEdge(const TopoDS_Shape& Ein,TopoDS_Shape& Eou)
1125 {
1126   Standard_Real f,l;
1127   TopoDS_Edge E1 = TopoDS::Edge(Ein); 
1128   BRep_Tool::Range(E1,f,l);
1129   Eou = Ein.EmptyCopied();
1130   TopoDS_Edge E2 = TopoDS::Edge(Eou); 
1131   BRep_Builder BB;
1132   BB.Range(E2,f,l);
1133 }
1134
1135 // ----------------------------------------------------------------------
1136 Standard_EXPORT void FUN_ds_Parameter(const TopoDS_Shape& E,const TopoDS_Shape& V,const Standard_Real P)
1137 {
1138   BRep_Builder BB;
1139   const TopoDS_Edge&   e = TopoDS::Edge(E);
1140   const TopoDS_Vertex& v = TopoDS::Vertex(V);
1141   Standard_Real p = P;
1142   TopLoc_Location loc; Standard_Real f,l;
1143   Handle(Geom_Curve) C = BRep_Tool::Curve(e,loc,f,l);
1144   if ( !C.IsNull() && C->IsPeriodic()) {
1145     Standard_Real per = C->Period();
1146
1147     TopAbs_Orientation oV=TopAbs_FORWARD;
1148
1149     TopExp_Explorer exV(e,TopAbs_VERTEX);
1150     for (; exV.More(); exV.Next()) {
1151       const TopoDS_Vertex& vofe = TopoDS::Vertex(exV.Current());
1152       if ( vofe.IsSame(v) ) {
1153         oV = vofe.Orientation();
1154         break;
1155       }
1156     }
1157     if ( exV.More() ) {
1158       if ( oV == TopAbs_REVERSED ) {
1159         if ( p < f ) {
1160           Standard_Real pp = ElCLib::InPeriod(p,f,f+per);
1161           p = pp;
1162         }
1163       }
1164     }
1165   }
1166   BB.UpdateVertex(v,p,e,0); 
1167 }
1168
1169 // ----------------------------------------------------------------------
1170 Standard_EXPORT Standard_Boolean FUN_tool_MakeWire(const TopTools_ListOfShape& loE,TopoDS_Wire& newW)
1171 {
1172   newW.Nullify();
1173   BRep_Builder BB; 
1174   BB.MakeWire(newW);
1175   TopTools_ListIteratorOfListOfShape itloE(loE);
1176   for (; itloE.More(); itloE.Next()) {
1177     const TopoDS_Edge& E = TopoDS::Edge(itloE.Value());
1178     BB.Add(newW,E);
1179   }
1180   return Standard_True;
1181 }
1182