0027232: Configuration - fix mblen missing building issue on Android
[occt.git] / src / BRepFill / BRepFill_NSections.cxx
1 // Created on: 1998-12-29
2 // Created by: Joelle CHAUVET
3 // Copyright (c) 1998-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17
18 #include <BRep_Builder.hxx>
19 #include <BRep_Tool.hxx>
20 #include <BRepAdaptor_Curve.hxx>
21 #include <BRepFill.hxx>
22 #include <BRepFill_NSections.hxx>
23 #include <BRepLib_MakeEdge.hxx>
24 #include <BRepLib_MakeWire.hxx>
25 #include <BRepLProp.hxx>
26 #include <BRepTools_WireExplorer.hxx>
27 #include <BSplCLib.hxx>
28 #include <Geom_BezierCurve.hxx>
29 #include <Geom_BSplineCurve.hxx>
30 #include <Geom_BSplineSurface.hxx>
31 #include <Geom_Conic.hxx>
32 #include <Geom_Curve.hxx>
33 #include <Geom_Line.hxx>
34 #include <Geom_TrimmedCurve.hxx>
35 #include <GeomConvert.hxx>
36 #include <GeomConvert_ApproxCurve.hxx>
37 #include <GeomConvert_CompCurveToBSplineCurve.hxx>
38 #include <GeomFill_AppSurf.hxx>
39 #include <GeomFill_EvolvedSection.hxx>
40 #include <GeomFill_HArray1OfSectionLaw.hxx>
41 #include <GeomFill_Line.hxx>
42 #include <GeomFill_NSections.hxx>
43 #include <GeomFill_SectionGenerator.hxx>
44 #include <GeomFill_SectionLaw.hxx>
45 #include <GeomFill_UniformSection.hxx>
46 #include <Precision.hxx>
47 #include <Standard_Type.hxx>
48 #include <TColGeom_SequenceOfCurve.hxx>
49 #include <TColgp_HArray1OfPnt.hxx>
50 #include <TColStd_HArray1OfInteger.hxx>
51 #include <TColStd_HArray1OfReal.hxx>
52 #include <TopExp.hxx>
53 #include <TopoDS.hxx>
54 #include <TopoDS_Shape.hxx>
55 #include <TopoDS_Vertex.hxx>
56 #include <TopoDS_Wire.hxx>
57 #include <TopTools_Array1OfShape.hxx>
58
59 #include <stdio.h>
60 IMPLEMENT_STANDARD_RTTIEXT(BRepFill_NSections,BRepFill_SectionLaw)
61
62 #ifdef OCCT_DEBUG
63 static Standard_Boolean Affich = 0;
64 #endif
65
66 #ifdef DRAW
67 #include <DrawTrSurf.hxx>
68 #include <DBRep.hxx>
69 #endif
70
71
72 //=======================================================================
73 //function : EdgeToBSpline
74 //purpose  : auxiliary -- get curve from edge and convert it to bspline
75 //           parameterized from 0 to 1
76 //=======================================================================
77
78 // NOTE: this code duplicates the same function in BRepOffsetAPI_ThruSections.cxx
79 static Handle(Geom_BSplineCurve) EdgeToBSpline (const TopoDS_Edge& theEdge)
80 {
81   Handle(Geom_BSplineCurve) aBSCurve;
82   if (BRep_Tool::Degenerated(theEdge)) {
83     // degenerated edge : construction of a point curve
84     TColStd_Array1OfReal aKnots (1,2);
85     aKnots(1) = 0.;
86     aKnots(2) = 1.;
87
88     TColStd_Array1OfInteger aMults (1,2);
89     aMults(1) = 2;
90     aMults(2) = 2;
91
92     TColgp_Array1OfPnt aPoles(1,2);
93     TopoDS_Vertex vf, vl;
94     TopExp::Vertices(theEdge,vl,vf);
95     aPoles(1) = BRep_Tool::Pnt(vf);
96     aPoles(2) = BRep_Tool::Pnt(vl);
97
98     aBSCurve = new Geom_BSplineCurve (aPoles, aKnots, aMults, 1);
99   }
100   else
101   {
102     // get the curve of the edge
103     TopLoc_Location aLoc;
104     Standard_Real aFirst, aLast;
105     Handle(Geom_Curve) aCurve = BRep_Tool::Curve (theEdge, aLoc, aFirst, aLast);
106
107     // convert its part used by edge to bspline; note that if edge curve is bspline,
108     // conversion made via trimmed curve is still needed -- it will copy it, segment 
109     // as appropriate, and remove periodicity if it is periodic (deadly for approximator)
110     Handle(Geom_TrimmedCurve) aTrimCurve = new Geom_TrimmedCurve (aCurve, aFirst, aLast);
111
112     // special treatment of conic curve
113     if (aTrimCurve->BasisCurve()->IsKind(STANDARD_TYPE(Geom_Conic)))
114     {
115       const Handle(Geom_Curve)& aCurveTemp = aTrimCurve; // to avoid ambiguity
116       GeomConvert_ApproxCurve anAppr (aCurveTemp, Precision::Confusion(), GeomAbs_C1, 16, 14);
117       if (anAppr.HasResult())
118         aBSCurve = anAppr.Curve();
119     }
120
121     // general case
122     if (aBSCurve.IsNull())
123       aBSCurve = GeomConvert::CurveToBSplineCurve (aTrimCurve);
124
125     // apply transformation if needed
126     if (! aLoc.IsIdentity())
127       aBSCurve->Transform (aLoc.Transformation());
128
129     // reparameterize to [0,1]
130     TColStd_Array1OfReal aKnots (1, aBSCurve->NbKnots());
131     aBSCurve->Knots (aKnots);
132     BSplCLib::Reparametrize (0., 1., aKnots);
133     aBSCurve->SetKnots (aKnots);
134   }
135
136   // reverse curve if edge is reversed
137   if (theEdge.Orientation() == TopAbs_REVERSED)
138     aBSCurve->Reverse();
139
140   return aBSCurve;
141 }
142
143 //=======================================================================
144 //function : totalsurf
145 //purpose  : 
146 //=======================================================================
147
148 static Handle(Geom_BSplineSurface) totalsurf(const TopTools_Array2OfShape& shapes,
149                                              const Standard_Integer NbSects,
150                                              const Standard_Integer NbEdges,
151                                              const TColStd_SequenceOfReal& params,
152                                              const Standard_Boolean w1Point,
153                                              const Standard_Boolean w2Point,
154                                              const Standard_Boolean uClosed,
155                                              const Standard_Boolean vClosed,
156                                              const Standard_Real myPres3d)
157 {
158   Standard_Integer i,j,jdeb=1,jfin=NbSects;
159   TopoDS_Edge edge;
160   TopoDS_Vertex vf,vl;
161
162   GeomFill_SectionGenerator section;
163   Handle(Geom_BSplineSurface) surface;
164   Handle(Geom_BSplineCurve) BS, BS1;
165
166   if (w1Point) {
167     jdeb++;
168     edge =  TopoDS::Edge(shapes.Value(1,1));
169     TopExp::Vertices(edge,vl,vf);
170     TColgp_Array1OfPnt Extremities(1,2);
171     Extremities(1) = BRep_Tool::Pnt(vf);
172     Extremities(2) = BRep_Tool::Pnt(vl);
173     TColStd_Array1OfReal Bounds(1,2);
174     Bounds(1) = 0.;
175     Bounds(2) = 1.;
176     TColStd_Array1OfInteger Mult(1,2);
177     Mult(1) = 2;
178     Mult(2) = 2;
179     Handle(Geom_BSplineCurve) BSPoint
180       = new Geom_BSplineCurve(Extremities,Bounds,Mult, 1);
181     section.AddCurve(BSPoint);
182   }
183
184   if (w2Point) {
185     jfin--;
186   }
187
188   for (j=jdeb; j<=jfin; j++) {
189
190     // case of looping sections
191     if (j==jfin && vClosed) {
192       section.AddCurve(BS1);
193     }
194
195     else {
196       // read the first edge to initialise CompBS;
197       TopoDS_Edge aPrevEdge = TopoDS::Edge (shapes.Value(1,j));
198       Handle(Geom_BSplineCurve) curvBS = EdgeToBSpline (aPrevEdge);
199       
200       // initialization
201       GeomConvert_CompCurveToBSplineCurve CompBS(curvBS);
202
203       for (i=2; i<=NbEdges; i++) {  
204         // read the edge
205         TopoDS_Edge aNextEdge = TopoDS::Edge (shapes.Value(i,j));
206         curvBS = EdgeToBSpline (aNextEdge);
207
208         // concatenation
209         TopoDS_Vertex ComV;
210         Standard_Real epsV;
211         Standard_Boolean Bof = TopExp::CommonVertex(aPrevEdge, aNextEdge, ComV);
212         if (Bof) epsV = BRep_Tool::Tolerance(ComV);
213         else epsV = Precision::Confusion();
214         Bof = CompBS.Add(curvBS, epsV, Standard_True, Standard_False, 1);
215         if (!Bof) Bof = CompBS.Add(curvBS, 200*epsV,
216                                    Standard_True, Standard_False, 1);
217
218         // remember previous edge
219         aPrevEdge = aNextEdge;
220       }
221
222       // return the final section
223       BS = CompBS.BSplineCurve();
224       section.AddCurve(BS);
225
226       // case of looping sections
227       if (j==jdeb && vClosed) {
228         BS1 = BS;
229       }
230
231     }
232   }
233
234   if (w2Point) {
235     edge =  TopoDS::Edge(shapes.Value(NbEdges,NbSects));
236     TopExp::Vertices(edge,vl,vf);
237     TColgp_Array1OfPnt Extremities(1,2);
238     Extremities(1) = BRep_Tool::Pnt(vf);
239     Extremities(2) = BRep_Tool::Pnt(vl);
240     TColStd_Array1OfReal Bounds(1,2);
241     Bounds(1) = 0.;
242     Bounds(2) = 1.;
243     TColStd_Array1OfInteger Mult(1,2);
244     Mult(1) = 2;
245     Mult(2) = 2;
246     Handle(Geom_BSplineCurve) BSPoint
247       = new Geom_BSplineCurve(Extremities,Bounds,Mult,1);
248     section.AddCurve(BSPoint);
249   }
250
251   Handle(TColStd_HArray1OfReal) HPar
252     = new TColStd_HArray1OfReal(1,params.Length());
253   for (i=1; i<=params.Length(); i++) {
254     HPar->SetValue(i,params(i));
255   }
256   section.SetParam(HPar);
257   section.Perform(Precision::PConfusion());
258   Handle(GeomFill_Line) line = new GeomFill_Line(NbSects);
259   Standard_Integer nbIt = 0, degmin = 2, degmax = 6;
260   Standard_Boolean knownP = Standard_True;
261   GeomFill_AppSurf anApprox(degmin, degmax, myPres3d, myPres3d, nbIt, knownP);
262   Standard_Boolean SpApprox = Standard_True;
263   anApprox.Perform(line, section, SpApprox);
264   Standard_Boolean uperiodic = uClosed;
265   Standard_Boolean vperiodic = vClosed;
266   Standard_Integer nup = anApprox.SurfPoles().ColLength(),
267                    nvp = anApprox.SurfPoles().RowLength();
268   TColStd_Array1OfInteger Umults(1,anApprox.SurfUKnots().Length());
269   Umults = anApprox.SurfUMults();
270   TColStd_Array1OfInteger Vmults(1,anApprox.SurfVKnots().Length());
271   Vmults = anApprox.SurfVMults();
272
273   if (uperiodic) {
274     Standard_Integer nbuk = anApprox.SurfUKnots().Length();
275     Umults(1) --;
276     Umults(nbuk) --;
277     nup --;
278   }
279
280   if (vperiodic) {
281     Standard_Integer nbvk = anApprox.SurfVKnots().Length();
282     Vmults(1) --;
283     Vmults(nbvk) --;
284     nvp --;
285   }
286
287   TColgp_Array2OfPnt   poles  (1, nup, 1, nvp);
288   TColStd_Array2OfReal weights(1, nup, 1, nvp);
289     for (j = 1; j <= nvp; j++) {
290       for (i = 1; i <= nup; i++) {
291         poles(i, j) = anApprox.SurfPoles()(i,j);
292         weights(i, j) = anApprox.SurfWeights()(i,j);
293       }
294     }
295
296   // To create non-rational surface if possible
297   Standard_Real TolEps = 1.e-13;
298   Standard_Boolean Vrational = Standard_False, Urational = Standard_False;
299   for (j = 1; j <= weights.UpperCol(); j++)
300     if (!Vrational)
301       for (i = 1; i <= weights.UpperRow()-1; i++)
302         {
303           //Standard_Real signeddelta = weights(i,j) - weights(i+1,j);
304           Standard_Real delta = Abs( weights(i,j) - weights(i+1,j) );
305 //        Standard_Real eps = Epsilon( Abs(weights(i,j)) );
306           if (delta > TolEps/* || delta > 3.*eps*/)
307             {
308               Vrational = Standard_True;
309               break;
310             }
311         }
312   for (i = 1; i <= weights.UpperRow(); i++)
313     if (!Urational)
314       for (j = 1; j <= weights.UpperCol()-1; j++)
315         {
316           //Standard_Real signeddelta = weights(i,j) - weights(i,j+1);
317           Standard_Real delta = Abs( weights(i,j) - weights(i,j+1) );
318 //        Standard_Real eps = Epsilon( Abs(weights(i,j)) );
319           if (delta > TolEps/* || delta > 3.*eps*/)
320             {
321               Urational = Standard_True;
322               break;
323             }
324         }
325   if (!Vrational && !Urational)
326     {
327       Standard_Real theWeight = weights(1,1);
328       for (i = 1; i <= weights.UpperRow(); i++)
329         for (j = 1; j <= weights.UpperCol(); j++)
330           weights(i,j) = theWeight;
331     }
332     
333   surface = 
334     new Geom_BSplineSurface(poles, weights,
335                             anApprox.SurfUKnots(), anApprox.SurfVKnots(),
336                             Umults, Vmults,
337                             anApprox.UDegree(), anApprox.VDegree(),
338                             uperiodic, vperiodic);
339   return surface;
340   
341 }
342
343
344 //=======================================================================
345 //function : Create
346 //purpose  : WSeq
347 //=======================================================================
348
349 BRepFill_NSections::BRepFill_NSections(const TopTools_SequenceOfShape& S,
350                                        const Standard_Boolean Build) 
351
352 {
353   myShapes = S;
354   VFirst = 0.;
355   VLast = 1.;
356   TColStd_SequenceOfReal par;
357   par.Clear();
358   for (Standard_Integer i=1;i<=S.Length();i++) {
359     par.Append(i-1);
360   }
361   myParams = par;
362   Init(par,Build);
363 }
364
365 //=======================================================================
366 //function : Create
367 //purpose  : WSeq + Param
368 //=======================================================================
369
370 BRepFill_NSections::BRepFill_NSections(const TopTools_SequenceOfShape& S,
371                                        const GeomFill_SequenceOfTrsf& Transformations,
372                                        const TColStd_SequenceOfReal & P,
373                                        const Standard_Real VF,
374                                        const Standard_Real VL,
375                                        const Standard_Boolean Build)
376
377 {
378 #ifdef OCCT_DEBUG
379   if ( Affich) {
380 #ifdef DRAW
381     Standard_Integer NBSECT = 0;
382     for (Standard_Integer i=1;i<=S.Length();i++) {
383       NBSECT++;
384       char name[256];
385       sprintf(name,"WIRE_%d",NBSECT);
386       DBRep::Set(name,TopoDS::Wire(S.Value(i)));
387     }
388 #endif
389   }
390 #endif
391   Standard_Boolean ok = Standard_True;
392   for (Standard_Integer iseq=1;iseq<P.Length();iseq++) {
393     ok = ok && (P.Value(iseq)<P.Value(iseq+1));
394   }
395   if (ok) {
396     myParams = P;
397     myShapes = S;
398     myTrsfs = Transformations;
399     VFirst = VF;
400     VLast = VL;
401     Init(P,Build);
402   }
403 }
404
405 //=======================================================================
406 //function : Init
407 //purpose  : Create a table of GeomFill_SectionLaw
408 //=======================================================================
409 void BRepFill_NSections::Init(const TColStd_SequenceOfReal & P,
410                               const Standard_Boolean Build)
411 {
412   BRepTools_WireExplorer wexp;
413 // Class BRep_Tool without fields and without Constructor :
414 //  BRep_Tool B;
415   TopoDS_Edge E;
416   Standard_Integer ii, NbEdge, jj, NbSects = P.Length();
417   Standard_Integer ideb = 1, ifin = NbSects;
418   Standard_Boolean wClosed, w1Point = Standard_True, 
419                             w2Point = Standard_True;
420   Standard_Real First, Last;
421   TopoDS_Wire W;
422
423   // Check if the start and end wires are punctual
424   W = TopoDS::Wire(myShapes(1));
425   for (wexp.Init(W); wexp.More(); wexp.Next()) 
426 //    w1Point = w1Point && B.Degenerated(wexp.Current());
427     w1Point = w1Point && BRep_Tool::Degenerated(wexp.Current());
428   if (w1Point) ideb++;
429   W = TopoDS::Wire(myShapes(NbSects));
430   for (wexp.Init(W); wexp.More(); wexp.Next()) 
431 //    w2Point = w2Point && B.Degenerated(wexp.Current());
432     w2Point = w2Point && BRep_Tool::Degenerated(wexp.Current());
433   if (w2Point) ifin--;
434
435   // Check if the start and end wires are identical
436   vclosed = myShapes(1).IsSame(myShapes(NbSects));
437
438   // Count the number of non-degenerated edges
439   W = TopoDS::Wire(myShapes(ideb));
440   for (NbEdge=0, wexp.Init(W); wexp.More(); wexp.Next()) 
441 //    if (! B.Degenerated(wexp.Current())) NbEdge++;
442     if (! BRep_Tool::Degenerated(wexp.Current())) NbEdge++;
443
444   myEdges = new (TopTools_HArray2OfShape) (1, NbEdge, 1, NbSects);
445   
446   // Fill tables
447   uclosed = Standard_True;
448   for (jj=ideb;jj<=ifin;jj++){
449
450     W = TopoDS::Wire(myShapes(jj));
451     
452     for (ii=1, wexp.Init(W); ii<=NbEdge ; wexp.Next(), ii++) {
453       E =  wexp.Current();
454       
455 //      if ( ! B.Degenerated(E)) {
456       if ( ! BRep_Tool::Degenerated(E)) {
457         myEdges->SetValue(ii,jj, E);
458       }
459     }
460
461   // Is the law closed by U ?
462
463     wClosed = W.Closed();
464     if (!wClosed) {
465       // if unsure about the flag, make check
466       TopoDS_Edge Edge1, Edge2;
467       TopoDS_Vertex V1,V2;
468       Edge1 = TopoDS::Edge (myEdges->Value(NbEdge,jj));
469       Edge2 = TopoDS::Edge (myEdges->Value(1,jj));
470       
471       if ( Edge1.Orientation() == TopAbs_REVERSED) {
472         V1 = TopExp::FirstVertex(Edge1);
473       }
474       else {
475         V1 = TopExp::LastVertex(Edge1);
476       }
477       if ( Edge2.Orientation() == TopAbs_REVERSED) {
478         V2 = TopExp::LastVertex(Edge2);
479       }
480       else {
481         V2 = TopExp::FirstVertex(Edge2);
482       } 
483       if (V1.IsSame(V2)) {
484         wClosed = Standard_True;
485       }
486       else {
487         BRepAdaptor_Curve Curve1(Edge1);
488         BRepAdaptor_Curve Curve2(Edge2);
489         Standard_Real U1 = BRep_Tool::Parameter(V1,Edge1);
490         Standard_Real U2 = BRep_Tool::Parameter(V2,Edge2);
491         Standard_Real Eps = BRep_Tool::Tolerance(V2) + 
492           BRep_Tool::Tolerance(V1);
493         
494         wClosed = Curve1.Value(U1).IsEqual(Curve2.Value(U2), Eps);
495       }
496     } 
497     if (!wClosed) uclosed = Standard_False;
498   }
499
500   // point sections at end
501   if (w1Point) {
502     W = TopoDS::Wire(myShapes(1));
503     wexp.Init(W);
504     E =  wexp.Current();
505     for (ii=1; ii<=NbEdge ; ii++) {
506       myEdges->SetValue(ii, 1, E);
507     }
508   }
509   
510   if (w2Point) {
511     W = TopoDS::Wire(myShapes(NbSects));
512     wexp.Init(W);
513     E =  wexp.Current();
514     for (ii=1; ii<=NbEdge ; ii++) {
515       myEdges->SetValue(ii, NbSects, E);
516     }
517   }
518   
519   
520   myLaws = new (GeomFill_HArray1OfSectionLaw) (1, NbEdge);
521
522   Standard_Real tol = Precision::Confusion();
523   mySurface = totalsurf(myEdges->Array2(),myShapes.Length(),NbEdge,
524                         myParams,w1Point,w2Point,uclosed,vclosed,tol);
525    
526   // Increase the degree so that the position D2 
527   // on GeomFill_NSections could be correct
528   // see comments in GeomFill_NSections
529   if (mySurface->VDegree()<2) {
530     mySurface->IncreaseDegree(mySurface->UDegree(),2);
531   }
532 #ifdef DRAW
533   if ( Affich) {
534     char*  name = new char[100];
535     sprintf(name,"Ref_Surf");
536     DrawTrSurf::Set(name,mySurface);
537   }
538 #endif
539
540   // Fill tables
541   if (Build) {
542     for (ii=1; ii<=NbEdge ; ii++) {
543       TColGeom_SequenceOfCurve NC;
544       NC.Clear();
545       for (jj=1;jj<=NbSects;jj++) {
546         E = TopoDS::Edge (myEdges->Value(ii,jj));
547         Handle(Geom_Curve) C;
548 //      if (B.Degenerated(E)) {
549         if (BRep_Tool::Degenerated(E)) {
550           TopoDS_Vertex vf,vl;
551           TopExp::Vertices(E,vl,vf);
552           TColgp_Array1OfPnt Extremities(1,2);
553           Extremities(1) = BRep_Tool::Pnt(vf);
554           Extremities(2) = BRep_Tool::Pnt(vl);
555           TColStd_Array1OfReal Bounds(1,2);
556           Bounds(1) = 0.;
557           Bounds(2) = 1.;
558           TColStd_Array1OfInteger Mult(1,2);
559           Mult(1) = 2;
560           Mult(2) = 2;
561           Handle(Geom_BSplineCurve) BSPoint
562             = new Geom_BSplineCurve(Extremities,Bounds,Mult,1);
563           C = BSPoint;
564         }
565         else {
566           C  = BRep_Tool::Curve(E,First,Last);
567         
568           if (E.Orientation() == TopAbs_REVERSED) {
569             Standard_Real aux;
570             Handle(Geom_Curve) CBis;
571             CBis = C->Reversed(); // To avoid the spoiling of the topology
572             aux = C->ReversedParameter(First);
573             First = C->ReversedParameter(Last);
574             Last = aux;
575             C =  CBis;
576           } 
577           if ((ii>1) || (!BRep_Tool::IsClosed(E)) ) { // Cut C
578             Handle(Geom_TrimmedCurve) TC = 
579               new (Geom_TrimmedCurve) (C,First, Last);
580             C  = TC;
581           } 
582           //  otherwise preserve the integrity of the curve
583         }
584         NC.Append(C);
585       }
586  
587       Standard_Real Ufirst = ii-1;
588       Standard_Real Ulast = ii;
589       myLaws->ChangeValue(ii) = new (GeomFill_NSections)(NC, myTrsfs, myParams,
590                                                          Ufirst,Ulast,
591                                                          VFirst,VLast,
592                                                          mySurface);
593     }
594  
595   } 
596  
597 }
598
599
600 //=======================================================================
601 //function : IsVertex
602 //purpose  :
603 //=======================================================================
604  Standard_Boolean BRepFill_NSections::IsVertex() const
605 {
606   return  Standard_False;
607 }
608
609 //=======================================================================
610 //function : IsConstant
611 //purpose  :
612 //=======================================================================
613  Standard_Boolean BRepFill_NSections::IsConstant() const
614 {
615   return Standard_False;
616 }
617
618 //=======================================================================
619 //function : Vertex
620 //purpose  : 
621 //=======================================================================
622  TopoDS_Vertex 
623  BRepFill_NSections::Vertex(const Standard_Integer Index, 
624                             const Standard_Real Param) const
625 {
626   BRep_Builder B;
627   TopoDS_Vertex V;
628   B.MakeVertex(V);
629   gp_Pnt P;
630
631   if (Index <= myEdges->ColLength()) {
632     Handle(Geom_BSplineCurve) Curve 
633       = Handle(Geom_BSplineCurve)::DownCast(myLaws->Value(Index)->
634                                             BSplineSurface()->VIso(Param));
635     Standard_Real first = Curve ->FirstParameter();
636     Curve->D0(first, P);
637     B.UpdateVertex(V, P, Precision::Confusion());
638   }
639   else if (Index == myEdges->ColLength()+1) {
640     Handle(Geom_BSplineCurve) Curve 
641       = Handle(Geom_BSplineCurve)::DownCast(myLaws->Value(Index-1)->
642                                             BSplineSurface()->VIso(Param));
643     Standard_Real last = Curve ->LastParameter();
644     Curve->D0(last, P);
645     B.UpdateVertex(V, P, Precision::Confusion());
646   }
647
648   return V;
649 }
650
651
652 ///=======================================================================
653 //function : VertexTol
654 //purpose  : Evaluate the hole between 2 edges of the section
655 //=======================================================================
656  Standard_Real BRepFill_NSections::VertexTol(const Standard_Integer Index,
657                                               const Standard_Real Param) const
658 {
659   Standard_Real Tol = Precision::Confusion();
660   Standard_Integer I1, I2;
661   if ( (Index==0) || (Index==myEdges->ColLength()) ) {
662     if (!uclosed) return Tol; //The least possible error
663     I1 = myEdges->ColLength();
664     I2 = 1;
665   }
666   else {
667     I1 = Index;
668     I2 = I1 +1;
669   } 
670
671   Handle(GeomFill_SectionLaw) Loi;
672   Standard_Integer NbPoles,  NbKnots, Degree;
673   Handle(TColgp_HArray1OfPnt) Poles;
674   Handle(TColStd_HArray1OfReal) Knots, Weigth;
675   Handle(TColStd_HArray1OfInteger) Mults;
676   Handle(Geom_BSplineCurve) BS;
677   gp_Pnt PFirst;
678
679   Loi = myLaws->Value(I1);
680   Loi->SectionShape( NbPoles,  NbKnots, Degree);
681   Poles = new (TColgp_HArray1OfPnt) (1, NbPoles);
682   Weigth = new  (TColStd_HArray1OfReal) (1, NbPoles);
683   Loi->D0(Param, Poles->ChangeArray1(), Weigth->ChangeArray1());
684   Knots = new  (TColStd_HArray1OfReal) (1, NbKnots);
685   Loi->Knots(Knots->ChangeArray1());
686   Mults = new (TColStd_HArray1OfInteger) (1, NbKnots);
687   Loi->Mults(Mults->ChangeArray1());
688   BS = new (Geom_BSplineCurve) (Poles->Array1(), 
689                                 Weigth->Array1(), 
690                                 Knots->Array1(), 
691                                 Mults->Array1(), 
692                                 Degree,
693                                 Loi->IsUPeriodic());
694   PFirst = BS->Value( Knots->Value(Knots->Length()) );
695
696   Loi = myLaws->Value(I2);
697   Loi->SectionShape( NbPoles,  NbKnots, Degree);
698   Poles = new (TColgp_HArray1OfPnt) (1, NbPoles);
699   Weigth = new  (TColStd_HArray1OfReal) (1, NbPoles);
700   Loi->D0(Param, Poles->ChangeArray1(), Weigth->ChangeArray1());
701   Knots = new  (TColStd_HArray1OfReal) (1, NbKnots);
702   Loi->Knots(Knots->ChangeArray1());
703   Mults = new (TColStd_HArray1OfInteger) (1, NbKnots);
704   Loi->Mults(Mults->ChangeArray1());
705   BS = new (Geom_BSplineCurve) (Poles->Array1(), 
706                                 Weigth->Array1(), 
707                                 Knots->Array1(), 
708                                 Mults->Array1(), 
709                                 Degree,
710                                 Loi->IsUPeriodic());
711   Tol += PFirst.Distance(BS->Value( Knots->Value(1)));
712   return Tol;
713 }
714
715 //=======================================================================
716 //function : ConcatenedLaw
717 //purpose  : 
718 //=======================================================================
719
720  Handle(GeomFill_SectionLaw) BRepFill_NSections::ConcatenedLaw() const
721 {
722   Handle(GeomFill_SectionLaw) Law;
723   if (myLaws->Length() == 1) 
724     return myLaws->Value(1);
725   else {
726     Standard_Real Ufirst, Ulast, Vfirst, Vlast;
727     mySurface->Bounds(Ufirst, Ulast, Vfirst, Vlast);
728     TColGeom_SequenceOfCurve NCompo;
729     NCompo.Clear();
730     for (Standard_Integer jj=1; jj<=myShapes.Length(); jj++) {
731       NCompo.Append(mySurface->VIso(myParams(jj)));
732     }
733     Law = new (GeomFill_NSections)(NCompo, myTrsfs, myParams, 
734                                    Ufirst, Ulast, 
735                                    Vfirst, Vlast,
736                                    mySurface);
737   }
738   return Law;
739 }
740
741 //=======================================================================
742 //function : Continuity
743 //purpose  : 
744 //=======================================================================
745  GeomAbs_Shape BRepFill_NSections::Continuity(const Standard_Integer Index,
746                                               const Standard_Real TolAngular) const
747 {
748
749  Standard_Integer jj;
750  GeomAbs_Shape cont_jj;
751  GeomAbs_Shape cont = GeomAbs_C0; 
752
753  for (jj=1; jj<=myShapes.Length(); jj++) {
754
755    TopoDS_Edge Edge1, Edge2;
756    if ( (Index==0) || (Index==myEdges->ColLength()) ) {
757      if (!uclosed) return GeomAbs_C0; //The least possible error
758      
759      Edge1 = TopoDS::Edge (myEdges->Value(myEdges->ColLength(),jj));
760      Edge2 = TopoDS::Edge (myEdges->Value(1,jj));
761    }
762    else {
763      Edge1 = TopoDS::Edge (myEdges->Value(Index,jj));
764      Edge2 = TopoDS::Edge (myEdges->Value(Index+1,jj));
765    } 
766    
767    TopoDS_Vertex V1,V2;
768    if ( Edge1.Orientation() == TopAbs_REVERSED) {
769      V1 = TopExp::FirstVertex(Edge1);
770    }
771    else {
772      V1 = TopExp::LastVertex(Edge1);
773    }
774    if ( Edge2.Orientation() == TopAbs_REVERSED) {
775      V2 = TopExp::LastVertex(Edge2);
776    }
777    else {
778      V2 = TopExp::FirstVertex(Edge2);
779    }
780    
781    if (BRep_Tool::Degenerated(Edge1) || BRep_Tool::Degenerated(Edge2))
782      cont_jj = GeomAbs_CN;
783    else
784      {
785        Standard_Real U1 = BRep_Tool::Parameter(V1,Edge1);
786        Standard_Real U2 = BRep_Tool::Parameter(V2,Edge2);
787        BRepAdaptor_Curve Curve1(Edge1);
788        BRepAdaptor_Curve Curve2(Edge2);
789        Standard_Real Eps = BRep_Tool::Tolerance(V2) +
790          BRep_Tool::Tolerance(V1);
791        cont_jj = BRepLProp::Continuity(Curve1,Curve2,U1,U2, Eps, TolAngular);
792      }
793
794    if (jj==1) cont = cont_jj;
795    if (cont>cont_jj) cont = cont_jj;
796
797  }
798    
799  return cont;
800 }
801
802 //=======================================================================
803 //function : D0
804 //purpose  : 
805 //=======================================================================
806  void BRepFill_NSections::D0(const Standard_Real V, TopoDS_Shape& S)
807 {
808   TopoDS_Wire W;
809   BRepLib_MakeWire MW;
810   Standard_Integer ii, NbEdge = myLaws->Length();
811   for (ii=1; ii<=NbEdge ; ii++) {
812     Handle(Geom_BSplineCurve) Curve 
813       = Handle(Geom_BSplineCurve)::DownCast(myLaws->Value(ii)->BSplineSurface()->VIso(V));
814     Standard_Real first = Curve ->FirstParameter(),
815     last = Curve ->LastParameter();
816     TopoDS_Edge E = BRepLib_MakeEdge(Curve,first,last);
817     MW.Add(E);
818   }
819   TopAbs_Orientation Orien = TopAbs_FORWARD;
820   TopoDS_Shape aLocalShape = MW.Wire().Oriented(Orien);
821   S = TopoDS::Wire(aLocalShape);
822 //  S = TopoDS::Wire(MW.Wire().Oriented(Orien));
823   
824
825