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