0027232: Configuration - fix mblen missing building issue on Android
[occt.git] / src / BRepFill / BRepFill_Generator.cxx
1 // Created on: 1994-03-07
2 // Created by: Bruno DUMORTIER
3 // Copyright (c) 1994-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_Builder.hxx>
19 #include <BRep_Tool.hxx>
20 #include <BRepFill_Generator.hxx>
21 #include <BRepLib.hxx>
22 #include <BRepTools.hxx>
23 #include <BRepTools_WireExplorer.hxx>
24 #include <Geom2d_BezierCurve.hxx>
25 #include <Geom2d_Line.hxx>
26 #include <Geom_BezierCurve.hxx>
27 #include <Geom_BSplineCurve.hxx>
28 #include <Geom_Circle.hxx>
29 #include <Geom_ConicalSurface.hxx>
30 #include <Geom_Curve.hxx>
31 #include <Geom_CylindricalSurface.hxx>
32 #include <Geom_Line.hxx>
33 #include <Geom_Plane.hxx>
34 #include <Geom_RectangularTrimmedSurface.hxx>
35 #include <Geom_Surface.hxx>
36 #include <Geom_TrimmedCurve.hxx>
37 #include <GeomAbs_Shape.hxx>
38 #include <GeomAdaptor_Curve.hxx>
39 #include <GeomConvert.hxx>
40 #include <GeomFill.hxx>
41 #include <GeomFill_Generator.hxx>
42 #include <gp_Ax1.hxx>
43 #include <gp_Ax3.hxx>
44 #include <gp_Circ.hxx>
45 #include <gp_Dir2d.hxx>
46 #include <gp_Lin.hxx>
47 #include <gp_Pnt2d.hxx>
48 #include <gp_Vec.hxx>
49 #include <Precision.hxx>
50 #include <Standard_NullObject.hxx>
51 #include <TColgp_Array1OfPnt.hxx>
52 #include <TColgp_Array1OfPnt2d.hxx>
53 #include <TopExp.hxx>
54 #include <TopExp_Explorer.hxx>
55 #include <TopLoc_Location.hxx>
56 #include <TopoDS.hxx>
57 #include <TopoDS_Edge.hxx>
58 #include <TopoDS_Face.hxx>
59 #include <TopoDS_Shape.hxx>
60 #include <TopoDS_Shell.hxx>
61 #include <TopoDS_Vertex.hxx>
62 #include <TopoDS_Wire.hxx>
63 #include <TopTools_DataMapOfShapeShape.hxx>
64
65 //=======================================================================
66 //function : DetectKPart
67 //purpose  : 
68 //=======================================================================
69 Standard_Integer DetectKPart(const TopoDS_Edge& Edge1,
70                              const TopoDS_Edge& Edge2)
71 {
72   // initializations
73   Standard_Integer IType = 0;
74
75   // characteristics of the first edge
76   Standard_Real first1 = 0., last1 = 0., first2, last2, ff, ll;
77   TopLoc_Location loc;
78   TopoDS_Vertex V1, V2;
79   Handle(Geom_Curve) curv1, curv;
80   GeomAdaptor_Curve AdC1;
81   Standard_Boolean degen1 = BRep_Tool::Degenerated(Edge1);
82
83   // find the particular case
84   gp_Pnt pos1, pos;
85   Standard_Real  dist;
86   Standard_Real dist1 =0.;
87   gp_Ax1 axe1, axe;
88
89   if (degen1) {
90     IType = -2;
91     TopExp::Vertices(Edge1,V1,V2);
92     pos1 = BRep_Tool::Pnt(V1);
93   }
94   else {
95     curv1 = BRep_Tool::Curve(Edge1, loc, first1, last1);
96     if (curv1.IsNull())
97       Standard_NullObject::Raise("Null 3D curve in edge");
98     curv1 = 
99       Handle(Geom_Curve)::DownCast(curv1->Transformed(loc.Transformation()));
100     ff = first1;
101     ll = last1;
102     if (Edge1.Orientation() == TopAbs_REVERSED) {
103       curv1->Reverse();
104       first1 = curv1->ReversedParameter(ll);
105       last1 = curv1->ReversedParameter(ff);
106     }
107     AdC1.Load(curv1);
108     if (AdC1.GetType() == GeomAbs_Circle) {
109       // first circular section 
110       IType = 1;
111       pos1 = AdC1.Circle().Location();
112       dist1 = AdC1.Circle().Radius();
113       axe1 = AdC1.Circle().Axis();
114     }
115     else if (AdC1.GetType() == GeomAbs_Line) {
116       // first straight line section 
117       IType = 4;
118       pos1 = AdC1.Line().Location();
119       dist1 = AdC1.Value(first1).Distance(AdC1.Value(last1));
120       gp_Vec vec(AdC1.Value(first1),AdC1.Value(last1));
121       gp_Dir dir(vec);
122       axe1 = gp_Ax1(AdC1.Value(first1),dir);
123     }
124     else {
125       // first section of any type
126       IType = 0;
127     }
128   }
129
130   if (IType!=0) {
131
132     Standard_Boolean degen2 = BRep_Tool::Degenerated(Edge2);
133     if (degen2) {
134       TopExp::Vertices(Edge2,V1,V2);
135       pos = BRep_Tool::Pnt(V1);
136       if (IType==1) {
137         // the only particular case with degenerated edge at end : the cone
138         if (pos.IsEqual(pos1,Precision::Confusion())) {
139           // the top is mixed with the center of the circle
140           IType = 0;
141         }
142         else {
143           gp_Vec vec(pos1,pos);
144           gp_Dir dir(vec);
145           axe = gp_Ax1(pos1,dir);
146           if (axe.IsParallel(axe1,Precision::Angular())) {
147             // the top is on the axis of the circle
148             IType = 2;
149           }
150           else {
151             // incorrect top --> no particular case
152             IType = 0;
153           }
154         }
155       }
156       else if (IType != 4) { //not a plane
157         // no particular case
158         IType = 0;
159       }
160     }
161     else {
162       curv = BRep_Tool::Curve(Edge2, loc, first2, last2);
163       if (curv.IsNull())
164         Standard_NullObject::Raise("Null 3D curve in edge");
165       curv = 
166         Handle(Geom_Curve)::DownCast(curv->Transformed(loc.Transformation()));
167       ff = first2;
168       ll = last2;
169       if (Edge2.Orientation() == TopAbs_REVERSED) {
170         curv->Reverse();
171         first2 = curv->ReversedParameter(ll);
172         last2 = curv->ReversedParameter(ff);
173       }
174       GeomAdaptor_Curve AdC(curv);
175     
176       if (IType>0 && IType<4) {
177         if (AdC.GetType() != GeomAbs_Circle) {
178           // section not circular --> no particular case
179           IType = 0;
180         }
181         else {
182           if (AdC.Circle().Axis()
183               .IsCoaxial(axe1,Precision::Angular(),Precision::Confusion())) {
184             // same axis
185             if (Abs(AdC.Circle().Radius()-dist1)< Precision::Confusion()) {
186               // possibility of cylinder or a piece of cylinder
187               Standard_Real h1 = Abs(last1-first1), h2 = Abs(last2-first2);
188               Standard_Boolean Same, 
189                SameParametricLength = ( Abs(h1-h2) < Precision::PConfusion() );
190               Standard_Real m1=(first1+last1)/2., m2=(first2+last2)/2.;
191               gp_Pnt P1,P2;
192               gp_Vec DU;
193               AdC1.D1(m1,P1,DU);
194               AdC.D0(m2,P2);
195               Same = SameParametricLength 
196                 && ( gp_Vec(P1,P2).IsNormal(DU,Precision::Angular()) ) ;
197               if (Same) {
198                 // cylinder or piece of cylinder
199                 IType = 1;
200               }
201               else {
202                 // the interval of definition is not correct
203                 IType = 0;
204               }
205             }
206             else {
207               // possibility of cone truncation
208               Standard_Real h1 = Abs(last1-first1), h2 = Abs(last2-first2);
209               Standard_Boolean Same, 
210                SameParametricLength = ( Abs(h1-h2) < Precision::PConfusion() );
211               Standard_Real m1=(first1+last1)/2., m2=(first2+last2)/2.;
212               gp_Pnt P1,P2;
213               gp_Vec DU;
214               AdC1.D1(m1,P1,DU);
215               AdC.D0(m2,P2);
216               Same = SameParametricLength 
217                 && ( gp_Vec(P1,P2).IsNormal(DU,Precision::Angular()) ) ;
218               if (Same) {
219                 // truncation of cone
220                 IType = 2;
221               }
222               else {
223                 // the interval of definition is not correct
224                 IType = 0;
225               }
226             }
227             if (AdC.Circle().Location().IsEqual(pos1,Precision::Confusion())) {
228               // the centers are mixed
229               IType = 0;
230             }
231           }
232           else {
233             // different axis
234             if (AdC.Circle().Radius()==dist1) {
235               // torus ?
236               IType = 3;
237             }
238             else {
239               // different radius --> no particular case
240               IType = 0;
241             }
242           }
243         }
244       }
245       else if (IType>=4) {
246         if (AdC.GetType() != GeomAbs_Line) {
247           // not a straight line section --> no particular case
248           IType = 0;
249         }
250         else {
251           pos = AdC.Line().Location();
252           dist = AdC.Value(first2).Distance(AdC.Value(last2));
253           gp_Vec vec(AdC.Value(first2),AdC.Value(last2));
254           gp_Dir aDir(vec);
255           axe = gp_Ax1(AdC.Value(first2), aDir);
256           if (axe.IsParallel(axe1,Precision::Angular())) {
257             // parallel straight line
258             if (Abs(dist-dist1)<Precision::Confusion()) {
259               gp_Dir dir(gp_Vec(AdC1.Value(first1),AdC.Value(first2)));
260               if (dir.IsNormal(gp_Dir(vec),Precision::Angular())) {
261                 // plane
262                 IType = 4;
263               }
264               else {
265                 // extrusion ?
266                 IType = 5;
267               }
268             }
269             else {
270               // different length --> no particular case
271               IType = 0;
272             }
273           }
274           else {
275             // not parallel straight line --> no particular case
276             IType = 0;
277           }
278         }
279       }
280       else if (IType==-2) {
281         if (AdC.GetType() == GeomAbs_Line)
282           IType = 4; //plane
283         else if (AdC.GetType() == GeomAbs_Circle)
284           {
285             // the only particular case with degenerated edge at the beginning the cone
286             pos = AdC.Circle().Location();
287             axe = AdC.Circle().Axis();
288             if (pos1.IsEqual(pos,Precision::Confusion())) {
289               // the top is mixed with the center of the circle
290               IType = 0;
291             }
292             else {
293               gp_Vec vec(pos1,pos);
294               gp_Dir dir(vec);
295               axe1 = gp_Ax1(pos1,dir);
296               if (axe.IsParallel(axe1,Precision::Angular())) {
297                 // the top is on the axis of the circle
298                 IType = -2;
299               }
300               else {
301                 // incorrect top --> no particular case
302                 IType = 0;
303               }
304             }
305           }
306         else
307           IType = 0;
308       }
309     }
310     
311   }
312   // torus and extrusion are not particular cases.
313   if (IType == 3 || IType == 5) IType = 0;
314   return IType;
315 }
316
317
318 //=======================================================================
319 //function : CreateKPart
320 //purpose  : 
321 //=======================================================================
322
323 void CreateKPart(const TopoDS_Edge& Edge1,const TopoDS_Edge& Edge2,
324                  const Standard_Integer IType, 
325                  Handle(Geom_Surface)& Surf)
326 {
327   // find the dimension
328   TopoDS_Vertex V1, V2;
329
330   TopLoc_Location loc;
331   Standard_Real a1, b1, aa =0., bb =0.;
332   TopoDS_Vertex v1f,v1l,v2f,v2l;
333
334   // find characteristics of the first edge
335   Handle(Geom_Curve) C1;
336   Standard_Boolean degen1 = BRep_Tool::Degenerated(Edge1);
337   if(degen1) {
338     // cone with degenerated edge at the top
339     TopExp::Vertices(Edge1,v1f,v1l);
340   }
341   else {
342     C1 = BRep_Tool::Curve(Edge1, loc, a1, b1);
343     if (C1.IsNull())
344       Standard_NullObject::Raise("Null 3D curve in edge");
345     C1 = Handle(Geom_Curve)::DownCast(C1->Transformed(loc.Transformation()));
346     aa = a1;
347     bb = b1;
348     if (Edge1.Orientation() == TopAbs_REVERSED) {
349       C1->Reverse();
350       aa = C1->ReversedParameter(b1);
351       bb = C1->ReversedParameter(a1);
352       TopExp::Vertices(Edge1,v1l,v1f);
353     }
354     else {
355       TopExp::Vertices(Edge1,v1f,v1l);
356     }
357   }
358
359   // find characteristics of the second edge
360   Handle(Geom_Curve) C2;
361   Standard_Boolean degen2 = BRep_Tool::Degenerated(Edge2);
362   if(degen2) {
363     // cone with degenerated edge at the top
364     TopExp::Vertices(Edge2,v2f,v2l);
365   }
366   else {
367     C2 = BRep_Tool::Curve(Edge2, loc, a1, b1);
368     if (C2.IsNull())
369       Standard_NullObject::Raise("Null 3D curve in edge");
370     C2 = Handle(Geom_Curve)::DownCast(C2->Transformed(loc.Transformation()));
371     if (Edge2.Orientation() == TopAbs_REVERSED) {
372       C2->Reverse();
373       if (degen1) {
374         aa = a1;
375         bb = b1;
376       }
377       TopExp::Vertices(Edge2,v2l,v2f);
378     }
379     else {
380       if (degen1) {
381         aa = a1; //C2->ReversedParameter(b1);
382         bb = b1; //C2->ReversedParameter(a1);
383       }
384       TopExp::Vertices(Edge2,v2f,v2l);
385     }
386   }
387
388   // create the new surface
389   TopoDS_Face face;
390   TopoDS_Wire W;
391   TopoDS_Edge edge1, edge2, edge3, edge4, couture;
392
393   TopoDS_Wire newW1, newW2;
394   BRep_Builder BW1, BW2;
395   BW1.MakeWire(newW1);
396   BW2.MakeWire(newW2);
397
398   GeomAdaptor_Curve aC1Adaptor;
399   if (!C1.IsNull())
400     aC1Adaptor.Load(C1);
401   GeomAdaptor_Curve aC2Adaptor;
402   if (!C2.IsNull())
403     aC2Adaptor.Load(C2);
404
405   // calculate the surface
406   Handle(Geom_Surface) surface;
407   Standard_Real V, Rad;
408   if (IType==1) {
409     // cylindrical surface
410     gp_Circ c1 = aC1Adaptor.Circle();
411     gp_Circ c2 = aC2Adaptor.Circle();
412     gp_Ax3 Ac1 = c1.Position();
413     V = gp_Vec( c1.Location(),c2.Location()).Dot(gp_Vec(Ac1.Direction()));
414     if ( V < 0.) {
415       Ac1.ZReverse();
416       V = -V;
417     }
418     Handle(Geom_CylindricalSurface) Cyl = 
419       new Geom_CylindricalSurface( Ac1, c1.Radius());
420     surface = new Geom_RectangularTrimmedSurface
421       ( Cyl, aa, bb, Min(0.,V), Max(0.,V) );
422   }
423   else if (IType==2) {
424     // conical surface
425     gp_Circ k1 = aC1Adaptor.Circle();
426     gp_Ax3 Ak1 = k1.Position();
427     if (degen2) {
428       V = gp_Vec( k1.Location(),BRep_Tool::Pnt(v2f))
429         .Dot(gp_Vec(Ak1.Direction()));
430       Rad = - k1.Radius();
431     }
432     else {
433       gp_Circ k2 = aC2Adaptor.Circle();
434       V = gp_Vec( k1.Location(),k2.Location()).Dot(gp_Vec(Ak1.Direction()));
435       Rad = k2.Radius() - k1.Radius();
436     }
437       
438     if ( V < 0.) {
439       Ak1.ZReverse();
440       V = -V;
441     }
442     Standard_Real Ang = ATan( Rad / V);
443     Handle(Geom_ConicalSurface) Cone = 
444       new Geom_ConicalSurface( Ak1, Ang, k1.Radius());
445     V /= Cos(Ang);
446     surface = new Geom_RectangularTrimmedSurface
447       ( Cone, aa, bb, Min(0.,V), Max(0.,V) );
448   }
449   else if (IType==-2) {
450     // conical surface with the top at the beginning (degen1 is true)
451     gp_Circ k2 = aC2Adaptor.Circle();
452     gp_Ax3 Ak2 = k2.Position();
453     Ak2.SetLocation(BRep_Tool::Pnt(v1f));
454     V = gp_Vec(BRep_Tool::Pnt(v1f),k2.Location())
455                                 .Dot(gp_Vec(Ak2.Direction()));
456     Rad = k2.Radius(); // - k2.Radius();      
457     if ( V < 0.) {
458       Ak2.ZReverse();
459       V = -V;
460     }
461     Standard_Real Ang = ATan( Rad / V);
462     Handle(Geom_ConicalSurface) Cone = 
463       new Geom_ConicalSurface( Ak2, Ang, 0.);
464     V /= Cos(Ang);
465     surface = new Geom_RectangularTrimmedSurface
466       ( Cone, aa, bb, Min(0.,V), Max(0.,V) );
467   }
468   else if (IType==3) {
469     // torus surface ?
470   }
471   else if (IType==4) {
472     // surface plane
473     gp_Lin L1, L2, aLine;
474     if (!degen1)
475     {
476       L1 = aC1Adaptor.Line();
477       aLine = L1;
478     }
479     if (!degen2)
480     {
481       L2 = aC2Adaptor.Line();
482       aLine = L2;
483     }
484
485     gp_Pnt P1 = (degen1)? BRep_Tool::Pnt(v1f) : L1.Location();
486     gp_Pnt P2 = (degen2)? BRep_Tool::Pnt(v2f) : L2.Location();
487
488     gp_Vec P1P2( P1, P2 ); 
489     gp_Dir D1 = aLine.Direction();
490     gp_Ax3 Ax( aLine.Location(), gp_Dir(D1.Crossed(P1P2)), D1 );
491     Handle(Geom_Plane) Plan = new Geom_Plane(Ax);
492     V = P1P2.Dot( Ax.YDirection());
493     surface = Plan;
494     //surface = new Geom_RectangularTrimmedSurface
495       //( Plan, aa, bb, Min(0.,V), Max(0.,V) );
496   }
497   else if (IType==5) {
498     // surface of extrusion ?
499   }
500   else {
501     // IType incorrect
502   }
503   Surf = surface;
504 }
505
506
507 //=======================================================================
508 //function : BRepFill_Generator
509 //purpose  : 
510 //=======================================================================
511
512 BRepFill_Generator::BRepFill_Generator()
513 {
514 }
515
516
517 //=======================================================================
518 //function : AddWire
519 //purpose  : 
520 //=======================================================================
521
522 void BRepFill_Generator::AddWire(const TopoDS_Wire& Wire)
523 {
524   myWires.Append( Wire);
525 }
526
527
528 //=======================================================================
529 //function : Perform
530 //purpose  : 
531 //=======================================================================
532
533 void BRepFill_Generator::Perform()
534 {
535   TopoDS_Shell Shell;
536   TopoDS_Face  Face;
537   TopoDS_Shape S1, S2;
538   TopoDS_Edge  Edge1, Edge2, Edge3, Edge4, Couture;
539
540   BRep_Builder B;
541   B.MakeShell(myShell);
542
543   Standard_Integer Nb = myWires.Length();
544
545   BRepTools_WireExplorer ex1,ex2;
546
547   Standard_Boolean wPoint1, wPoint2, uClosed = Standard_False, DegenFirst = Standard_False, DegenLast = Standard_False;
548   
549   for ( Standard_Integer i = 1; i <= Nb-1; i++) {
550
551     TopoDS_Wire Wire1 = TopoDS::Wire(myWires( i ));
552     TopoDS_Wire Wire2 = TopoDS::Wire(myWires(i+1));
553
554     wPoint1 = Standard_False;
555     if (i==1) {
556       wPoint1 = Standard_True;
557       for(ex1.Init(Wire1); ex1.More(); ex1.Next()) {
558         wPoint1 = wPoint1 && (BRep_Tool::Degenerated(ex1.Current()));
559       }
560       DegenFirst = wPoint1;
561
562       TopoDS_Vertex V1, V2;
563       TopExp::Vertices(Wire1, V1, V2);
564       uClosed = V1.IsSame(V2);
565     }
566
567     wPoint2 = Standard_False;
568     if (i==Nb-1) {
569       wPoint2 = Standard_True;
570       for(ex2.Init(Wire2); ex2.More(); ex2.Next()) {
571         wPoint2 = wPoint2 && (BRep_Tool::Degenerated(ex2.Current()));
572       }
573       DegenLast = wPoint2;
574     }
575
576     ex1.Init(Wire1);
577     ex2.Init(Wire2);
578
579     TopTools_DataMapOfShapeShape Map;
580     
581     Standard_Boolean tantque = ex1.More() && ex2.More();
582
583     while ( tantque ) { 
584
585       TopoDS_Vertex V1f,V1l,V2f,V2l, Vf_toMap, Vl_toMap;
586
587       Standard_Boolean degen1 
588         = BRep_Tool::Degenerated(TopoDS::Edge(ex1.Current()));
589       Standard_Boolean degen2
590         = BRep_Tool::Degenerated(TopoDS::Edge(ex2.Current()));
591
592       if ( degen1 ) {
593         TopoDS_Shape aLocalShape = ex1.Current().EmptyCopied();
594         Edge1 = TopoDS::Edge(aLocalShape);
595 //      Edge1 = TopoDS::Edge(ex1.Current().EmptyCopied());
596 //      aLocalShape = ex1.Current();
597 //      TopExp::Vertices(TopoDS::Edge(aLocalShape),V1f,V1l);
598         TopExp::Vertices(TopoDS::Edge(ex1.Current()),V1f,V1l);
599         V1f.Orientation(TopAbs_FORWARD);
600         B.Add(Edge1,V1f);
601         V1l.Orientation(TopAbs_REVERSED);
602         B.Add(Edge1,V1l);
603         B.Range(Edge1,0,1);
604       }
605       else {
606         TopoDS_Shape aLocalShape = ex1.Current();
607         Edge1 = TopoDS::Edge(aLocalShape);
608 //      Edge1 = TopoDS::Edge(ex1.Current());
609       }
610
611       if ( degen2 ) {
612         TopoDS_Shape aLocalShape = ex2.Current().EmptyCopied();
613         Edge2 = TopoDS::Edge(aLocalShape);
614 //      Edge2 = TopoDS::Edge(ex2.Current().EmptyCopied());
615         TopExp::Vertices(TopoDS::Edge(ex2.Current()),V2f,V2l);
616         V2f.Orientation(TopAbs_FORWARD);
617         B.Add(Edge2,V2f);
618         V2l.Orientation(TopAbs_REVERSED);
619         B.Add(Edge2,V2l);
620         B.Range(Edge2,0,1);
621       }
622       else {
623         Edge2 = TopoDS::Edge(ex2.Current());
624       }
625
626       Standard_Boolean Periodic = (BRep_Tool::IsClosed(Edge1) || degen1) &&
627                                   (BRep_Tool::IsClosed(Edge2) || degen2);
628       // ATTENTION : a non-punctual wire should not 
629       //             contain a punctual edge
630       if (!wPoint1) ex1.Next();
631       if (!wPoint2) ex2.Next();
632
633       // initialization of vertices
634       Handle(Geom_Surface) Surf;
635       Standard_Real f1=0, l1=1, f2=0, l2=1;
636       if (Edge1.Orientation() == TopAbs_REVERSED)
637         TopExp::Vertices(Edge1,V1l,V1f);
638       else
639         TopExp::Vertices(Edge1,V1f,V1l);
640       if (Edge2.Orientation() == TopAbs_REVERSED)
641         TopExp::Vertices(Edge2,V2l,V2f);
642       else
643         TopExp::Vertices(Edge2,V2f,V2l);
644       if (degen1)
645         {
646           Vf_toMap = V2f;
647           Vl_toMap = V2l;
648         }
649       else
650         {
651           Vf_toMap = V1f;
652           Vl_toMap = V1l;
653         }
654
655       // processing of KPart
656       Standard_Integer IType = DetectKPart(Edge1,Edge2);
657       if (IType==0) {
658         // no part cases
659         TopLoc_Location L,L1,L2;
660
661         Handle(Geom_Curve) C1, C2;
662         TColgp_Array1OfPnt Extremities(1,2);
663       
664         if (degen1) {
665           Extremities(1) = BRep_Tool::Pnt(V1f);
666           Extremities(2) = BRep_Tool::Pnt(V1l);
667           C1 = new Geom_BezierCurve(Extremities);
668         }
669         else {
670           C1 = BRep_Tool::Curve(Edge1,L1,f1,l1);
671           if (C1.IsNull())
672             Standard_NullObject::Raise("Null 3D curve in edge");
673         }
674         if (degen2) {
675           Extremities(1) = BRep_Tool::Pnt(V2l);
676           Extremities(2) = BRep_Tool::Pnt(V2f);
677           C2 = new Geom_BezierCurve(Extremities);
678         }
679         else {
680           C2 = BRep_Tool::Curve(Edge2,L2,f2,l2);
681           if (C2.IsNull())
682             Standard_NullObject::Raise("Null 3D curve in edge");
683         }
684         
685         // compute the location
686         Standard_Boolean SameLoc = Standard_False;
687         
688         // transform and trim the curves
689       
690         if (Abs(f1 - C1->FirstParameter()) > Precision::PConfusion() ||
691             Abs(l1 - C1->LastParameter())  > Precision::PConfusion()   ) {
692           C1 = new Geom_TrimmedCurve(C1,f1,l1);
693         }
694         else {
695           C1 = Handle(Geom_Curve)::DownCast(C1->Copy());
696         }
697         if (!SameLoc) C1->Transform(L1.Transformation());
698         if (Edge1.Orientation() == TopAbs_REVERSED) {
699           C1->Reverse();
700         }
701         
702         if (Abs(f2 - C2->FirstParameter()) > Precision::PConfusion() ||
703             Abs(l2 - C2->LastParameter())  > Precision::PConfusion()   ) {
704           C2 = new Geom_TrimmedCurve(C2,f2,l2);
705         }
706         else {
707           C2 = Handle(Geom_Curve)::DownCast(C2->Copy());
708         }
709         if (!SameLoc) C2->Transform(L2.Transformation());
710         if (Edge2.Orientation() == TopAbs_REVERSED) {
711           C2->Reverse();
712         }
713         
714         GeomFill_Generator Generator;
715         Generator.AddCurve( C1);
716         Generator.AddCurve( C2);
717         Generator.Perform( Precision::PConfusion());
718         
719         Surf = Generator.Surface();
720         B.MakeFace(Face,Surf,Precision::Confusion());
721       }
722       else {
723         // particular case
724         CreateKPart(Edge1,Edge2,IType,Surf);
725         B.MakeFace(Face,Surf,Precision::Confusion());
726       }
727       
728       // make the missing edges
729       Standard_Real first,last;
730       Surf->Bounds(f1,l1,f2,l2);
731
732       if ( Map.IsBound(Vf_toMap)) {
733         TopoDS_Shape aLocalShape = Map(Vf_toMap).Reversed();
734         Edge3 = TopoDS::Edge(aLocalShape);
735 //      Edge3 = TopoDS::Edge(Map(V1f).Reversed());
736       }
737       else {
738         Handle(Geom_Curve) CC;
739         TColgp_Array1OfPnt Extremities(1,2);
740         if (IType==0) {
741           // general case : Edge3 corresponds to iso U=f1
742           CC = Surf->UIso(f1);
743           first=f2;
744           last=l2;
745         }
746         else {
747           // particular case : it is required to calculate the curve 3d
748           Extremities(1) = BRep_Tool::Pnt(V1f);
749           Extremities(2) = BRep_Tool::Pnt(V2f);
750           CC = new Geom_BezierCurve(Extremities);
751           first=0.;
752           last=1.;
753         }
754         B.MakeEdge(Edge3,CC,Precision::Confusion());
755         V1f.Orientation(TopAbs_FORWARD);
756         B.Add(Edge3,V1f);
757         V2f.Orientation(TopAbs_REVERSED);
758         B.Add(Edge3,V2f);
759         B.Range(Edge3,first,last);
760         Edge3.Reverse();
761         Map.Bind(Vf_toMap, Edge3);
762       }
763
764       Standard_Boolean CommonEdge = Standard_False;
765       if ( Map.IsBound(Vl_toMap)  ) {
766         TopoDS_Shape aLocalShape = Map(Vl_toMap).Reversed();
767         const TopoDS_Edge CommonE = TopoDS::Edge(aLocalShape);
768 //      const TopoDS_Edge CommonE = TopoDS::Edge(Map(V1l).Reversed());
769         TopoDS_Vertex V1, V2;
770         TopExp::Vertices(CommonE,V1,V2);
771         CommonEdge = V1.IsSame(V1l) && V2.IsSame(V2l);
772       }
773       if ( CommonEdge ) {
774         TopoDS_Shape aLocalShape = Map(Vl_toMap).Reversed();
775         Edge4 = TopoDS::Edge(aLocalShape);
776 //      Edge4 = TopoDS::Edge(Map(V1l).Reversed());
777       }
778       else {
779         Handle(Geom_Curve) CC;
780         TColgp_Array1OfPnt Extremities(1,2);
781         if (IType==0) {
782           // general case : Edge4 corresponds to iso U=l1
783           CC = Surf->UIso(l1);
784           first=f2;
785           last=l2;
786         }
787         else {
788           // particular case : it is required to calculate the curve 3d
789           Extremities(1) = BRep_Tool::Pnt(V1l);
790           Extremities(2) = BRep_Tool::Pnt(V2l);
791           CC = new Geom_BezierCurve(Extremities);
792           first=0.;
793           last=1.;
794         }
795         B.MakeEdge(Edge4,CC,Precision::Confusion());
796         V1l.Orientation(TopAbs_FORWARD);
797         B.Add(Edge4,V1l);
798         V2l.Orientation(TopAbs_REVERSED);
799         B.Add(Edge4,V2l);
800         B.Range(Edge4,first,last);
801         Map.Bind(Vl_toMap, Edge4);
802       }
803
804       // make the wire
805       
806       TopoDS_Wire W;
807       B.MakeWire(W);
808       
809       if (! (degen1 && IType == 4))
810         B.Add(W,Edge1);
811       B.Add(W,Edge4);
812       if (! (degen2 && IType == 4))
813         B.Add(W,Edge2.Reversed());
814       B.Add(W,Edge3);
815       
816       B.Add(Face,W);
817       
818       B.Add(myShell,Face);
819
820     // complete myMap for edge1
821       if (! (degen1 && IType == 4))
822         {
823           TopTools_ListOfShape Empty;
824           if (!myMap.IsBound(Edge1)) myMap.Bind(Edge1,Empty);
825           myMap(Edge1).Append(Face);
826         }
827       
828       // set the pcurves
829       
830       Standard_Real T = Precision::Confusion();
831
832       if (IType != 4) //not plane
833         {
834           if ( Edge1.Orientation() == TopAbs_REVERSED ) {
835             B.UpdateEdge(Edge1,
836                          new Geom2d_Line(gp_Pnt2d(0,f2),gp_Dir2d(-1,0)),
837                          Face,T);
838             B.Range(Edge1,Face,-l1,-f1);
839           }
840           else {
841             B.UpdateEdge(Edge1,
842                          new Geom2d_Line(gp_Pnt2d(0,f2),gp_Dir2d(1,0)),
843                          Face,T);
844             B.Range(Edge1,Face,f1,l1);
845           }
846           
847           if ( Edge2.Orientation() == TopAbs_REVERSED ) {
848             B.UpdateEdge(Edge2,
849                          new Geom2d_Line(gp_Pnt2d(0,l2),gp_Dir2d(-1,0)),
850                          Face,T);
851             B.Range(Edge2,Face,-l1,-f1);
852           }
853           else {
854             B.UpdateEdge(Edge2,
855                          new Geom2d_Line(gp_Pnt2d(0,l2),gp_Dir2d(1,0)),
856                          Face,T);
857             B.Range(Edge2,Face,f1,l1);
858           }
859         }
860
861       if (IType==0) {
862         if ( Periodic) {
863           B.UpdateEdge(Edge3,
864                        new Geom2d_Line(gp_Pnt2d(l1,0),gp_Dir2d(0,1)),
865                        new Geom2d_Line(gp_Pnt2d(f1,0),gp_Dir2d(0,1)),
866                        Face,T);
867         }
868         else {
869           B.UpdateEdge(Edge3,
870                        new Geom2d_Line(gp_Pnt2d(f1,0),gp_Dir2d(0,1)),
871                        Face,T);
872           B.UpdateEdge(Edge4,
873                        new Geom2d_Line(gp_Pnt2d(l1,0),gp_Dir2d(0,1)),
874                        Face,T);
875         }
876       }
877       else {
878         // KPart
879         if ( Periodic) {
880           TColgp_Array1OfPnt2d Extrem1(1,2);
881           Extrem1(1).SetCoord(l1,f2);
882           Extrem1(2).SetCoord(l1,l2);
883           TColgp_Array1OfPnt2d Extrem2(1,2);
884           Extrem2(1).SetCoord(f1,f2);
885           Extrem2(2).SetCoord(f1,l2);
886           B.UpdateEdge(Edge3,
887                        new Geom2d_BezierCurve(Extrem1),
888                        new Geom2d_BezierCurve(Extrem2),
889                        Face,T);
890         }
891         else if (IType != 4) { //not plane
892           TColgp_Array1OfPnt2d Extrem2(1,2);
893           Extrem2(1).SetCoord(f1,f2);
894           Extrem2(2).SetCoord(f1,l2);
895           B.UpdateEdge(Edge3,
896                        new Geom2d_BezierCurve(Extrem2),
897                        Face,T);
898           TColgp_Array1OfPnt2d Extrem1(1,2);
899           Extrem1(1).SetCoord(l1,f2);
900           Extrem1(2).SetCoord(l1,l2);
901           B.UpdateEdge(Edge4,
902                        new Geom2d_BezierCurve(Extrem1),
903                        Face,T);
904         }
905       }
906       // Set the non parameter flag;
907       B.SameParameter(Edge1,Standard_False);
908       B.SameParameter(Edge2,Standard_False);
909       B.SameParameter(Edge3,Standard_False);
910       B.SameParameter(Edge4,Standard_False);
911       B.SameRange(Edge1,Standard_False);
912       B.SameRange(Edge2,Standard_False);
913       B.SameRange(Edge3,Standard_False);
914       B.SameRange(Edge4,Standard_False);
915
916       tantque = ex1.More() && ex2.More();
917       if (wPoint1) tantque = ex2.More();
918       if (wPoint2) tantque = ex1.More();
919     }
920   }
921   BRepLib::SameParameter(myShell);
922
923   if (uClosed && DegenFirst && DegenLast)
924     myShell.Closed(Standard_True);
925 }
926
927
928 //=======================================================================
929 //function : GeneratedShapes
930 //purpose  : 
931 //=======================================================================
932
933 const TopTools_ListOfShape& 
934  BRepFill_Generator::GeneratedShapes (const TopoDS_Shape& SSection) const 
935 {
936   if (myMap.IsBound(SSection)) {
937     return myMap(SSection);
938   }
939   else {
940     static TopTools_ListOfShape Empty;
941     return Empty;
942   }
943 }
944
945 //=======================================================================
946 //function : Generated
947 //purpose  : 
948 //=================================================================== ====
949
950 const TopTools_DataMapOfShapeListOfShape& BRepFill_Generator::Generated() const
951 {
952   return myMap;
953 }
954
955