17fedb760c88b09e53e8c3193ce5d18776a1eab2
[occt.git] / src / IntPoly / IntPoly_PlaneSection.cxx
1 // Created on: 1995-07-17
2 // Created by: Stagiaire Alain JOURDAIN
3 // Copyright (c) 1995-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
9 // under the terms of the GNU Lesser General Public 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 <IntPoly_PlaneSection.ixx>
18
19 #include <IntPoly_SequenceOfSequenceOfPnt2d.hxx>
20 #include <IntPoly_IndexedMapOfPnt2d.hxx>
21 #include <IntPoly_Pnt2dHasher.hxx>
22 #include <Precision.hxx>
23 #include <TopExp_Explorer.hxx>
24 #include <TopoDS_Shape.hxx>
25 #include <TopoDS_Edge.hxx>
26 #include <BRep_Tool.hxx>
27 #include <BRep_Builder.hxx>
28 #include <TopoDS.hxx>
29 #include <Poly_Triangulation.hxx>
30 #include <Poly_Polygon3D.hxx>
31 #include <OSD_Chronometer.hxx>
32
33
34 //=======================================================================
35 //function : IntPoly_PlaneSection
36 //purpose  : 
37 //=======================================================================
38
39 IntPoly_PlaneSection::IntPoly_PlaneSection()
40 {}
41
42
43 //=======================================================================
44 //function : IntPoly_PlaneSection
45 //purpose  : 
46 //=======================================================================
47
48 IntPoly_PlaneSection::IntPoly_PlaneSection(const TopoDS_Shape& S,
49                                            const gp_Pln& P)
50 {
51   myShape = S;
52   myTransform.SetTransformation(P.Position()); 
53   gp_Ax3 Ax0(gp_Pnt(0,0,0),gp_Dir(0,0,1));
54   myBackTransform.SetTransformation(P.Position(),Ax0);
55   Section();
56 }
57
58
59 //=======================================================================
60 //function : Section
61 //purpose  : 
62 //=======================================================================
63
64 void IntPoly_PlaneSection::Section()
65
66   TopExp_Explorer ex;
67   Standard_Integer NbTrian,i,i1,i2,i3,Result;
68   Standard_Real Big = Precision::Infinite();
69   Standard_Boolean Inter;
70   //gp_Pnt Nod1,Nod2,Nod3;
71   gp_Pnt2d BegPoint,EndPoint,OutPoint;
72   TopLoc_Location Loc;
73   Handle(Poly_Triangulation) Tr;
74   myCpt = 0;
75   
76   for (ex.Init(myShape,TopAbs_FACE);ex.More();ex.Next()) {
77     Tr = (BRep_Tool::Triangulation(TopoDS::Face(ex.Current()),Loc));
78     if (!Tr.IsNull()) {
79       NbTrian = Tr->NbTriangles();
80       const Poly_Array1OfTriangle& TabTrian = Tr->Triangles();
81       const TColgp_Array1OfPnt&    TabNodes = Tr->Nodes();
82       TColgp_Array1OfPnt  TabTransfNodes(1,Tr->NbNodes());      
83       for (i = 1;i <= Tr->NbNodes();i++) {
84         if (!Loc.IsIdentity())
85           TabTransfNodes(i) = 
86             (TabNodes(i).Transformed(Loc.Transformation()))
87               .Transformed(myTransform);
88         else 
89           TabTransfNodes(i) = TabNodes(i).Transformed(myTransform);
90       }
91       for (i = 1;i <= NbTrian;i++) {
92         TabTrian(i).Get(i1,i2,i3);
93         Inter = Intersect(TabTransfNodes(i1),
94                           TabTransfNodes(i2),
95                           TabTransfNodes(i3),
96                           BegPoint,EndPoint);
97         if (Inter) {
98           if (myMapBegPoints.Contains(BegPoint)) {
99             Standard_Integer Index = myMapBegPoints.FindIndex(BegPoint);
100             Insert(myMapEndPoints.FindKey(Index),BegPoint,EndPoint);
101             myCpt++;
102             myMapBegPoints.Substitute(Index,gp_Pnt2d(Big,myCpt));
103             myMapEndPoints.Substitute(Index,gp_Pnt2d(Big,myCpt));
104           }
105           else if (myMapEndPoints.Contains(EndPoint)) {
106             Standard_Integer Index = myMapEndPoints.FindIndex(EndPoint);
107             Insert(myMapBegPoints.FindKey(Index),EndPoint,BegPoint);
108             myCpt++;
109             myMapBegPoints.Substitute(Index,gp_Pnt2d(Big,myCpt));
110             myMapEndPoints.Substitute(Index,gp_Pnt2d(Big,myCpt));
111           }
112           else {
113             myMapBegPoints.Add(BegPoint);
114             myMapEndPoints.Add(EndPoint);
115           }  
116         }
117       }
118     } 
119   }
120   
121   Standard_Integer NbLinks = myMapBegPoints.Extent();
122   i = 1;
123   while (i <= NbLinks) {
124     if (!(Precision::IsInfinite((myMapBegPoints.FindKey(i)).X()))) {
125       BegPoint = myMapBegPoints.FindKey(i);
126       EndPoint = myMapEndPoints.FindKey(i);
127       myCpt++;
128       myMapBegPoints.Substitute(i,gp_Pnt2d(Big,myCpt));
129       myMapEndPoints.Substitute(i,gp_Pnt2d(Big,myCpt));
130       Result = Concat(BegPoint,EndPoint,OutPoint);
131       if (Result == 2) 
132         ForwConstruction(OutPoint);
133       else
134         if (Result == 1)
135           PrevConstruction(OutPoint);
136         else {
137           ForwConstruction(EndPoint);
138           PrevConstruction(BegPoint);   
139         }
140     }
141     i++;
142   }
143   
144   i = 1;
145   while (i < mySection.Length()) {
146     ConcatSection(mySection.ChangeValue(i),mySection.Length(),i+1);
147     i++;
148   }
149   myNbEdges = mySection.Length();
150 }
151
152
153 //=======================================================================
154 //function : Intersect
155 //purpose  : Determines the 2 2D-points resulting of the intersection
156 //           of the triangle (Point1,Point2,Point3) by the plane
157 //=======================================================================
158
159 Standard_Boolean IntPoly_PlaneSection::Intersect(const gp_Pnt& Point1,
160                                                  const gp_Pnt& Point2,
161                                                  const gp_Pnt& Point3,
162                                                  gp_Pnt2d& OutPoint1,
163                                                  gp_Pnt2d& OutPoint2)
164 {
165   gp_Pnt Pt1 = Point1;
166   gp_Pnt Pt2 = Point2;
167   gp_Pnt Pt3 = Point3;
168   Standard_Real z1 = Pt1.Z();
169   Standard_Real z2 = Pt2.Z();
170   Standard_Real z3 = Pt3.Z();
171   Standard_Boolean intersection = Standard_False;
172
173   if ((z1 == 0) && (z2 == 0) && (z3 == 0)) 
174     return intersection;
175   if ((z1 == 0) && (z2 == 0)) {
176     intersection = Standard_True;
177     OutPoint1.SetCoord(Pt1.X(),Pt1.Y());
178     OutPoint2.SetCoord(Pt2.X(),Pt2.Y());
179     return intersection;
180   }
181   if ((z2 == 0) && (z3 == 0)) {
182     intersection = Standard_True;
183     OutPoint1.SetCoord(Pt2.X(),Pt2.Y());
184     OutPoint2.SetCoord(Pt3.X(),Pt3.Y());
185     return intersection;
186   }
187   if ((z3 == 0) && (z1 == 0)) {
188     intersection = Standard_True;
189     OutPoint1.SetCoord(Pt3.X(),Pt3.Y());
190     OutPoint2.SetCoord(Pt1.X(),Pt1.Y());
191     return intersection;
192   }
193   if (z1 == 0) {
194     if ((z2 < 0) && (z3 > 0)) 
195       intersection = Standard_True;
196     if ((z2 > 0) && (z3 < 0)) {
197       intersection = Standard_True;
198       gp_Pnt Pt = Pt2;
199       Pt2 = Pt3;
200       Pt3 = Pt; 
201     }
202     if (intersection) {
203       Standard_Real u1 = Pt2.X();
204       Standard_Real v1 = Pt2.Y();
205       z1 = Pt2.Z();
206       Standard_Real u2 = Pt3.X();
207       Standard_Real v2 = Pt3.Y();
208       z2 = Pt3.Z();
209       Standard_Real U = u1 - z1 * (u2 - u1)/(z2 - z1);
210       Standard_Real V = v1 - z1 * (v2 - v1)/(z2 - z1);
211       OutPoint1.SetCoord(Pt1.X(),Pt1.Y());
212       OutPoint2.SetCoord(U,V); 
213       return intersection;
214     }
215   }
216   else
217     if (z2 == 0) {
218       if ((z1 < 0) && (z3 > 0)) 
219         intersection = Standard_True;
220       if ((z1 > 0) && (z3 < 0)) {
221         intersection = Standard_True;
222         gp_Pnt Pt = Pt1;
223         Pt1 = Pt3;
224         Pt3 = Pt; 
225       }
226       if (intersection) {
227         Standard_Real u1 = Pt1.X();
228         Standard_Real v1 = Pt1.Y();
229         z1 = Pt1.Z();
230         Standard_Real u2 = Pt3.X();
231         Standard_Real v2 = Pt3.Y();
232         z2 = Pt3.Z();
233         Standard_Real U = u1 - z1 * (u2 - u1)/(z2 - z1);
234         Standard_Real V = v1 - z1 * (v2 - v1)/(z2 - z1);
235         OutPoint1.SetCoord(Pt2.X(),Pt2.Y());
236         OutPoint2.SetCoord(U,V); 
237         return intersection;
238       }
239     }
240     else
241       if (z3 == 0) {
242         if ((z2 < 0) && (z1 > 0)) 
243           intersection = Standard_True;
244         if ((z2 > 0) && (z1 < 0)) {
245           intersection = Standard_True;
246           gp_Pnt Pt = Pt2;
247           Pt2 = Pt1;
248           Pt1 = Pt; 
249         }
250         if (intersection) {
251           Standard_Real u1 = Pt2.X();
252           Standard_Real v1 = Pt2.Y();
253           z1 = Pt2.Z();
254           Standard_Real u2 = Pt1.X();
255           Standard_Real v2 = Pt1.Y();
256           z2 = Pt1.Z();
257           Standard_Real U = u1 - z1 * (u2 - u1)/(z2 - z1);
258           Standard_Real V = v1 - z1 * (v2 - v1)/(z2 - z1);
259           OutPoint1.SetCoord(Pt3.X(),Pt3.Y());
260           OutPoint2.SetCoord(U,V); 
261           return intersection;
262         }
263       }
264   
265   if ((z1 < 0) && (z2 > 0)) 
266     intersection = Standard_True;
267   if ((z1 > 0) && (z2 < 0)) { 
268     intersection = Standard_True;
269     gp_Pnt Pt = Pt1;
270     Pt1 = Pt2;
271     Pt2 = Pt; 
272   }
273   if (intersection) {
274     Standard_Real u1 = Pt1.X();
275     Standard_Real v1 = Pt1.Y();
276     z1 = Pt1.Z();
277     Standard_Real u2 = Pt2.X();
278     Standard_Real v2 = Pt2.Y();
279     z2 = Pt2.Z();
280     Standard_Real U = u1 - z1 * (u2 - u1)/(z2 - z1);
281     Standard_Real V = v1 - z1 * (v2 - v1)/(z2 - z1);
282     OutPoint1.SetCoord(U,V); 
283     intersection = Standard_False;
284     Pt1 = Point1;
285     Pt2 = Point2;
286     z1 = Pt1.Z();
287     z2 = Pt2.Z();
288     if ((z2 < 0) && (z3 > 0)) 
289       intersection = Standard_True;
290     if ((z2 > 0) && (z3 < 0)) {
291       intersection = Standard_True;
292       gp_Pnt Pt = Pt2;
293       Pt2 = Pt3;
294       Pt3 = Pt; 
295     }
296     if (intersection) {
297       u1 = Pt2.X();
298       v1 = Pt2.Y();
299       z1 = Pt2.Z();
300       u2 = Pt3.X();
301       v2 = Pt3.Y();
302       z2 = Pt3.Z();
303       U = u1 - z1 * (u2 - u1)/(z2 - z1);
304       V = v1 - z1 * (v2 - v1)/(z2 - z1);
305       OutPoint2.SetCoord(U,V); 
306       return intersection;
307     }
308     else {
309       intersection = Standard_True;
310       Pt3 = Point3;
311       z3 = Pt3.Z();
312       if ((z3 > 0) && (z1 < 0)) {
313         gp_Pnt Pt = Pt3;
314         Pt3 = Pt1;
315         Pt1 = Pt; 
316       }
317       u1 = Pt3.X();
318       v1 = Pt3.Y();
319       z1 = Pt3.Z();
320       u2 = Pt1.X();
321       v2 = Pt1.Y();
322       z2 = Pt1.Z();
323       U = u1 - z1 * (u2 - u1)/(z2 - z1);
324       V = v1 - z1 * (v2 - v1)/(z2 - z1);
325       OutPoint2.SetCoord(U,V); 
326       return intersection;
327     }
328   }
329   else {
330     if ((z2 < 0) && (z3 > 0)) 
331       intersection = Standard_True;
332     if ((z2 > 0) && (z3 < 0)) {
333       intersection = Standard_True;
334       gp_Pnt Pt = Pt2;
335       Pt2 = Pt3;
336       Pt3 = Pt; 
337     }
338     if (intersection) {
339       Standard_Real u1 = Pt2.X();
340       Standard_Real v1 = Pt2.Y();
341       z1 = Pt2.Z();
342       Standard_Real u2 = Pt3.X();
343       Standard_Real v2 = Pt3.Y();
344       z2 = Pt3.Z();
345       Standard_Real U = u1 - z1 * (u2 - u1)/(z2 - z1);
346       Standard_Real V = v1 - z1 * (v2 - v1)/(z2 - z1);
347       OutPoint1.SetCoord(U,V); 
348       Pt3 = Point3;
349       z3 = Pt3.Z();
350       if ((z3 > 0) && (z1 < 0)) {
351         gp_Pnt Pt = Pt3;
352         Pt3 = Pt1;
353         Pt1 = Pt; 
354       }
355       u1 = Pt3.X();
356       v1 = Pt3.Y();
357       z1 = Pt3.Z();
358       u2 = Pt1.X();
359       v2 = Pt1.Y();
360       z2 = Pt1.Z();
361       U = u1 - z1 * (u2 - u1)/(z2 - z1);
362       V = v1 - z1 * (v2 - v1)/(z2 - z1);
363       OutPoint2.SetCoord(U,V); 
364       return intersection;
365     }
366   }
367   return intersection;
368 }
369
370
371 //=======================================================================
372 //function : Insert
373 //purpose  : Sees whether OldPnt and NewPnt begins or ends a section
374 //           created before and adds the 2 others points.
375 //           If not, creates a section
376 //=======================================================================
377
378 void IntPoly_PlaneSection::Insert(const gp_Pnt2d& OldPnt,
379                                   const gp_Pnt2d& ComPnt,
380                                   const gp_Pnt2d& NewPnt)
381 {
382   Standard_Integer i = 0;
383   Standard_Integer NbSection = mySection.Length();
384   Standard_Boolean IsInSection = Standard_False;
385   
386   while (i < NbSection) {
387     i++;
388     TColgp_SequenceOfPnt2d& CurSection = mySection.ChangeValue(i);
389     if (IntPoly_Pnt2dHasher::IsEqual(OldPnt,CurSection.First())) {
390       IsInSection = Standard_True;
391       CurSection.Prepend(ComPnt);
392       CurSection.Prepend(NewPnt);
393       break;
394     }
395     if (IntPoly_Pnt2dHasher::IsEqual(OldPnt,CurSection.Last())) {
396       IsInSection = Standard_True;
397       CurSection.Append(ComPnt);
398       CurSection.Append(NewPnt);
399       break;
400     }
401     if (IntPoly_Pnt2dHasher::IsEqual(NewPnt,CurSection.First())) {
402       IsInSection = Standard_True;
403       CurSection.Prepend(ComPnt);
404       CurSection.Prepend(OldPnt);
405       break;
406     }
407     if (IntPoly_Pnt2dHasher::IsEqual(NewPnt,CurSection.Last())) {
408       IsInSection = Standard_True;
409       CurSection.Append(ComPnt);
410       CurSection.Append(OldPnt);
411       break;
412     }
413   }
414   if (!(IsInSection)) {
415     TColgp_SequenceOfPnt2d EmptySec;
416     EmptySec.Append(OldPnt);
417     EmptySec.Append(ComPnt);
418     EmptySec.Append(NewPnt);
419     mySection.Append(EmptySec);
420   }  
421 }
422
423
424 //=======================================================================
425 //function : Concat
426 //purpose  : sees whether BegPnt or EndPnt begins or ends a section
427 //           created before, and returns the other point to continue 
428 //           the construction
429 //           Returns 2 if the construction is 'Forward'
430 //           Returns 1 if the construction is 'Previous'
431 //           Returns 0 if not and creates a section
432 //=======================================================================
433
434 Standard_Integer IntPoly_PlaneSection::Concat(const gp_Pnt2d& BegPnt,
435                                               const gp_Pnt2d& EndPnt,
436                                               gp_Pnt2d& OutPnt)
437 {
438   Standard_Integer i = 0;
439   Standard_Integer NbSection = mySection.Length();
440   Standard_Integer ConcatIdx = 0;
441   
442   while (i < NbSection) {
443     i++;
444     TColgp_SequenceOfPnt2d& CurSection = mySection.ChangeValue(i);
445     if (IntPoly_Pnt2dHasher::IsEqual(BegPnt,CurSection.First())) {
446       ConcatIdx = 1;
447       myIndex = i;
448       CurSection.Prepend(EndPnt);
449       OutPnt = EndPnt;
450       break;
451     }
452     if (IntPoly_Pnt2dHasher::IsEqual(BegPnt,CurSection.Last())) {
453       ConcatIdx = 2;
454       myIndex = i;
455       CurSection.Append(EndPnt);
456       OutPnt = EndPnt;
457       break;
458     }
459     if (IntPoly_Pnt2dHasher::IsEqual(EndPnt,CurSection.First())) {
460       ConcatIdx = 1;
461       myIndex = i;
462       CurSection.Prepend(BegPnt);
463       OutPnt = BegPnt;
464       break;
465     }
466     if (IntPoly_Pnt2dHasher::IsEqual(EndPnt,CurSection.Last())) {
467       ConcatIdx = 2;
468       myIndex = i;
469       CurSection.Append(BegPnt);
470       OutPnt = BegPnt;
471       break;
472     }
473   }
474   if (ConcatIdx == 0) {
475     TColgp_SequenceOfPnt2d EmptySec;
476     EmptySec.Append(BegPnt);
477     EmptySec.Append(EndPnt);
478     mySection.Append(EmptySec);
479     NbSection++;
480     myIndex = NbSection;
481   }  
482   return ConcatIdx;
483 }
484
485
486 //=======================================================================
487 //function : ConcatSection
488 //purpose  : Sees whether Section begins or ends another one in  mySection,
489 //           from the rank 'Index' to the last one 'NbSection'
490 //=======================================================================
491
492 void IntPoly_PlaneSection::ConcatSection(TColgp_SequenceOfPnt2d& Section,
493                                          const Standard_Integer NbSection,
494                                          const Standard_Integer Index)
495 {
496   Standard_Integer j;
497   Standard_Integer i = Index;
498   gp_Pnt2d BegPnt = Section.First();
499   gp_Pnt2d EndPnt = Section.Last();
500
501   while (i <= NbSection) {
502     TColgp_SequenceOfPnt2d& CurSection = mySection.ChangeValue(i);
503     Standard_Integer CurSection_Length = CurSection.Length(); 
504     if (IntPoly_Pnt2dHasher::IsEqual(BegPnt,CurSection.First())) {
505       for (j = 2;j <= CurSection_Length;j++) 
506         Section.Prepend(CurSection.Value(j));
507       mySection.Remove(i);
508       ConcatSection(Section,NbSection-1,Index);
509       break;
510     }
511     else
512       if (IntPoly_Pnt2dHasher::IsEqual(BegPnt,CurSection.Last())) {
513         for (j = CurSection_Length-1;j >= 1;j--) 
514           Section.Prepend(CurSection.Value(j));
515         mySection.Remove(i);
516         ConcatSection(Section,NbSection-1,Index);
517         break;
518       }
519       else
520         if (IntPoly_Pnt2dHasher::IsEqual(EndPnt,CurSection.First())) {
521           for (j = 2;j <= CurSection_Length;j++) 
522             Section.Append(CurSection.Value(j));
523           mySection.Remove(i);
524           ConcatSection(Section,NbSection-1,Index);
525           break;
526         }
527         else
528           if (IntPoly_Pnt2dHasher::IsEqual(EndPnt,CurSection.Last())) {
529             for (j = CurSection_Length-1;j >= 1;j--) 
530               Section.Append(CurSection.Value(j));
531             mySection.Remove(i);
532             ConcatSection(Section,NbSection-1,Index);
533             break;
534           }
535     i++;
536   }
537 }
538
539
540 //=======================================================================
541 //function : ForwContruction
542 //purpose  : Builds a section from Point in this way  
543 //                    ___   ___   ___   ___
544 //               <---/__/--/__/--/__/--/__/--Point
545 //=======================================================================
546
547 void IntPoly_PlaneSection::ForwConstruction(const gp_Pnt2d& Point)
548 {
549   if (myMapBegPoints.Contains(Point)) {
550     Standard_Integer Index = myMapBegPoints.FindIndex(Point);
551     gp_Pnt2d Pnt = myMapEndPoints.FindKey(Index);
552     (mySection.ChangeValue(myIndex)).Append(Pnt);
553     Standard_Real Big = Precision::Infinite();
554     myCpt++;
555     myMapBegPoints.Substitute(Index,gp_Pnt2d(Big,myCpt));
556     myMapEndPoints.Substitute(Index,gp_Pnt2d(Big,myCpt));
557     ForwConstruction(Pnt);
558   }
559 }
560
561
562 //=======================================================================
563 //function : PrevContruction
564 //purpose  : Builds a section from Point in this way  
565 //                      ___   ___   ___   ___
566 //              Point--/__/--/__/--/__/--/__/--->
567 //=======================================================================
568
569 void IntPoly_PlaneSection::PrevConstruction(const gp_Pnt2d& Point)
570 {
571   if (myMapEndPoints.Contains(Point)) {
572     Standard_Integer Index = myMapEndPoints.FindIndex(Point);
573     gp_Pnt2d Pnt = myMapBegPoints.FindKey(Index);
574     (mySection.ChangeValue(myIndex)).Prepend(Pnt);
575     Standard_Real Big = Precision::Infinite();
576     myCpt++;
577     myMapBegPoints.Substitute(Index,gp_Pnt2d(Big,myCpt));
578     myMapEndPoints.Substitute(Index,gp_Pnt2d(Big,myCpt));
579     PrevConstruction(Pnt);
580   }
581 }
582
583
584 //=======================================================================
585 //function : NbEdges
586 //purpose  : Returns the final number of edges in the section
587 //=======================================================================
588
589 Standard_Integer IntPoly_PlaneSection::NbEdges()
590 { return myNbEdges; }
591
592
593 //=======================================================================
594 //function : Edge
595 //purpose  : Builds the edges of the section
596 //=======================================================================
597
598 TopoDS_Edge IntPoly_PlaneSection::Edge(const Standard_Integer Index)
599 {
600   const TColgp_SequenceOfPnt2d& CurSection = mySection.ChangeValue(Index);
601   Standard_Integer NbPoints = CurSection.Length();
602   TColgp_Array1OfPnt TabPnt(1,NbPoints);
603   gp_Pnt CurPoint;
604   for (Standard_Integer i = 1 ; i <= NbPoints ; i++) {
605     CurPoint.SetX((CurSection.Value(i)).X());
606     CurPoint.SetY((CurSection.Value(i)).Y());
607     CurPoint.SetZ(0);
608     TabPnt.SetValue(i,CurPoint.Transformed(myBackTransform));
609   }
610   Handle(Poly_Polygon3D) Pol = new Poly_Polygon3D(TabPnt);
611   TopoDS_Edge Edge;
612   BRep_Builder B;
613   B.MakeEdge(Edge,Pol);
614   return Edge;
615 }
616
617
618
619
620
621
622
623