0027568: Exception is thrown when a degenerated edge is added to a wire
[occt.git] / src / BRep / BRep_Tool.cxx
1 // Created on: 1993-07-07
2 // Created by: Remi LEQUETTE
3 // Copyright (c) 1993-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
18 #include <BRep_Curve3D.hxx>
19 #include <BRep_CurveOnClosedSurface.hxx>
20 #include <BRep_CurveOnSurface.hxx>
21 #include <BRep_CurveRepresentation.hxx>
22 #include <BRep_ListIteratorOfListOfCurveRepresentation.hxx>
23 #include <BRep_ListIteratorOfListOfPointRepresentation.hxx>
24 #include <BRep_PointRepresentation.hxx>
25 #include <BRep_Polygon3D.hxx>
26 #include <BRep_PolygonOnClosedSurface.hxx>
27 #include <BRep_PolygonOnClosedTriangulation.hxx>
28 #include <BRep_PolygonOnSurface.hxx>
29 #include <BRep_PolygonOnTriangulation.hxx>
30 #include <BRep_TEdge.hxx>
31 #include <BRep_TFace.hxx>
32 #include <BRep_Tool.hxx>
33 #include <BRep_TVertex.hxx>
34 #include <ElSLib.hxx>
35 #include <Geom2d_Curve.hxx>
36 #include <Geom2d_TrimmedCurve.hxx>
37 #include <Geom2dAdaptor.hxx>
38 #include <Geom_Curve.hxx>
39 #include <Geom_OffsetSurface.hxx>
40 #include <Geom_Plane.hxx>
41 #include <Geom_RectangularTrimmedSurface.hxx>
42 #include <Geom_Surface.hxx>
43 #include <Geom_TrimmedCurve.hxx>
44 #include <GeomAdaptor_HCurve.hxx>
45 #include <GeomAdaptor_HSurface.hxx>
46 #include <GeomProjLib.hxx>
47 #include <gp_Pnt.hxx>
48 #include <gp_Pnt2d.hxx>
49 #include <NCollection_IncAllocator.hxx>
50 #include <NCollection_Map.hxx>
51 #include <Poly_Polygon2D.hxx>
52 #include <Poly_Polygon3D.hxx>
53 #include <Poly_PolygonOnTriangulation.hxx>
54 #include <Poly_Triangulation.hxx>
55 #include <Precision.hxx>
56 #include <ProjLib_ProjectedCurve.hxx>
57 #include <Standard_NoSuchObject.hxx>
58 #include <Standard_NullObject.hxx>
59 #include <TopExp.hxx>
60 #include <TopExp_Explorer.hxx>
61 #include <TopLoc_Location.hxx>
62 #include <TopoDS.hxx>
63 #include <TopoDS_Edge.hxx>
64 #include <TopoDS_Face.hxx>
65 #include <TopoDS_Iterator.hxx>
66 #include <TopoDS_Shape.hxx>
67 #include <TopoDS_Vertex.hxx>
68 #include <TopoDS_Wire.hxx>
69 #include <TopTools_MapOfShape.hxx>
70 #include <TopTools_ShapeMapHasher.hxx>
71 #include <BRep_GCurve.hxx>
72
73 //modified by NIZNHY-PKV Fri Oct 17 14:13:29 2008f
74 static 
75   Standard_Boolean IsPlane(const Handle(Geom_Surface)& aS);
76 //modified by NIZNHY-PKV Fri Oct 17 14:13:33 2008t
77 //
78 //=======================================================================
79 //function : Surface
80 //purpose  : Returns the geometric surface of the face. Returns
81 //           in <L> the location for the surface.
82 //=======================================================================
83
84 const Handle(Geom_Surface)& BRep_Tool::Surface(const TopoDS_Face& F,
85                                                TopLoc_Location& L)
86 {
87   const BRep_TFace* TF = static_cast<const BRep_TFace*>(F.TShape().get());
88   L = F.Location() * TF->Location();
89   return TF->Surface();
90 }
91
92 //=======================================================================
93 //function : Surface
94 //purpose  : Returns the geometric  surface of the face. It can
95 //           be a copy if there is a Location.
96 //=======================================================================
97
98 Handle(Geom_Surface) BRep_Tool::Surface(const TopoDS_Face& F)
99 {
100   const BRep_TFace* TF = static_cast<const BRep_TFace*>(F.TShape().get());
101   const Handle(Geom_Surface)& S = TF->Surface();
102
103   if(S.IsNull()) return S;
104
105   TopLoc_Location L = F.Location() * TF->Location();
106   if (!L.IsIdentity()) {
107     Handle(Geom_Geometry) aCopy = S->Transformed(L.Transformation());
108     Geom_Surface* aGS = static_cast<Geom_Surface*>(aCopy.get());
109     return Handle(Geom_Surface)(aGS);
110   }
111   return S;
112 }
113
114 //=======================================================================
115 //function : Triangulation
116 //purpose  : Returns  the Triangulation of  the  face. It  is a
117 //           null handle if there is no triangulation.
118 //=======================================================================
119
120 const Handle(Poly_Triangulation)& BRep_Tool::Triangulation(const TopoDS_Face& F,
121                                                            TopLoc_Location&   L)
122 {
123   L = F.Location();
124   const BRep_TFace* TF = static_cast<const BRep_TFace*>(F.TShape().get());
125   return TF->Triangulation();
126 }
127
128 //=======================================================================
129 //function : Tolerance
130 //purpose  : Returns the tolerance of the face.
131 //=======================================================================
132
133 Standard_Real  BRep_Tool::Tolerance(const TopoDS_Face& F)
134 {
135   const BRep_TFace* TF = static_cast<const BRep_TFace*>(F.TShape().get());
136   Standard_Real p = TF->Tolerance();
137   Standard_Real pMin = Precision::Confusion();
138   if (p > pMin) return p;
139   else          return pMin;
140 }
141
142 //=======================================================================
143 //function : NaturalRestriction
144 //purpose  : Returns the  NaturalRestriction  flag of the  face.
145 //=======================================================================
146
147 Standard_Boolean  BRep_Tool::NaturalRestriction(const TopoDS_Face& F)
148 {
149   const BRep_TFace* TF = static_cast<const BRep_TFace*>(F.TShape().get());
150   return TF->NaturalRestriction();
151 }
152
153 //=======================================================================
154 //function : Curve
155 //purpose  : Returns the 3D curve  of the edge.  May be  a Null
156 //           handle. Returns in <L> the location for the curve.
157 //           In <First> and <Last> the parameter range.
158 //=======================================================================
159
160 static const Handle(Geom_Curve) nullCurve;
161
162 const Handle(Geom_Curve)&  BRep_Tool::Curve(const TopoDS_Edge& E,
163                                             TopLoc_Location& L,
164                                             Standard_Real& First,
165                                             Standard_Real& Last)
166 {
167   // find the representation
168   const BRep_TEdge* TE = static_cast<const BRep_TEdge*>(E.TShape().get());
169   BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves()); 
170
171   while (itcr.More()) {
172     const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
173     if (cr->IsCurve3D()) {
174       const BRep_Curve3D* GC = static_cast<const BRep_Curve3D*>(cr.get());
175       L = E.Location() * GC->Location();
176       GC->Range(First,Last);
177       return GC->Curve3D();
178     }
179     itcr.Next();
180   }
181   L.Identity();
182   First = Last = 0.;
183   return nullCurve;
184 }
185
186 //=======================================================================
187 //function : Curve
188 //purpose  : Returns the 3D curve  of the edge. May be a Null handle.
189 //           In <First> and <Last> the parameter range.
190 //           It can be a copy if there is a Location.
191 //=======================================================================
192
193 Handle(Geom_Curve)  BRep_Tool::Curve(const TopoDS_Edge& E,
194                                      Standard_Real& First,
195                                      Standard_Real& Last)
196 {
197   TopLoc_Location L;
198   const Handle(Geom_Curve)& C = Curve(E,L,First,Last);
199   if ( !C.IsNull() ) {
200     if ( !L.IsIdentity() ) {
201       Handle(Geom_Geometry) aCopy = C->Transformed(L.Transformation());
202       Geom_Curve* aGC = static_cast<Geom_Curve*>(aCopy.get());
203       return Handle(Geom_Curve)(aGC);
204     }
205   }
206   return C;
207 }
208
209 //=======================================================================
210 //function : IsGeometric
211 //purpose  : Returns True if <E> is a 3d curve or a curve on
212 //           surface.
213 //=======================================================================
214
215 Standard_Boolean  BRep_Tool::IsGeometric(const TopoDS_Edge& E)
216 {
217   // find the representation
218   const BRep_TEdge* TE = static_cast<const BRep_TEdge*>(E.TShape().get());
219   BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
220
221   while (itcr.More()) {
222     const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
223     if (cr->IsCurve3D()) {
224       Handle(BRep_Curve3D) GC (Handle(BRep_Curve3D)::DownCast (cr));
225       if (! GC.IsNull() && ! GC->Curve3D().IsNull())
226         return Standard_True;
227     }
228     else if (cr->IsCurveOnSurface()) return Standard_True;
229     itcr.Next();
230   }
231   return Standard_False;
232 }
233
234 //=======================================================================
235 //function : Polygon3D
236 //purpose  : Returns the 3D polygon of the edge. May be   a Null
237 //           handle. Returns in <L> the location for the polygon.
238 //=======================================================================
239
240 static const Handle(Poly_Polygon3D) nullPolygon3D;
241
242 const Handle(Poly_Polygon3D)& BRep_Tool::Polygon3D(const TopoDS_Edge& E,
243                                                    TopLoc_Location&   L)
244 {
245   // find the representation
246   const BRep_TEdge* TE = static_cast<const BRep_TEdge*>(E.TShape().get());
247   BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
248
249   while (itcr.More()) {
250     const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
251     if (cr->IsPolygon3D()) {
252       const BRep_Polygon3D* GC = static_cast<const BRep_Polygon3D*>(cr.get());
253       L = E.Location() * GC->Location();
254       return GC->Polygon3D();
255     }
256     itcr.Next();
257   }
258   L.Identity();
259   return nullPolygon3D;
260 }
261
262 //=======================================================================
263 //function : CurveOnSurface
264 //purpose  : Returns the curve  associated to the  edge in  the
265 //           parametric  space of  the  face.  Returns   a NULL
266 //           handle  if this curve  does not exist.  Returns in
267 //           <First> and <Last> the parameter range.
268 //=======================================================================
269
270 Handle(Geom2d_Curve) BRep_Tool::CurveOnSurface(const TopoDS_Edge& E, 
271                                                const TopoDS_Face& F,
272                                                Standard_Real& First,
273                                                Standard_Real& Last)
274 {
275   TopLoc_Location l;
276   const Handle(Geom_Surface)& S = BRep_Tool::Surface(F,l);
277   TopoDS_Edge aLocalEdge = E;
278   if (F.Orientation() == TopAbs_REVERSED) {
279     aLocalEdge.Reverse();
280 //    return CurveOnSurface(E,S,l,First,Last);
281   }
282 //    return CurveOnSurface(TopoDS::Edge(E.Reversed()),S,l,First,Last);
283 //  else
284 //    return CurveOnSurface(E,S,l,First,Last);
285   return CurveOnSurface(aLocalEdge,S,l,First,Last);
286 }
287
288 //=======================================================================
289 //function : CurveOnSurface
290 //purpose  : Returns the  curve associated to   the edge in the
291 //           parametric  space of the   surface. Returns a NULL
292 //           handle  if this curve does  not exist.  Returns in
293 //           <First> and <Last> the parameter range.
294 //=======================================================================
295
296 static const Handle(Geom2d_Curve) nullPCurve;
297
298 Handle(Geom2d_Curve) BRep_Tool::CurveOnSurface(const TopoDS_Edge& E, 
299                                                const Handle(Geom_Surface)& S,
300                                                const TopLoc_Location& L,
301                                                Standard_Real& First,
302                                                Standard_Real& Last)
303 {
304   TopLoc_Location loc = L.Predivided(E.Location());
305   Standard_Boolean Eisreversed = (E.Orientation() == TopAbs_REVERSED);
306
307   // find the representation
308   const BRep_TEdge* TE = static_cast<const BRep_TEdge*>(E.TShape().get());
309   BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
310
311   while (itcr.More()) {
312     const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
313     if (cr->IsCurveOnSurface(S,loc)) {
314       const BRep_GCurve* GC = static_cast<const BRep_GCurve*>(cr.get());
315       GC->Range(First,Last);
316       if (GC->IsCurveOnClosedSurface() && Eisreversed)
317         return GC->PCurve2();
318       else
319         return GC->PCurve();
320     }
321     itcr.Next();
322   }
323
324   // for planar surface and 3d curve try a projection
325   // modif 21-05-97 : for RectangularTrimmedSurface, try a projection
326   Handle(Geom_Plane) GP;
327   Handle(Geom_RectangularTrimmedSurface) GRTS;
328   GRTS = Handle(Geom_RectangularTrimmedSurface)::DownCast(S);
329   if(!GRTS.IsNull())
330     GP = Handle(Geom_Plane)::DownCast(GRTS->BasisSurface());
331   else
332     GP = Handle(Geom_Plane)::DownCast(S);
333   //fin modif du 21-05-97
334
335   if (!GP.IsNull())
336   {
337     Handle(GeomAdaptor_HCurve) HC;
338     Handle(GeomAdaptor_HSurface) HS;
339
340     HC = new GeomAdaptor_HCurve();
341     HS = new GeomAdaptor_HSurface();
342
343     TopLoc_Location aCurveLocation;
344
345     Standard_Real f, l;// for those who call with (u,u).
346     Handle(Geom_Curve) C3d = BRep_Tool::Curve(E, aCurveLocation, f, l);
347
348     if (C3d.IsNull())
349     {
350       First = Last = 0.;
351       return nullPCurve;
352     }
353
354     aCurveLocation = aCurveLocation.Predivided(L);
355     First = f; Last = l; //Range of edge must not be modified
356
357     if (!aCurveLocation.IsIdentity())
358     {
359       const gp_Trsf& T = aCurveLocation.Transformation();
360       Handle(Geom_Geometry) GC3d = C3d->Transformed(T);
361       C3d = Handle(Geom_Curve)::DownCast (GC3d);
362       f = C3d->TransformedParameter(f, T);
363       l = C3d->TransformedParameter(l, T);
364     }
365     GeomAdaptor_Surface& GAS = HS->ChangeSurface();
366     GAS.Load(GP);
367
368     Handle(Geom_Curve) ProjOnPlane = 
369       GeomProjLib::ProjectOnPlane(new Geom_TrimmedCurve(C3d,f,l,Standard_True,Standard_False),
370                                   GP,
371                                   GP->Position().Direction(),
372                                   Standard_True);
373
374     GeomAdaptor_Curve& GAC = HC->ChangeCurve();
375     GAC.Load(ProjOnPlane);
376
377     ProjLib_ProjectedCurve Proj(HS,HC);
378     Handle(Geom2d_Curve) pc = Geom2dAdaptor::MakeCurve(Proj);
379
380     if (pc->DynamicType() == STANDARD_TYPE(Geom2d_TrimmedCurve)) {
381       Handle(Geom2d_TrimmedCurve) TC = 
382         Handle(Geom2d_TrimmedCurve)::DownCast (pc);
383       pc = TC->BasisCurve();
384     }
385
386     return pc;
387   }
388   
389   First = Last = 0.;
390   return nullPCurve;
391 }
392
393 //=======================================================================
394 //function : CurveOnSurface
395 //purpose  : 
396 //=======================================================================
397
398 void  BRep_Tool::CurveOnSurface(const TopoDS_Edge& E, 
399                                 Handle(Geom2d_Curve)& C, 
400                                 Handle(Geom_Surface)& S, 
401                                 TopLoc_Location& L,
402                                 Standard_Real& First,
403                                 Standard_Real& Last)
404 {
405   // find the representation
406   const BRep_TEdge* TE = static_cast<const BRep_TEdge*>(E.TShape().get());
407   BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
408
409   while (itcr.More()) {
410     const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
411     if (cr->IsCurveOnSurface()) {
412       const BRep_GCurve* GC = static_cast<const BRep_GCurve*>(cr.get());
413       C = GC->PCurve();
414       S = GC->Surface();
415       L = E.Location() * GC->Location();
416       GC->Range(First,Last);
417       return;
418     }
419     itcr.Next();
420   }
421   
422   C.Nullify();
423   S.Nullify();
424   L.Identity();
425   First = Last = 0.;
426 }
427
428 //=======================================================================
429 //function : CurveOnSurface
430 //purpose  : 
431 //=======================================================================
432
433 void  BRep_Tool::CurveOnSurface(const TopoDS_Edge& E, 
434                                 Handle(Geom2d_Curve)& C, 
435                                 Handle(Geom_Surface)& S, 
436                                 TopLoc_Location& L,
437                                 Standard_Real& First,
438                                 Standard_Real& Last,
439                                 const Standard_Integer Index)
440 {
441   Standard_Integer i = 0;
442   Standard_Boolean Eisreversed = (E.Orientation() == TopAbs_REVERSED);
443
444   // find the representation
445   const BRep_TEdge* TE = static_cast<const BRep_TEdge*>(E.TShape().get());
446   BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
447
448   while (itcr.More()) {
449     const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
450     if (cr->IsCurveOnSurface()) {
451       const BRep_GCurve* GC = static_cast<const BRep_GCurve*>(cr.get());
452       i++;
453       if (i > Index) break;
454       if (i == Index) {
455         // JMB le 21 Mai 1999
456         // it is done as in the other CurveOnSurface methods, ie. take into account
457         // the orientation in case of cut edges (return PCurve2)
458         // otherwise there is a risk to loop curves or to not get the prover one.
459         if (GC->IsCurveOnClosedSurface() && Eisreversed)
460           C = GC->PCurve2();
461         else
462           C = GC->PCurve();
463         S = GC->Surface();
464         L = E.Location() * GC->Location();
465         GC->Range(First,Last);
466         return;
467       }
468     }
469     itcr.Next();
470   }
471   
472   C.Nullify();
473   S.Nullify();
474   L.Identity();
475   First = Last = 0.;
476 }
477
478 //=======================================================================
479 //function : PolygonOnSurface
480 //purpose  : Returns the polygon associated to the  edge in  the
481 //           parametric  space of  the  face.  Returns   a NULL
482 //           handle  if this polygon  does not exist.
483 //=======================================================================
484
485 Handle(Poly_Polygon2D) BRep_Tool::PolygonOnSurface(const TopoDS_Edge& E, 
486                                                    const TopoDS_Face& F)
487 {
488   TopLoc_Location l;
489   const Handle(Geom_Surface)& S = BRep_Tool::Surface(F,l);
490   TopoDS_Edge aLocalEdge = E;
491   if (F.Orientation() == TopAbs_REVERSED) {
492     aLocalEdge.Reverse();
493 //    return PolygonOnSurface(E,S,l);
494   }
495   //    return PolygonOnSurface(TopoDS::Edge(E.Reversed()),S,l);
496 //  else
497 //    return PolygonOnSurface(E,S,l);
498   return PolygonOnSurface(aLocalEdge,S,l);
499 }
500
501 //=======================================================================
502 //function : PolygonOnSurface
503 //purpose  : Returns the polygon associated to the  edge in  the
504 //           parametric  space of  the surface. Returns   a NULL
505 //           handle  if this polygon  does not exist.
506 //=======================================================================
507
508 static const Handle(Poly_Polygon2D) nullPolygon2D;
509
510 Handle(Poly_Polygon2D) BRep_Tool::PolygonOnSurface(const TopoDS_Edge& E, 
511                                                    const Handle(Geom_Surface)& S,
512                                                    const TopLoc_Location& L)
513 {
514   TopLoc_Location l = L.Predivided(E.Location());
515   Standard_Boolean Eisreversed = (E.Orientation() == TopAbs_REVERSED);
516
517   // find the representation
518   const BRep_TEdge* TE = static_cast<const BRep_TEdge*>(E.TShape().get());
519   BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
520
521   while (itcr.More()) {
522     const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
523     if (cr->IsPolygonOnSurface(S,l)) {
524       if (cr->IsPolygonOnClosedSurface() && Eisreversed )
525         return cr->Polygon2();
526       else
527         return cr->Polygon();
528     }
529     itcr.Next();
530   }
531   
532   return nullPolygon2D;
533 }
534
535 //=======================================================================
536 //function : PolygonOnSurface
537 //purpose  : 
538 //=======================================================================
539
540 void BRep_Tool::PolygonOnSurface(const TopoDS_Edge&      E,
541                                  Handle(Poly_Polygon2D)& P,
542                                  Handle(Geom_Surface)&   S,
543                                  TopLoc_Location&        L)
544 {
545   // find the representation
546   const BRep_TEdge* TE = static_cast<const BRep_TEdge*>(E.TShape().get());
547   BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
548
549   while (itcr.More()) {
550     const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
551     if (cr->IsPolygonOnSurface()) {
552       const BRep_PolygonOnSurface* PS = static_cast<const BRep_PolygonOnSurface*>(cr.get());
553       P = PS->Polygon();
554       S = PS->Surface();
555       L = E.Location() * PS->Location();
556       return;
557     }
558     itcr.Next();
559   }
560   
561   L.Identity();
562   P.Nullify();
563   S.Nullify();
564 }
565
566 //=======================================================================
567 //function : PolygonOnSurface
568 //purpose  : 
569 //=======================================================================
570
571 void BRep_Tool::PolygonOnSurface(const TopoDS_Edge&      E,
572                                  Handle(Poly_Polygon2D)& P,
573                                  Handle(Geom_Surface)&   S,
574                                  TopLoc_Location&        L,
575                                  const Standard_Integer  Index)
576 {
577   Standard_Integer i = 0;
578
579   // find the representation
580   const BRep_TEdge* TE = static_cast<const BRep_TEdge*>(E.TShape().get());
581   BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
582
583   while (itcr.More()) {
584     const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
585     if (cr->IsPolygonOnSurface()) {
586       const BRep_PolygonOnSurface* PS = static_cast<const BRep_PolygonOnSurface*>(cr.get());
587       i++;
588       if (i > Index) break;
589       if (i == Index) {
590         P = PS->Polygon();
591         S = PS->Surface();
592         L = E.Location() * PS->Location();
593         return;
594       }
595     }
596     itcr.Next();
597   }
598   
599   L.Identity();
600   P.Nullify();
601   S.Nullify();
602 }
603
604 //=======================================================================
605 //function : PolygonOnTriangulation
606 //purpose  : Returns the polygon associated to the  edge in  the
607 //           parametric  space of  the  face.  Returns   a NULL
608 //           handle  if this polygon  does not exist.
609 //=======================================================================
610
611 static const Handle(Poly_PolygonOnTriangulation) nullArray;
612
613 const Handle(Poly_PolygonOnTriangulation)&
614 BRep_Tool::PolygonOnTriangulation(const TopoDS_Edge&                E, 
615                                   const Handle(Poly_Triangulation)& T,
616                                   const TopLoc_Location&            L)
617 {
618   TopLoc_Location l = L.Predivided(E.Location());
619   Standard_Boolean Eisreversed = (E.Orientation() == TopAbs_REVERSED);
620
621   // find the representation
622   const BRep_TEdge* TE = static_cast<const BRep_TEdge*>(E.TShape().get());
623   BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
624
625   while (itcr.More()) {
626     const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
627     if ( cr->IsPolygonOnTriangulation(T,l)) {
628       if ( cr->IsPolygonOnClosedTriangulation() && Eisreversed )
629         return cr->PolygonOnTriangulation2();
630       else
631         return cr->PolygonOnTriangulation();
632     }
633     itcr.Next();
634   }
635   
636   return nullArray;
637 }
638
639 //=======================================================================
640 //function : PolygonOnTriangulation
641 //purpose  : 
642 //=======================================================================
643
644 void 
645 BRep_Tool::PolygonOnTriangulation(const TopoDS_Edge&                   E,
646                                   Handle(Poly_PolygonOnTriangulation)& P,
647                                   Handle(Poly_Triangulation)&          T,
648                                   TopLoc_Location&                     L)
649 {
650   // find the representation
651   const BRep_TEdge* TE = static_cast<const BRep_TEdge*>(E.TShape().get());
652   BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
653
654   while (itcr.More()) {
655     const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
656     if (cr->IsPolygonOnTriangulation()) {
657       const BRep_PolygonOnTriangulation* PT =
658         static_cast<const BRep_PolygonOnTriangulation*>(cr.get());
659       P = PT->PolygonOnTriangulation();
660       T = PT->Triangulation();
661       L = E.Location() * PT->Location();
662       return;
663     }
664     itcr.Next();
665   }
666   
667   L.Identity();
668   P.Nullify();
669   T.Nullify();
670 }
671
672 //=======================================================================
673 //function : PolygonOnTriangulation
674 //purpose  : 
675 //=======================================================================
676
677 void 
678 BRep_Tool::PolygonOnTriangulation(const TopoDS_Edge&                   E,
679                                   Handle(Poly_PolygonOnTriangulation)& P,
680                                   Handle(Poly_Triangulation)&          T,
681                                   TopLoc_Location&                     L,
682                                   const Standard_Integer               Index)
683 {
684   Standard_Integer i = 0;
685
686   // find the representation
687   const BRep_TEdge* TE = static_cast<const BRep_TEdge*>(E.TShape().get());
688   BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
689
690   while (itcr.More()) {
691     const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
692     if (cr->IsPolygonOnTriangulation()) {
693       const BRep_PolygonOnTriangulation* PT =
694         static_cast<const BRep_PolygonOnTriangulation*>(cr.get());
695       i++;
696       if (i > Index) break;
697       if (i == Index) {
698         T = PT->Triangulation();
699         P = PT->PolygonOnTriangulation();
700         L = E.Location() * PT->Location();
701         return;
702       }
703     }
704     itcr.Next();
705   }
706   
707   L.Identity();
708   P.Nullify();
709   T.Nullify();
710 }
711
712 //=======================================================================
713 //function : IsClosed
714 //purpose  : Returns  True  if  <E>  has  two  PCurves  in  the
715 //           parametric space of <F>. i.e.  <F>  is on a closed
716 //           surface and <E> is on the closing curve.
717 //=======================================================================
718
719 Standard_Boolean BRep_Tool::IsClosed(const TopoDS_Edge& E, 
720                                      const TopoDS_Face& F)
721 {
722   TopLoc_Location l;
723   const Handle(Geom_Surface)& S = BRep_Tool::Surface(F,l);
724   if (IsClosed(E,S,l)) return Standard_True;
725   const Handle(Poly_Triangulation)& T = BRep_Tool::Triangulation(F,l);
726   return IsClosed(E, T, l);
727 }
728
729 //=======================================================================
730 //function : IsClosed
731 //purpose  : Returns  True  if  <E>  has  two  PCurves  in  the
732 //           parametric space  of <S>.  i.e.   <S>  is a closed
733 //           surface and <E> is on the closing curve.
734 //=======================================================================
735
736 Standard_Boolean BRep_Tool::IsClosed(const TopoDS_Edge& E,
737                                      const Handle(Geom_Surface)& S,
738                                      const TopLoc_Location& L)
739 {
740   //modified by NIZNHY-PKV Fri Oct 17 12:16:58 2008f
741   if (IsPlane(S)) {
742     return Standard_False;
743   }
744   //modified by NIZNHY-PKV Fri Oct 17 12:16:54 2008t
745   //
746   TopLoc_Location      l = L.Predivided(E.Location());
747
748   // find the representation
749   const BRep_TEdge* TE = static_cast<const BRep_TEdge*>(E.TShape().get());
750   BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
751
752   while (itcr.More()) {
753     const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
754     if (cr->IsCurveOnSurface(S,l) &&
755         cr->IsCurveOnClosedSurface())
756       return Standard_True;
757     itcr.Next();
758   }
759   return Standard_False;
760 }
761
762 //=======================================================================
763 //function : IsClosed
764 //purpose  : Returns  True  if <E> has two arrays of indices in
765 //           the triangulation <T>.
766 //=======================================================================
767
768 Standard_Boolean BRep_Tool::IsClosed(const TopoDS_Edge&                E, 
769                                      const Handle(Poly_Triangulation)& T,
770                                      const TopLoc_Location& L)
771 {
772   TopLoc_Location l = L.Predivided(E.Location());
773
774   // find the representation
775   const BRep_TEdge* TE = static_cast<const BRep_TEdge*>(E.TShape().get());
776   BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
777
778   while (itcr.More()) {
779     const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
780     if (cr->IsPolygonOnTriangulation(T,l) &&
781         cr->IsPolygonOnClosedTriangulation()) 
782       return Standard_True;
783     itcr.Next();
784   }
785   return Standard_False;
786 }
787
788 //=======================================================================
789 //function : Tolerance
790 //purpose  : Returns the tolerance for <E>.
791 //=======================================================================
792
793 Standard_Real  BRep_Tool::Tolerance(const TopoDS_Edge& E)
794 {
795   const BRep_TEdge* TE = static_cast<const BRep_TEdge*>(E.TShape().get());
796   Standard_Real p = TE->Tolerance();
797   Standard_Real pMin = Precision::Confusion();
798   if (p > pMin) return p;
799   else          return pMin;
800 }
801
802 //=======================================================================
803 //function : SameParameter
804 //purpose  : Returns the SameParameter flag for the edge.
805 //=======================================================================
806
807 Standard_Boolean  BRep_Tool::SameParameter(const TopoDS_Edge& E)
808 {
809   const BRep_TEdge* TE = static_cast<const BRep_TEdge*>(E.TShape().get());
810   return TE->SameParameter();
811 }
812
813 //=======================================================================
814 //function : SameRange
815 //purpose  : Returns the SameRange flag for the edge.
816 //=======================================================================
817
818 Standard_Boolean  BRep_Tool::SameRange(const TopoDS_Edge& E)
819 {
820   const BRep_TEdge* TE = static_cast<const BRep_TEdge*>(E.TShape().get());
821   return TE->SameRange();
822 }
823
824 //=======================================================================
825 //function : Degenerated
826 //purpose  : Returns True  if the edge is degenerated.
827 //=======================================================================
828
829 Standard_Boolean  BRep_Tool::Degenerated(const TopoDS_Edge& E)
830 {
831   const BRep_TEdge* TE = static_cast<const BRep_TEdge*>(E.TShape().get());
832   return TE->Degenerated();
833 }
834
835 //=======================================================================
836 //function : Range
837 //purpose  : 
838 //=======================================================================
839
840 void  BRep_Tool::Range(const TopoDS_Edge& E, 
841                        Standard_Real& First, 
842                        Standard_Real& Last)
843 {
844   //  set the range to all the representations
845   const BRep_TEdge* TE = static_cast<const BRep_TEdge*>(E.TShape().get());
846   BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
847   
848   while (itcr.More()) {
849     const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
850     if (cr->IsCurve3D()) {
851       const BRep_Curve3D* CR = static_cast<const BRep_Curve3D*>(cr.get());
852       if (!CR->Curve3D().IsNull()) {
853         First = CR->First(); 
854         Last = CR->Last();
855         return;
856       }
857     }
858     else if (cr->IsCurveOnSurface()) {
859       const BRep_GCurve* CR = static_cast<const BRep_GCurve*>(cr.get());
860       First = CR->First(); 
861       Last = CR->Last();
862       return;
863     }
864     itcr.Next();
865   }
866   First = Last = 0.;
867 }
868
869 //=======================================================================
870 //function : Range
871 //purpose  : 
872 //=======================================================================
873
874 void  BRep_Tool::Range(const TopoDS_Edge& E, 
875                        const Handle(Geom_Surface)& S,
876                        const TopLoc_Location& L,
877                        Standard_Real& First, 
878                        Standard_Real& Last)
879 {
880   TopLoc_Location l = L.Predivided(E.Location());
881   
882   // find the representation
883   const BRep_TEdge* TE = static_cast<const BRep_TEdge*>(E.TShape().get());
884   BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
885   
886   while (itcr.More()) {
887     const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
888     if (cr->IsCurveOnSurface(S,l)) {
889       const BRep_CurveOnSurface* CR = static_cast<const BRep_CurveOnSurface*>(cr.get());
890       CR->Range(First,Last);
891       break;
892     }
893     itcr.Next();
894   }
895   if (!itcr.More()) {
896     Range(E,First,Last);
897   }
898   E.TShape()->Modified(Standard_True);
899 }
900
901 //=======================================================================
902 //function : Range
903 //purpose  : 
904 //=======================================================================
905
906 void  BRep_Tool::Range(const TopoDS_Edge& E, 
907                        const TopoDS_Face& F, 
908                        Standard_Real& First, 
909                        Standard_Real& Last)
910 {
911   TopLoc_Location L;
912   const Handle(Geom_Surface)& S = BRep_Tool::Surface(F,L);
913   Range(E,S,L,First,Last);
914 }
915
916 //=======================================================================
917 //function : UVPoints
918 //purpose  : 
919 //=======================================================================
920
921 void  BRep_Tool::UVPoints(const TopoDS_Edge& E, 
922                           const Handle(Geom_Surface)& S, 
923                           const TopLoc_Location& L, 
924                           gp_Pnt2d& PFirst, 
925                           gp_Pnt2d& PLast)
926 {
927   TopLoc_Location l = L.Predivided(E.Location());
928   Standard_Boolean Eisreversed = (E.Orientation() == TopAbs_REVERSED);
929
930   // find the representation
931   const BRep_TEdge* TE = static_cast<const BRep_TEdge*>(E.TShape().get());
932   BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
933
934   while (itcr.More()) {
935     const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
936     if (cr->IsCurveOnSurface(S,l)) {
937       if (cr->IsCurveOnClosedSurface() && Eisreversed)
938       {
939         const BRep_CurveOnClosedSurface* CR =
940           static_cast<const BRep_CurveOnClosedSurface*>(cr.get());
941         CR->UVPoints2(PFirst, PLast);
942       }
943       else
944       {
945         const BRep_CurveOnSurface* CR =
946           static_cast<const BRep_CurveOnSurface*>(cr.get());
947         CR->UVPoints(PFirst, PLast);
948       }
949       return;
950     }
951     itcr.Next();
952   }
953
954   // for planar surface project the vertices
955   // modif 21-05-97 : for RectangularTrimmedSurface, project the vertices
956   Handle(Geom_Plane) GP;
957   Handle(Geom_RectangularTrimmedSurface) GRTS;
958   GRTS = Handle(Geom_RectangularTrimmedSurface)::DownCast(S);
959   if(!GRTS.IsNull())
960     GP = Handle(Geom_Plane)::DownCast(GRTS->BasisSurface());
961   else
962     GP = Handle(Geom_Plane)::DownCast(S);
963   //fin modif du 21-05-97
964   if (!GP.IsNull()) {
965     // get the two vertices
966     TopoDS_Vertex Vf,Vl;
967     TopExp::Vertices(E,Vf,Vl);
968
969     TopLoc_Location Linverted = L.Inverted();
970     Vf.Move(Linverted);
971     Vl.Move(Linverted);
972     Standard_Real u,v;
973     gp_Pln pln = GP->Pln();
974
975     u=v=0.;
976     if (!Vf.IsNull()) {
977       gp_Pnt PF = BRep_Tool::Pnt(Vf);
978       ElSLib::Parameters(pln,PF,u,v);
979     }
980     PFirst.SetCoord(u,v);
981
982     u=v=0.;
983     if (!Vl.IsNull()) {
984       gp_Pnt PL = BRep_Tool::Pnt(Vl);
985       ElSLib::Parameters(pln,PL,u,v);
986     }
987     PLast.SetCoord(u,v);
988   }
989   else
990   {
991     PFirst.SetCoord (0., 0.);
992     PLast.SetCoord (0., 0.);
993   }
994 }
995
996 //=======================================================================
997 //function : UVPoints
998 //purpose  : 
999 //=======================================================================
1000
1001 void  BRep_Tool::UVPoints(const TopoDS_Edge& E,
1002                           const TopoDS_Face& F, 
1003                           gp_Pnt2d& PFirst, 
1004                           gp_Pnt2d& PLast)
1005 {
1006   TopLoc_Location L;
1007   const Handle(Geom_Surface)& S = BRep_Tool::Surface(F,L);
1008   TopoDS_Edge aLocalEdge = E;
1009   if (F.Orientation() == TopAbs_REVERSED) {
1010     aLocalEdge.Reverse();
1011 //    UVPoints(E,S,L,PFirst,PLast);
1012   }
1013 //    UVPoints(TopoDS::Edge(E.Reversed()),S,L,PFirst,PLast);
1014 //  else
1015 //    UVPoints(E,S,L,PFirst,PLast);
1016   UVPoints(aLocalEdge,S,L,PFirst,PLast);
1017 }
1018
1019 //=======================================================================
1020 //function : SetUVPoints
1021 //purpose  : 
1022 //=======================================================================
1023
1024 void  BRep_Tool::SetUVPoints(const TopoDS_Edge& E,
1025                              const Handle(Geom_Surface)& S,
1026                              const TopLoc_Location& L, 
1027                              const gp_Pnt2d& PFirst, 
1028                              const gp_Pnt2d& PLast)
1029 {
1030   TopLoc_Location l = L.Predivided(E.Location());
1031   Standard_Boolean Eisreversed = (E.Orientation() == TopAbs_REVERSED);
1032
1033   // find the representation
1034   const BRep_TEdge* TE = static_cast<const BRep_TEdge*>(E.TShape().get());
1035   BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
1036
1037   while (itcr.More()) {
1038     Handle(BRep_CurveRepresentation)& cr = itcr.Value();
1039     if (cr->IsCurveOnSurface(S,l)) {
1040       if (cr->IsCurveOnClosedSurface() && Eisreversed)
1041       {
1042         BRep_CurveOnClosedSurface* CS = static_cast<BRep_CurveOnClosedSurface*>(cr.get());
1043         CS->SetUVPoints2(PFirst, PLast);
1044       }
1045       else
1046       {
1047         BRep_CurveOnSurface* CS = static_cast<BRep_CurveOnSurface*>(cr.get());
1048         CS->SetUVPoints(PFirst, PLast);
1049       }
1050     }
1051     itcr.Next();
1052   }
1053 }
1054
1055 //=======================================================================
1056 //function : SetUVPoints
1057 //purpose  : 
1058 //=======================================================================
1059
1060 void  BRep_Tool::SetUVPoints(const TopoDS_Edge& E,
1061                              const TopoDS_Face& F, 
1062                              const gp_Pnt2d& PFirst, 
1063                              const gp_Pnt2d& PLast)
1064 {
1065   TopLoc_Location L;
1066   const Handle(Geom_Surface)& S = BRep_Tool::Surface(F,L);
1067   TopoDS_Edge aLocalEdge = E;
1068   if (F.Orientation() == TopAbs_REVERSED) {
1069     aLocalEdge.Reverse();
1070 //    SetUVPoints(TopoDS::Edge(E.Reversed()),S,L,PFirst,PLast);
1071   }
1072 //  else
1073 //    SetUVPoints(E,S,L,PFirst,PLast);
1074   SetUVPoints(aLocalEdge,S,L,PFirst,PLast);
1075 }
1076
1077 //=======================================================================
1078 //function : HasContinuity
1079 //purpose  : Returns True if the edge is on the surfaces of the
1080 //           two faces.
1081 //=======================================================================
1082
1083 Standard_Boolean BRep_Tool::HasContinuity(const TopoDS_Edge& E, 
1084                                           const TopoDS_Face& F1, 
1085                                           const TopoDS_Face& F2)
1086 {
1087   TopLoc_Location l1,l2;
1088   const Handle(Geom_Surface)& S1 = BRep_Tool::Surface(F1,l1);
1089   const Handle(Geom_Surface)& S2 = BRep_Tool::Surface(F2,l2);
1090   return HasContinuity(E,S1,S2,l1,l2);
1091 }
1092
1093 //=======================================================================
1094 //function : Continuity
1095 //purpose  : Returns the continuity.
1096 //=======================================================================
1097
1098 GeomAbs_Shape  BRep_Tool::Continuity(const TopoDS_Edge& E, 
1099                                      const TopoDS_Face& F1, 
1100                                      const TopoDS_Face& F2)
1101 {
1102   TopLoc_Location l1,l2;
1103   const Handle(Geom_Surface)& S1 = BRep_Tool::Surface(F1,l1);
1104   const Handle(Geom_Surface)& S2 = BRep_Tool::Surface(F2,l2);
1105   return Continuity(E,S1,S2,l1,l2);
1106 }
1107
1108 //=======================================================================
1109 //function : HasContinuity
1110 //purpose  : Returns True if the edge is on the surfaces.
1111 //=======================================================================
1112
1113 Standard_Boolean BRep_Tool::HasContinuity(const TopoDS_Edge& E, 
1114                                           const Handle(Geom_Surface)& S1, 
1115                                           const Handle(Geom_Surface)& S2, 
1116                                           const TopLoc_Location& L1, 
1117                                           const TopLoc_Location& L2)
1118 {
1119   const TopLoc_Location& Eloc = E.Location();
1120   TopLoc_Location l1 = L1.Predivided(Eloc);
1121   TopLoc_Location l2 = L2.Predivided(Eloc);
1122
1123   // find the representation
1124   const BRep_TEdge* TE = static_cast<const BRep_TEdge*>(E.TShape().get());
1125   BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
1126
1127   while (itcr.More()) {
1128     const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
1129     if (cr->IsRegularity(S1,S2,l1,l2))
1130       return Standard_True;
1131     itcr.Next();
1132   }
1133   return Standard_False;
1134 }
1135
1136 //=======================================================================
1137 //function : Continuity
1138 //purpose  : Returns the continuity.
1139 //=======================================================================
1140
1141 GeomAbs_Shape  BRep_Tool::Continuity(const TopoDS_Edge& E, 
1142                                      const Handle(Geom_Surface)& S1, 
1143                                      const Handle(Geom_Surface)& S2, 
1144                                      const TopLoc_Location& L1, 
1145                                      const TopLoc_Location& L2)
1146 {
1147   TopLoc_Location l1 = L1.Predivided(E.Location());
1148   TopLoc_Location l2 = L2.Predivided(E.Location());
1149
1150   // find the representation
1151   BRep_ListIteratorOfListOfCurveRepresentation itcr
1152     ((*((Handle(BRep_TEdge)*)&E.TShape()))->ChangeCurves());
1153
1154   while (itcr.More()) {
1155     const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
1156     if (cr->IsRegularity(S1,S2,l1,l2))
1157       return cr->Continuity();
1158     itcr.Next();
1159   }
1160   return GeomAbs_C0;
1161 }
1162
1163 //=======================================================================
1164 //function : HasContinuity
1165 //purpose  : Returns True if the edge is on some two surfaces.
1166 //=======================================================================
1167
1168 Standard_Boolean BRep_Tool::HasContinuity(const TopoDS_Edge& E)
1169 {
1170   const BRep_TEdge* TE = static_cast<const BRep_TEdge*>(E.TShape().get());
1171   BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
1172
1173   for (; itcr.More(); itcr.Next())
1174   {
1175     const Handle(BRep_CurveRepresentation)& CR = itcr.Value();
1176     if (CR->IsRegularity())
1177       return Standard_True;
1178   }
1179   return Standard_False;
1180 }
1181
1182 //=======================================================================
1183 //function : Pnt
1184 //purpose  : Returns the 3d point.
1185 //=======================================================================
1186
1187 gp_Pnt  BRep_Tool::Pnt(const TopoDS_Vertex& V)
1188 {
1189   const BRep_TVertex* TV = static_cast<const BRep_TVertex*>(V.TShape().get());
1190   
1191   if (TV == 0)
1192   {
1193     Standard_NullObject::Raise("BRep_Tool:: TopoDS_Vertex hasn't gp_Pnt");
1194   }
1195
1196   const gp_Pnt& P = TV->Pnt();
1197   if (V.Location().IsIdentity())
1198   {
1199     return P;
1200   }
1201
1202   return P.Transformed(V.Location().Transformation());
1203 }
1204
1205 //=======================================================================
1206 //function : Tolerance
1207 //purpose  : Returns the tolerance.
1208 //=======================================================================
1209
1210 Standard_Real  BRep_Tool::Tolerance(const TopoDS_Vertex& V)
1211 {
1212   const BRep_TVertex* aTVert = static_cast<const BRep_TVertex*>(V.TShape().get());
1213
1214   if (aTVert == 0)
1215   {
1216     Standard_NullObject::Raise("BRep_Tool:: TopoDS_Vertex hasn't gp_Pnt");
1217   }
1218
1219   Standard_Real p = aTVert->Tolerance();
1220   Standard_Real pMin = Precision::Confusion();
1221   if (p > pMin) return p;
1222   else          return pMin;
1223 }
1224
1225 //=======================================================================
1226 //function : Parameter
1227 //purpose  : Returns the parameter of <V> on <E>.
1228 //=======================================================================
1229
1230 Standard_Real  BRep_Tool::Parameter(const TopoDS_Vertex& V, 
1231                                     const TopoDS_Edge& E)
1232 {
1233   
1234   // Search the vertex in the edge
1235
1236   Standard_Boolean rev = Standard_False;
1237   TopoDS_Shape VF;
1238   TopAbs_Orientation orient = TopAbs_INTERNAL;
1239
1240   TopoDS_Iterator itv(E.Oriented(TopAbs_FORWARD));
1241
1242   // if the edge has no vertices
1243   // and is degenerated use the vertex orientation
1244   // RLE, june 94
1245
1246   if (!itv.More() && Degenerated(E)) {
1247     orient = V.Orientation();
1248   }
1249
1250   while (itv.More()) {
1251     const TopoDS_Shape& Vcur = itv.Value();
1252     if (V.IsSame(Vcur)) {
1253       if (VF.IsNull()) {
1254         VF = Vcur;
1255       }
1256       else {
1257         rev = E.Orientation() == TopAbs_REVERSED;
1258         if (Vcur.Orientation() == V.Orientation()) {
1259           VF = Vcur;
1260         }
1261       }
1262     }
1263     itv.Next();
1264   }
1265   
1266   if (!VF.IsNull()) orient = VF.Orientation();
1267  
1268   Standard_Real f,l;
1269
1270   if (orient ==  TopAbs_FORWARD) {
1271     BRep_Tool::Range(E,f,l);
1272     return (rev) ? l : f;
1273   }
1274  
1275   else if (orient ==  TopAbs_REVERSED) {
1276     BRep_Tool::Range(E,f,l);
1277     return (rev) ? f : l;
1278    }
1279
1280   else {
1281     TopLoc_Location L;
1282     const Handle(Geom_Curve)& C = BRep_Tool::Curve(E,L,f,l);
1283     L = L.Predivided(V.Location());
1284     if (!C.IsNull() || Degenerated(E)) {
1285       const BRep_TVertex* TV = static_cast<const BRep_TVertex*>(V.TShape().get());
1286       BRep_ListIteratorOfListOfPointRepresentation itpr(TV->Points());
1287
1288       while (itpr.More()) {
1289         const Handle(BRep_PointRepresentation)& pr = itpr.Value();
1290         if (pr->IsPointOnCurve(C,L)) {
1291           Standard_Real p = pr->Parameter();
1292           Standard_Real res = p;// SVV 4 nov 99 - to avoid warnings on Linux
1293           if (!C.IsNull()) {
1294             // Closed curves RLE 16 june 94
1295             if (Precision::IsNegativeInfinite(f)) return pr->Parameter();//p;
1296             if (Precision::IsPositiveInfinite(l)) return pr->Parameter();//p;
1297             gp_Pnt Pf = C->Value(f).Transformed(L.Transformation());
1298             gp_Pnt Pl = C->Value(l).Transformed(L.Transformation());
1299             Standard_Real tol = BRep_Tool::Tolerance(V);
1300             if (Pf.Distance(Pl) < tol) {
1301               if (Pf.Distance(BRep_Tool::Pnt(V)) < tol) {
1302                 if (V.Orientation() == TopAbs_FORWARD) res = f;//p = f;
1303                 else                                   res = l;//p = l;
1304               }
1305             }
1306           }
1307           return res;//p;
1308         }
1309         itpr.Next();
1310       }
1311     }
1312     else {
1313       // no 3d curve !!
1314       // let us try with the first pcurve
1315       Handle(Geom2d_Curve) PC;
1316       Handle(Geom_Surface) S;
1317       BRep_Tool::CurveOnSurface(E,PC,S,L,f,l);
1318       L = L.Predivided(V.Location());
1319       const BRep_TVertex* TV = static_cast<const BRep_TVertex*>(V.TShape().get());
1320       BRep_ListIteratorOfListOfPointRepresentation itpr(TV->Points());
1321
1322       while (itpr.More()) {
1323         const Handle(BRep_PointRepresentation)& pr = itpr.Value();
1324         if (pr->IsPointOnCurveOnSurface(PC,S,L)) {
1325           Standard_Real p = pr->Parameter();
1326           // Closed curves RLE 16 june 94
1327           if (PC->IsClosed()) {
1328             if ((p == PC->FirstParameter()) || 
1329                 (p == PC->LastParameter())) {
1330               if (V.Orientation() == TopAbs_FORWARD) p = PC->FirstParameter();
1331               else                                   p = PC->LastParameter();
1332             }
1333           }
1334           return p;
1335         }
1336         itpr.Next();
1337       }
1338     }
1339   }
1340   
1341   Standard_NoSuchObject::Raise("BRep_Tool:: no parameter on edge");
1342   return 0;
1343 }
1344
1345 //=======================================================================
1346 //function : Parameter
1347 //purpose  : Returns the  parameters  of   the  vertex   on the
1348 //           pcurve of the edge on the face.
1349 //=======================================================================
1350
1351 Standard_Real BRep_Tool::Parameter(const TopoDS_Vertex& V, 
1352                                    const TopoDS_Edge& E, 
1353                                    const TopoDS_Face& F)
1354 {
1355   TopLoc_Location L;
1356   const Handle(Geom_Surface)& S = BRep_Tool::Surface(F,L);
1357   return BRep_Tool::Parameter(V,E,S,L);
1358 }
1359
1360 //=======================================================================
1361 //function : Parameter
1362 //purpose  : Returns the  parameters  of   the  vertex   on the
1363 //           pcurve of the edge on the surface.
1364 //=======================================================================
1365
1366 Standard_Real BRep_Tool::Parameter(const TopoDS_Vertex& V, 
1367                                    const TopoDS_Edge& E, 
1368                                    const Handle(Geom_Surface)& S,
1369                                    const TopLoc_Location& L)
1370 {
1371   // Search the vertex in the edge
1372
1373   Standard_Boolean rev = Standard_False;
1374   TopoDS_Shape VF;
1375   TopoDS_Iterator itv(E.Oriented(TopAbs_FORWARD));
1376
1377   while (itv.More()) {
1378     if (V.IsSame(itv.Value())) {
1379       if (VF.IsNull()) VF = itv.Value();
1380       else {
1381         rev = E.Orientation() == TopAbs_REVERSED;
1382         if (itv.Value().Orientation() == V.Orientation()) 
1383         VF = itv.Value();
1384       }
1385     }
1386     itv.Next();
1387   }
1388
1389  TopAbs_Orientation orient = TopAbs_INTERNAL;
1390   if (!VF.IsNull()) orient = VF.Orientation();
1391  
1392  Standard_Real f,l;
1393
1394  if (orient ==  TopAbs_FORWARD) {
1395    BRep_Tool::Range(E,S,L,f,l);
1396    return (rev) ? l : f;
1397  }
1398  
1399  else if (orient ==  TopAbs_REVERSED) {
1400    BRep_Tool::Range(E,S,L,f,l);
1401    return (rev) ? f : l;
1402  }
1403
1404  else {
1405    Handle(Geom2d_Curve) PC = BRep_Tool::CurveOnSurface(E,S,L,f,l);
1406    const BRep_TVertex* TV = static_cast<const BRep_TVertex*>(V.TShape().get());
1407    BRep_ListIteratorOfListOfPointRepresentation itpr(TV->Points());
1408
1409    while (itpr.More()) {
1410      if (itpr.Value()->IsPointOnCurveOnSurface(PC,S,L))
1411        return itpr.Value()->Parameter();
1412      itpr.Next();
1413    }
1414  }
1415
1416  //----------------------------------------------------------
1417    
1418   TopLoc_Location L1;
1419   const Handle(Geom_Curve)& C = BRep_Tool::Curve(E,L1,f,l);
1420   L1 = L1.Predivided(V.Location());
1421   if (!C.IsNull() || Degenerated(E)) {
1422     const BRep_TVertex* TV = static_cast<const BRep_TVertex*>(V.TShape().get());
1423     BRep_ListIteratorOfListOfPointRepresentation itpr(TV->Points());
1424
1425     while (itpr.More()) {
1426       const Handle(BRep_PointRepresentation)& pr = itpr.Value();
1427       if (pr->IsPointOnCurve(C,L1)) {
1428         Standard_Real p = pr->Parameter();
1429         Standard_Real res = p;
1430         if (!C.IsNull()) {
1431           // Closed curves RLE 16 june 94
1432           if (Precision::IsNegativeInfinite(f)) return res;
1433           if (Precision::IsPositiveInfinite(l)) return res;
1434           gp_Pnt Pf = C->Value(f).Transformed(L1.Transformation());
1435           gp_Pnt Pl = C->Value(l).Transformed(L1.Transformation());
1436           Standard_Real tol = BRep_Tool::Tolerance(V);
1437           if (Pf.Distance(Pl) < tol) {
1438             if (Pf.Distance(BRep_Tool::Pnt(V)) < tol) {
1439               if (V.Orientation() == TopAbs_FORWARD) res = f;
1440               else                                   res = l;
1441             }
1442           }
1443         }
1444         return res;
1445       }
1446       itpr.Next();
1447     }
1448   }
1449   
1450 //----------------------------------------------------------   
1451  
1452   Standard_NoSuchObject::Raise("BRep_Tool:: no parameter on edge");
1453   return 0;
1454 }
1455
1456 //=======================================================================
1457 //function : Parameters
1458 //purpose  : Returns the parameters of the vertex on the face.
1459 //=======================================================================
1460
1461 gp_Pnt2d  BRep_Tool::Parameters(const TopoDS_Vertex& V, 
1462                                 const TopoDS_Face& F)
1463 {
1464   TopLoc_Location L;
1465   const Handle(Geom_Surface)& S = BRep_Tool::Surface(F,L);
1466   L = L.Predivided(V.Location());
1467   const BRep_TVertex* TV = static_cast<const BRep_TVertex*>(V.TShape().get());
1468   BRep_ListIteratorOfListOfPointRepresentation itpr(TV->Points());
1469   
1470   // It is checked if there is PointRepresentation (case non Manifold)
1471   while (itpr.More()) {
1472     if (itpr.Value()->IsPointOnSurface(S,L)) {
1473       return gp_Pnt2d(itpr.Value()->Parameter(),
1474                       itpr.Value()->Parameter2());
1475     }
1476     itpr.Next();
1477   }
1478
1479  TopoDS_Vertex Vf,Vl;
1480  TopoDS_Edge E;
1481  // Otherwise the edges are searched (PMN 4/06/97) It is not possible to succeed 999/1000!
1482  // even if often there is a way to make more economically than above...
1483  TopExp_Explorer exp;
1484  for (exp.Init(F, TopAbs_EDGE); exp.More(); exp.Next()) { 
1485     E = TopoDS::Edge(exp.Current());  
1486     TopExp::Vertices(E, Vf, Vl);
1487     if ((V.IsSame(Vf)) || (V.IsSame(Vl))) {
1488       gp_Pnt2d Pf, Pl;
1489       UVPoints(E, F, Pf, Pl);
1490       if (V.IsSame(Vf)) return Pf;
1491       else              return Pl;//Ambiguity (natural) for degenerated edges.
1492     }
1493   }
1494   Standard_NoSuchObject::Raise("BRep_Tool:: no parameters on surface");
1495   return gp_Pnt2d(0,0);
1496 }
1497 //=======================================================================
1498 //function : IsClosed
1499 //purpose  : 
1500 //=======================================================================
1501 Standard_Boolean BRep_Tool::IsClosed (const TopoDS_Shape& theShape)
1502 {
1503   if (theShape.ShapeType() == TopAbs_SHELL)
1504   {
1505     NCollection_Map<TopoDS_Shape, TopTools_ShapeMapHasher> aMap (101, new NCollection_IncAllocator);
1506     TopExp_Explorer exp (theShape.Oriented(TopAbs_FORWARD), TopAbs_EDGE);
1507     Standard_Boolean hasBound = Standard_False;
1508     for (; exp.More(); exp.Next())
1509     {
1510       const TopoDS_Edge& E = TopoDS::Edge(exp.Current());
1511       if (BRep_Tool::Degenerated(E) || E.Orientation() == TopAbs_INTERNAL || E.Orientation() == TopAbs_EXTERNAL)
1512         continue;
1513       hasBound = Standard_True;
1514       if (!aMap.Add(E))
1515         aMap.Remove(E);
1516     }
1517     return hasBound && aMap.IsEmpty();
1518   }
1519   else if (theShape.ShapeType() == TopAbs_WIRE)
1520   {
1521     NCollection_Map<TopoDS_Shape, TopTools_ShapeMapHasher> aMap (101, new NCollection_IncAllocator);
1522     TopExp_Explorer exp (theShape.Oriented(TopAbs_FORWARD), TopAbs_VERTEX);
1523     Standard_Boolean hasBound = Standard_False;
1524     for (; exp.More(); exp.Next())
1525     {
1526       const TopoDS_Shape& V = exp.Current();
1527       if (V.Orientation() == TopAbs_INTERNAL || V.Orientation() == TopAbs_EXTERNAL)
1528         continue;
1529       hasBound = Standard_True;
1530       if (!aMap.Add(V))
1531         aMap.Remove(V);
1532     }
1533     return hasBound && aMap.IsEmpty();
1534   }
1535   else if (theShape.ShapeType() == TopAbs_EDGE)
1536   {
1537     TopoDS_Vertex aVFirst, aVLast;
1538     TopExp::Vertices(TopoDS::Edge(theShape), aVFirst, aVLast);
1539     return !aVFirst.IsNull() && aVFirst.IsSame(aVLast);
1540   }
1541   return theShape.Closed();
1542 }
1543
1544 //modified by NIZNHY-PKV Fri Oct 17 14:09:58 2008 f 
1545 //=======================================================================
1546 //function : IsPlane
1547 //purpose  : 
1548 //=======================================================================
1549 Standard_Boolean IsPlane(const Handle(Geom_Surface)& aS)
1550 {
1551   Standard_Boolean bRet;
1552   Handle(Geom_Plane) aGP;
1553   Handle(Geom_RectangularTrimmedSurface) aGRTS;
1554   Handle(Geom_OffsetSurface) aGOFS;
1555   //
1556   aGRTS=Handle(Geom_RectangularTrimmedSurface)::DownCast(aS);
1557   aGOFS=Handle(Geom_OffsetSurface)::DownCast(aS);
1558   //
1559   if(!aGOFS.IsNull()) {
1560     aGP=Handle(Geom_Plane)::DownCast(aGOFS->BasisSurface());
1561   }
1562   else if(!aGRTS.IsNull()) {
1563     aGP=Handle(Geom_Plane)::DownCast(aGRTS->BasisSurface());
1564   }
1565   else {
1566     aGP=Handle(Geom_Plane)::DownCast(aS);
1567   }
1568   //
1569   bRet=!aGP.IsNull();
1570   //
1571   return bRet;
1572 }
1573
1574 //=======================================================================
1575 //function : MaxTolerance
1576 //purpose  : 
1577 //=======================================================================
1578 Standard_Real BRep_Tool::MaxTolerance (const TopoDS_Shape& theShape,
1579                                        const TopAbs_ShapeEnum theSubShape)
1580 {
1581   Standard_Real aTol = 0.0;
1582
1583   // Explorer Shape-Subshape.
1584   TopExp_Explorer anExpSS(theShape, theSubShape);
1585   if (theSubShape == TopAbs_FACE)
1586   {
1587     for( ; anExpSS.More() ;  anExpSS.Next() )
1588     {
1589       const TopoDS_Shape& aCurrentSubShape = anExpSS.Current();
1590       aTol = Max(aTol, Tolerance(TopoDS::Face(aCurrentSubShape)));
1591     }
1592   }
1593   else if (theSubShape == TopAbs_EDGE)
1594   {
1595     for( ; anExpSS.More() ;  anExpSS.Next() )
1596     {
1597       const TopoDS_Shape& aCurrentSubShape = anExpSS.Current();
1598       aTol = Max(aTol, Tolerance(TopoDS::Edge(aCurrentSubShape)));
1599     }
1600   }
1601   else if (theSubShape == TopAbs_VERTEX)
1602   {
1603     for( ; anExpSS.More() ;  anExpSS.Next() )
1604     {
1605       const TopoDS_Shape& aCurrentSubShape = anExpSS.Current();
1606       aTol = Max(aTol, Tolerance(TopoDS::Vertex(aCurrentSubShape)));
1607     }
1608   }
1609
1610   return aTol;
1611 }