0027772: Foundation Classes - define Standard_Boolean using C++ type "bool" instead...
[occt.git] / src / ChFi3d / ChFi3d_FilBuilder.cxx
CommitLineData
b311480e 1// Created on: 1995-04-25
2// Created by: Modelistation
3// Copyright (c) 1995-1999 Matra Datavision
973c2be1 4// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e 5//
973c2be1 6// This file is part of Open CASCADE Technology software library.
b311480e 7//
d5f74e42 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
973c2be1 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.
b311480e 13//
973c2be1 14// Alternatively, this file may be used under the terms of Open CASCADE
15// commercial license or contractual agreement.
b311480e 16
7fd59977 17// Modified: MPS : (10-04-97) portage WNT pour GetFilletShape
7fd59977 18
42cf5bc1 19#include <Adaptor3d_TopolTool.hxx>
7fd59977 20#include <Blend_Point.hxx>
42cf5bc1 21#include <BRepAdaptor_HCurve2d.hxx>
22#include <BRepAdaptor_HSurface.hxx>
7fd59977 23#include <BRepBlend_ConstRad.hxx>
24#include <BRepBlend_ConstRadInv.hxx>
42cf5bc1 25#include <BRepBlend_CurvPointRadInv.hxx>
7fd59977 26#include <BRepBlend_EvolRad.hxx>
27#include <BRepBlend_EvolRadInv.hxx>
42cf5bc1 28#include <BRepBlend_Line.hxx>
7fd59977 29#include <BRepBlend_RstRstConstRad.hxx>
30#include <BRepBlend_RstRstEvolRad.hxx>
31#include <BRepBlend_SurfCurvConstRadInv.hxx>
32#include <BRepBlend_SurfCurvEvolRadInv.hxx>
33#include <BRepBlend_SurfPointConstRadInv.hxx>
34#include <BRepBlend_SurfPointEvolRadInv.hxx>
42cf5bc1 35#include <BRepBlend_SurfRstConstRad.hxx>
36#include <BRepBlend_SurfRstEvolRad.hxx>
37#include <BRepBlend_Walking.hxx>
38#include <ChFi3d_Builder_0.hxx>
39#include <ChFi3d_FilBuilder.hxx>
40#include <ChFi3d_SearchSing.hxx>
41#include <ChFiDS_ErrorStatus.hxx>
7fd59977 42#include <ChFiDS_FilSpine.hxx>
42cf5bc1 43#include <ChFiDS_HData.hxx>
44#include <ChFiDS_HElSpine.hxx>
7fd59977 45#include <ChFiDS_ListIteratorOfListOfStripe.hxx>
46#include <ChFiDS_ListIteratorOfRegularities.hxx>
42cf5bc1 47#include <ChFiDS_ListOfStripe.hxx>
7fd59977 48#include <ChFiDS_Regul.hxx>
42cf5bc1 49#include <ChFiDS_SecHArray1.hxx>
50#include <ChFiDS_Spine.hxx>
51#include <ChFiDS_Stripe.hxx>
52#include <ChFiDS_SurfData.hxx>
7fd59977 53#include <ElSLib.hxx>
42cf5bc1 54#include <Geom_Curve.hxx>
55#include <GeomAdaptor_HCurve.hxx>
56#include <gp_XY.hxx>
57#include <Law_Composite.hxx>
58#include <Law_Function.hxx>
7fd59977 59#include <math_FunctionRoot.hxx>
7fd59977 60#include <Precision.hxx>
7fd59977 61#include <Standard_ConstructionError.hxx>
62#include <Standard_Failure.hxx>
42cf5bc1 63#include <TColStd_SequenceOfReal.hxx>
64#include <TopoDS_Edge.hxx>
65#include <TopoDS_Shape.hxx>
66#include <TopoDS_Vertex.hxx>
67#include <TopOpeBRepBuild_HBuilder.hxx>
68#include <TopOpeBRepDS_Curve.hxx>
69#include <TopOpeBRepDS_HDataStructure.hxx>
70#include <TopOpeBRepDS_Surface.hxx>
71#include <TopTools_ListIteratorOfListOfShape.hxx>
72
0797d9d3 73#ifdef OCCT_DEBUG
742cc8b0 74#include <OSD_Chronometer.hxx>
7fd59977 75extern Standard_Boolean ChFi3d_GettraceCHRON();
76extern Standard_Real t_computedata ,t_completedata;
77
78extern void ChFi3d_InitChron(OSD_Chronometer& ch);
79extern void ChFi3d_ResultChron(OSD_Chronometer & ch,Standard_Real& time);
80#endif
81
82static Standard_Real MaxRad(const Handle(ChFiDS_FilSpine)& fsp,
83
84 const TopoDS_Edge& E)
85{
86 Standard_Integer IE = fsp->Index(E);
87
88 // 1: case of constant R
89 if (fsp->IsConstant(IE))
90 return (fsp->Radius(IE));
91 else // 2,3: case of sequence ParAndRad and(or) Laws
92 return (fsp->MaxRadFromSeqAndLaws());
93
94/*
95 Handle(ChFiDS_HElSpine) HGuide = fsp->ElSpine(IE);
96 Standard_Real la = HGuide->LastParameter(), fi = HGuide->FirstParameter();
97 Standard_Real longueur = la - fi, temp, w;
0797d9d3 98//#ifndef OCCT_DEBUG
7fd59977 99 Standard_Real radiussect = 0.;
100//#else
101// Standard_Real radiussect;
102//#endif
103 Handle(Law_Composite) lc = fsp->Law(HGuide);
104 for(Standard_Integer i = 0; i <= 5; i++){
105 w = fi + i*longueur*0.2;
106 temp = lc->Value(w);
107 if(temp>radiussect) radiussect = temp;
108 }
109 return radiussect;
110*/
111}
112
113static void SimulParams(const Handle(ChFiDS_HElSpine)& HGuide,
114 const Handle(ChFiDS_FilSpine)& fsp,
115 Standard_Real& MaxStep,
116 Standard_Real& Fleche)
117{
118 Standard_Real la = HGuide->LastParameter(), fi = HGuide->FirstParameter();
119 Standard_Real longueur = la - fi;
120 MaxStep = longueur * 0.05;
121 Standard_Real w;
122 //gp_Pnt Pbid;
123 //gp_Vec d1,d2;
124 Standard_Real radiussect;
125 if(fsp->IsConstant()) radiussect = fsp->Radius();
126 else {
127 radiussect = 0.;
128 Handle(Law_Composite) lc = fsp->Law(HGuide);
129 for(Standard_Integer i = 0; i <= 5; i++){
130 w = fi + i*longueur*0.2;
131 Standard_Real temp = lc->Value(w);
132 if(temp>radiussect) radiussect = temp;
133 }
134 }
135 Fleche = radiussect * 0.05;
136}
137
138//=======================================================================
139//function : ChFi3d_FilBuilder
140//purpose :
141//=======================================================================
142
143ChFi3d_FilBuilder::ChFi3d_FilBuilder(const TopoDS_Shape& S,
144 const ChFi3d_FilletShape FShape,
145 const Standard_Real Ta):
146 ChFi3d_Builder(S, Ta)
147{
148 SetFilletShape(FShape);
149}
150
151//=======================================================================
152//function : SetFilletShape
153//purpose :
154//=======================================================================
155
156void ChFi3d_FilBuilder::SetFilletShape(const ChFi3d_FilletShape FShape)
157{
158 switch (FShape) {
159 case ChFi3d_Rational:
160 myShape = BlendFunc_Rational;
161 break;
162 case ChFi3d_QuasiAngular:
163 myShape = BlendFunc_QuasiAngular;
164 break;
165 case ChFi3d_Polynomial:
166 myShape = BlendFunc_Polynomial;
167 break;
168 }
169}
170
171//=======================================================================
172//function : GetFilletShape
173//purpose :
174//=======================================================================
175
176ChFi3d_FilletShape ChFi3d_FilBuilder::GetFilletShape() const
177{
7fd59977 178 ChFi3d_FilletShape filshape = ChFi3d_Rational; // need to set default value
7fd59977 179 switch (myShape) {
180 case BlendFunc_Rational:
181 filshape= ChFi3d_Rational;
182 break;
183 case BlendFunc_QuasiAngular:
184 filshape= ChFi3d_QuasiAngular;
185 break;
186 case BlendFunc_Polynomial:
187 filshape= ChFi3d_Polynomial;
188 break;
189 default:
190 break;
191 }
192 return filshape;
193}
194
195//=======================================================================
196//function : Add
197//purpose :
198//=======================================================================
199
200void ChFi3d_FilBuilder::Add(const TopoDS_Edge& E)
201{
202 if(!Contains(E) && myEFMap.Contains(E)){
203 Handle(ChFiDS_Stripe) Stripe = new ChFiDS_Stripe();
204 Handle(ChFiDS_Spine)& Sp = Stripe->ChangeSpine();
205 Sp = new ChFiDS_FilSpine(tolesp);
206 Handle(ChFiDS_FilSpine) Spine = Handle(ChFiDS_FilSpine)::DownCast(Sp);
207
208 TopoDS_Edge E_wnt = E;
209 E_wnt.Orientation(TopAbs_FORWARD);
210 Spine->SetEdges(E_wnt);
211 if(PerformElement(Spine)){
212 PerformExtremity(Spine);
213 Spine->Load();
214 myListStripe.Append(Stripe);
215 }
216 }
217}
218
219//=======================================================================
220//function : Add
221//purpose :
222//=======================================================================
223
224void ChFi3d_FilBuilder::Add(const Standard_Real Radius, const TopoDS_Edge& E)
225{
226 Add(E);
227 Standard_Integer IC = Contains(E);
228 if (IC)
229 SetRadius( Radius, IC, E );
230}
231
232//=======================================================================
233//function : SetRadius
234//purpose :
235//=======================================================================
236
237void ChFi3d_FilBuilder::SetRadius(const Handle(Law_Function)& C,
238 const Standard_Integer IC,
239 const Standard_Integer IinC)
240{
241 if(IC <= NbElements()) {
242 Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
243 fsp->SetRadius(C, IinC);
244 }
245}
246
247//=======================================================================
248//function : IsConstant
249//purpose :
250//=======================================================================
251
252Standard_Boolean ChFi3d_FilBuilder::IsConstant(const Standard_Integer IC)
253{
254 if(IC <= NbElements()) {
255 Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
256 return fsp->IsConstant();
257 }
258 return 0;
259}
260
261//=======================================================================
262//function : Radius
263//purpose :
264//=======================================================================
265
266Standard_Real ChFi3d_FilBuilder::Radius(const Standard_Integer IC)
267{
268 if(IC <= NbElements()) {
269 Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
270 return fsp->Radius();
271 }
272 return -1.;
273}
274
275//=======================================================================
276//function : ResetContour
277//purpose :
278//=======================================================================
279
280void ChFi3d_FilBuilder::ResetContour(const Standard_Integer IC)
281{
282 if(IC <= NbElements()) {
283 Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
284 fsp->Reset(Standard_True);
285 }
286}
287
288//=======================================================================
289//function : SetRadius
290//purpose :
291//=======================================================================
292
293void ChFi3d_FilBuilder::SetRadius(const Standard_Real Radius,
294 const Standard_Integer IC,
295 const TopoDS_Edge& E)
296{
297 if(IC <= NbElements()) {
298 Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
299 fsp->SetRadius(Radius, E);
300 }
301}
302
303//=======================================================================
304//function : UnSet
305//purpose :
306//=======================================================================
307
308void ChFi3d_FilBuilder::UnSet(const Standard_Integer IC,
309 const TopoDS_Edge& E)
310{
311 if(IC <= NbElements()) {
312 Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
313 fsp->UnSetRadius(E);
314 }
315}
316
317//=======================================================================
318//function : SetRadius
319//purpose :
320//=======================================================================
321
322void ChFi3d_FilBuilder::SetRadius(const Standard_Real Radius,
323 const Standard_Integer IC,
324 const TopoDS_Vertex& V)
325{
326 if(IC <= NbElements()) {
327 Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
328 fsp->SetRadius(Radius, V);
329 }
330}
331
332//=======================================================================
333//function : UnSet
334//purpose :
335//=======================================================================
336
337void ChFi3d_FilBuilder::UnSet(const Standard_Integer IC,
338 const TopoDS_Vertex& V)
339{
340 if(IC <= NbElements()) {
341 Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
342 fsp->UnSetRadius(V);
343 }
344}
345
346//=======================================================================
347//function : SetRadius
348//purpose :
349//=======================================================================
350
351void ChFi3d_FilBuilder::SetRadius(const gp_XY& UandR,
352 const Standard_Integer IC,
353 const Standard_Integer IinC)
354{
355 if(IC <= NbElements()) {
356 Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
357 fsp->SetRadius( UandR, IinC );
358 }
359}
360
361//=======================================================================
362//function : IsConstant
363//purpose :
364//=======================================================================
365
366Standard_Boolean ChFi3d_FilBuilder::IsConstant(const Standard_Integer IC,
367 const TopoDS_Edge& E)
368{
369 if(IC <= NbElements()) {
370 Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
371 return fsp->IsConstant(fsp->Index(E));
372 }
373 return 0;
374}
375
376//=======================================================================
377//function : Radius
378//purpose :
379//=======================================================================
380
381Standard_Real ChFi3d_FilBuilder::Radius(const Standard_Integer IC,
382 const TopoDS_Edge& E)
383{
384 if(IC <= NbElements()) {
385 Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
386 return fsp->Radius(E);
387 }
388 return -1.;
389}
390
391//=======================================================================
392//function : GetBounds
393//purpose :
394//=======================================================================
395
396Standard_Boolean ChFi3d_FilBuilder::GetBounds(const Standard_Integer IC,
397 const TopoDS_Edge& E,
398 Standard_Real& F,
399 Standard_Real& L)
400{
401 if(IC <= NbElements()) {
402 Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
403 Handle(Law_Function)& loi = fsp->ChangeLaw(E);
404 if(!loi.IsNull()){
405 loi->Bounds(F,L);
406 return Standard_True;
407 }
408 }
409 return Standard_False;
410}
411
412//=======================================================================
413//function : GetLaw
414//purpose :
415//=======================================================================
416
417Handle(Law_Function) ChFi3d_FilBuilder::GetLaw(const Standard_Integer IC,
418 const TopoDS_Edge& E)
419{
420 if(IC <= NbElements()) {
421 Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
422 return fsp->ChangeLaw(E);
423 }
424 return Handle(Law_Function)();
425}
426
427//=======================================================================
428//function : SetLaw
429//purpose :
430//=======================================================================
431
432void ChFi3d_FilBuilder::SetLaw(const Standard_Integer IC,
433 const TopoDS_Edge& E,
434 const Handle(Law_Function)& L)
435{
81bba717 436 // Check if it is necessary to check borders!
7fd59977 437 if(IC <= NbElements()) {
438 Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
439 fsp->ChangeLaw(E) = L;
440 }
441}
442
443//=======================================================================
444//function : Simulate
445//purpose :
446//=======================================================================
447
448void ChFi3d_FilBuilder::Simulate (const Standard_Integer IC)
449{
0797d9d3 450#ifdef OCCT_DEBUG
7fd59977 451 if(ChFi3d_GettraceCHRON()){
452 simul.Reset();elspine.Reset();chemine.Reset();
453 simul.Start();
454 }
455#endif
456 ChFiDS_ListIteratorOfListOfStripe itel;
457 Standard_Integer i = 1;
458 for (itel.Initialize(myListStripe);itel.More(); itel.Next(), i++) {
459 if(i == IC){
460 PerformSetOfSurf(itel.Value(), Standard_True);
461 break;
462 }
463 }
0797d9d3 464#ifdef OCCT_DEBUG
7fd59977 465 if(ChFi3d_GettraceCHRON()){
466 simul.Stop();
81bba717 467 cout<<"Total simulation time : ";
7fd59977 468 simul.Show();
81bba717 469 cout<<"Spine construction time : ";
7fd59977 470 elspine.Show();
81bba717 471 cout<<"and process time : ";
7fd59977 472 chemine.Show();
473 }
474#endif
475}
476
477//=======================================================================
478//function : NbSurf
479//purpose :
480//=======================================================================
481
482Standard_Integer ChFi3d_FilBuilder::NbSurf (const Standard_Integer IC) const
483{
484 ChFiDS_ListIteratorOfListOfStripe itel;
485 Standard_Integer i = 1;
486 for (itel.Initialize(myListStripe);itel.More(); itel.Next(), i++) {
487 if(i == IC){
488 return itel.Value()->SetOfSurfData()->Length();
489 }
490 }
491 return 0;
492}
493
494//=======================================================================
495//function : Sect
496//purpose :
497//=======================================================================
498
499Handle(ChFiDS_SecHArray1) ChFi3d_FilBuilder::Sect (const Standard_Integer IC,
500 const Standard_Integer IS) const
501{
502 ChFiDS_ListIteratorOfListOfStripe itel;
503 Standard_Integer i = 1;
504 Handle(ChFiDS_SecHArray1) res;
505 for (itel.Initialize(myListStripe);itel.More(); itel.Next(), i++) {
506 if(i == IC){
507 Handle(MMgt_TShared) bid = itel.Value()->SetOfSurfData()->Value(IS)->Simul();
508 res = Handle(ChFiDS_SecHArray1)::DownCast(bid);
509 return res;
510 }
511 }
512 return Handle(ChFiDS_SecHArray1)();
513}
514
515//=======================================================================
516//function : SimulKPart
517//purpose :
518//=======================================================================
519
520void ChFi3d_FilBuilder::SimulKPart(const Handle(ChFiDS_SurfData)& SD) const
521{
522 TopOpeBRepDS_DataStructure& DStr = myDS->ChangeDS();
523 Handle(Geom_Surface) S = DStr.Surface(SD->Surf()).Surface();
524 gp_Pnt2d p1f = SD->InterferenceOnS1().PCurveOnSurf()->
525 Value(SD->InterferenceOnS1().FirstParameter());
526 gp_Pnt2d p1l = SD->InterferenceOnS1().PCurveOnSurf()->
527 Value(SD->InterferenceOnS1().LastParameter());
528 gp_Pnt2d p2f = SD->InterferenceOnS2().PCurveOnSurf()->
529 Value(SD->InterferenceOnS2().FirstParameter());
530 gp_Pnt2d p2l = SD->InterferenceOnS2().PCurveOnSurf()->
531 Value(SD->InterferenceOnS2().LastParameter());
532 GeomAdaptor_Surface AS(S);
533 Handle(ChFiDS_SecHArray1) sec;
534 Standard_Real u1,v1,u2,v2;
535 GeomAbs_SurfaceType typ = AS.GetType();
536 switch (typ){
537 case GeomAbs_Cylinder:
538 {
539 u1 = p1f.X();
540 u2 = p2f.X();
541 v1 = Max(p1f.Y(),p2f.Y());
542 v2 = Min(p1l.Y(),p2l.Y());
543 sec = new ChFiDS_SecHArray1(1,2);
544 gp_Cylinder Cy = AS.Cylinder();
545 ChFiDS_CircSection& sec1 = sec->ChangeValue(1);
546 ChFiDS_CircSection& sec2 = sec->ChangeValue(2);
547 sec1.Set(ElSLib::CylinderVIso(Cy.Position(), Cy.Radius(), v1), u1, u2);
548 sec2.Set(ElSLib::CylinderVIso(Cy.Position(), Cy.Radius(), v2), u1, u2);
549 }
550 break;
551 case GeomAbs_Torus:
552 {
553 v1 = p1f.Y();
554 v2 = p2f.Y();
555 u1 = Max(p1f.X(),p2f.X());
556 u2 = Min(p1l.X(),p2l.X());
557 Standard_Real ang = (u2-u1);
558 gp_Torus To = AS.Torus();
559 Standard_Real majr = To.MajorRadius(), minr = To.MinorRadius();
c6541a0c 560 Standard_Integer n = (Standard_Integer) (36.*ang/M_PI + 1);
7fd59977 561 if(n<2) n = 2;
562 sec = new ChFiDS_SecHArray1(1, n);
563 for (Standard_Integer i = 1; i <= n; i++) {
564 ChFiDS_CircSection& isec = sec->ChangeValue(i);
565 Standard_Real u = u1 + (i - 1)*(u2 - u1)/(n-1);
566 isec.Set(ElSLib::TorusUIso(To.Position(), majr, minr, u), v1, v2);
567 }
568 }
569 break;
570 case GeomAbs_Sphere:
571 {
572 v1 = p1f.Y();
573 v2 = p2f.Y();
574 u1 = Max(p1f.X(),p2f.X());
575 u2 = Min(p1l.X(),p2l.X());
576 Standard_Real ang = (u2-u1);
577 gp_Sphere Sp = AS.Sphere();
578 Standard_Real rad = Sp.Radius();
c6541a0c 579 Standard_Integer n = (Standard_Integer) (36.*ang/M_PI + 1);
7fd59977 580 if(n<2) n = 2;
581 sec = new ChFiDS_SecHArray1(1, n);
582 for (Standard_Integer i = 1; i <= n; i++) {
583 ChFiDS_CircSection& isec = sec->ChangeValue(i);
584 Standard_Real u = u1 + (i - 1)*(u2 - u1)/(n-1);
585 isec.Set(ElSLib::SphereUIso(Sp.Position(), rad, u), v1, v2);
586 }
587 }
588 break;
589 default:
590 break;
591 }
592 SD->SetSimul(sec);
593}
594
595
596//=======================================================================
597//function : SimulSurf
598//purpose :
599//=======================================================================
600
601Standard_Boolean
602ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
603 const Handle(ChFiDS_HElSpine)& HGuide,
604 const Handle(ChFiDS_Spine)& Spine,
605 const Standard_Integer Choix,
606 const Handle(BRepAdaptor_HSurface)& S1,
607 const Handle(Adaptor3d_TopolTool)& I1,
608 const Handle(BRepAdaptor_HSurface)& S2,
609 const Handle(Adaptor3d_TopolTool)& I2,
610 const Standard_Real TolGuide,
611 Standard_Real& First,
612 Standard_Real& Last,
613 const Standard_Boolean Inside,
614 const Standard_Boolean Appro,
615 const Standard_Boolean Forward,
616 const Standard_Boolean RecOnS1,
617 const Standard_Boolean RecOnS2,
618 const math_Vector& Soldep,
dde68833 619 Standard_Integer& intf,
620 Standard_Integer& intl)
7fd59977 621{
622 Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Spine);
623 if(fsp.IsNull()) Standard_ConstructionError::Raise
81bba717 624 ("SimulSurf : this is not the spine of the fillet");
7fd59977 625 Handle(BRepBlend_Line) lin;
0797d9d3 626#ifdef OCCT_DEBUG
7fd59977 627// TopAbs_Orientation Or = S1->ChangeSurface().Face().Orientation();
628#endif
81bba717 629 // Flexible parameters!!!
7fd59977 630 Standard_Real locfleche, MaxStep;
631 SimulParams(HGuide,fsp,MaxStep,locfleche);
632 Handle(ChFiDS_SecHArray1) sec;
633 gp_Pnt2d pf1,pl1,pf2,pl2;
634
635 Standard_Real PFirst = First;
636 if(intf) First = fsp->FirstParameter(1);
637 if(intl) Last = fsp->LastParameter(fsp->NbEdges());
638 if (fsp->IsConstant()) {
639 BRepBlend_ConstRad Func(S1,S2,HGuide);
640 BRepBlend_ConstRadInv FInv(S1,S2,HGuide);
641 Func.Set(fsp->Radius(),Choix);
642 FInv.Set(fsp->Radius(),Choix);
643 Func.Set(myShape);
644 done = SimulData(Data,HGuide,lin,S1,I1 ,
645 S2,I2,Func,FInv,PFirst,MaxStep,locfleche,
646 TolGuide,First,Last,Inside,Appro,Forward,
647 Soldep,4,RecOnS1,RecOnS2);
648 if(!done) return Standard_False;
649 Standard_Integer nbp = lin->NbPoints();
650 sec = new ChFiDS_SecHArray1(1,nbp);
651 for(Standard_Integer i = 1; i <= nbp; i++){
652 ChFiDS_CircSection& isec = sec->ChangeValue(i);
653 Standard_Real u1,v1,u2,v2,w,p1,p2;
654 gp_Circ ci;
655 const Blend_Point& p = lin->Point(i);
656 p.ParametersOnS1(u1,v1);
657 p.ParametersOnS2(u2,v2);
658 w = p.Parameter();
659 Func.Section(w,u1,v1,u2,v2,p1,p2,ci);
660 isec.Set(ci,p1,p2);
661 if(i == 1) {pf1.SetCoord(u1,v1); pf2.SetCoord(u2,v2);}
662 if(i == nbp) {pl1.SetCoord(u1,v1); pl2.SetCoord(u2,v2);}
663 }
664 }
665 else{
666 BRepBlend_EvolRad Func(S1,S2,HGuide,fsp->Law(HGuide));
667 BRepBlend_EvolRadInv FInv(S1,S2,HGuide,fsp->Law(HGuide));
668 Func.Set(Choix);
669 FInv.Set(Choix);
670 Func.Set(myShape);
671 done = SimulData(Data,HGuide,lin,S1,I1 ,
672 S2,I2,Func,FInv,PFirst,MaxStep,locfleche,
673 TolGuide,First,Last,Inside,Appro,Forward,
674 Soldep,4,RecOnS1,RecOnS2);
675 if(!done) return Standard_False;
676 Standard_Integer nbp = lin->NbPoints();
677 sec = new ChFiDS_SecHArray1(1,nbp);
678 for(Standard_Integer i = 1; i <= nbp; i++){
679 ChFiDS_CircSection& isec = sec->ChangeValue(i);
680 Standard_Real u1,v1,u2,v2,w,p1,p2;
681 gp_Circ ci;
682 const Blend_Point& p = lin->Point(i);
683 p.ParametersOnS1(u1,v1);
684 p.ParametersOnS2(u2,v2);
685 w = p.Parameter();
686 Func.Section(w,u1,v1,u2,v2,p1,p2,ci);
687 isec.Set(ci,p1,p2);
688 if(i == 1) {pf1.SetCoord(u1,v1); pf2.SetCoord(u2,v2);}
689 if(i == nbp) {pl1.SetCoord(u1,v1); pl2.SetCoord(u2,v2);}
690 }
691 }
692 Data->SetSimul(sec);
693 Data->Set2dPoints(pf1,pl1,pf2,pl2);
694 ChFi3d_FilCommonPoint(lin->StartPointOnFirst(),lin->TransitionOnS1(),
695 Standard_True, Data->ChangeVertexFirstOnS1(),tolesp);
696 ChFi3d_FilCommonPoint(lin->EndPointOnFirst(),lin->TransitionOnS1(),
697 Standard_False,Data->ChangeVertexLastOnS1(),tolesp);
698 ChFi3d_FilCommonPoint(lin->StartPointOnSecond(),lin->TransitionOnS2(),
699 Standard_True, Data->ChangeVertexFirstOnS2(),tolesp);
700 ChFi3d_FilCommonPoint(lin->EndPointOnSecond(),lin->TransitionOnS2(),
701 Standard_False, Data->ChangeVertexLastOnS2(),tolesp);
702 Standard_Boolean reverse = (!Forward || Inside);
703 if(intf && reverse){
dde68833 704 Standard_Boolean ok = Standard_False;
7fd59977 705 const ChFiDS_CommonPoint& cp1 = Data->VertexFirstOnS1();
706 if(cp1.IsOnArc()){
707 TopoDS_Face F1 = S1->ChangeSurface().Face();
708 TopoDS_Face bid;
dde68833 709 intf = !SearchFace(Spine,cp1,F1,bid);
710 ok = intf != 0;
7fd59977 711 }
712 const ChFiDS_CommonPoint& cp2 = Data->VertexFirstOnS2();
713 if(cp2.IsOnArc() && !ok){
714 TopoDS_Face F2 = S2->ChangeSurface().Face();
715 TopoDS_Face bid;
716 intf = !SearchFace(Spine,cp2,F2,bid);
717 }
718 }
719 if(intl){
720 Standard_Boolean ok = 0;
721 const ChFiDS_CommonPoint& cp1 = Data->VertexLastOnS1();
722 if(cp1.IsOnArc()){
723 TopoDS_Face F1 = S1->ChangeSurface().Face();
724 TopoDS_Face bid;
dde68833 725 intl = !SearchFace(Spine,cp1,F1,bid);
726 ok = intl != 0;
7fd59977 727 }
728 const ChFiDS_CommonPoint& cp2 = Data->VertexLastOnS2();
729 if(cp2.IsOnArc() && !ok){
730 TopoDS_Face F2 = S2->ChangeSurface().Face();
731 TopoDS_Face bid;
732 intl = !SearchFace(Spine,cp2,F2,bid);
733 }
734 }
735 return Standard_True;
736}
737
738//=======================================================================
739//function : SimulSurf
740//purpose :
741//=======================================================================
742
743void ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
744 const Handle(ChFiDS_HElSpine)& HGuide,
745 const Handle(ChFiDS_Spine)& Spine,
746 const Standard_Integer Choix,
747 const Handle(BRepAdaptor_HSurface)& HS1,
748 const Handle(Adaptor3d_TopolTool)& I1,
749 const Handle(BRepAdaptor_HCurve2d)& PC1,
750 const Handle(BRepAdaptor_HSurface)& HSref1,
751 const Handle(BRepAdaptor_HCurve2d)& PCref1,
752 Standard_Boolean& Decroch1,
753 const Handle(BRepAdaptor_HSurface)& HS2,
754 const Handle(Adaptor3d_TopolTool)& I2,
755 const TopAbs_Orientation Or2,
756 const Standard_Real /*Fleche*/,
757 const Standard_Real TolGuide,
758 Standard_Real& First,
759 Standard_Real& Last,
760 const Standard_Boolean Inside,
761 const Standard_Boolean Appro,
762 const Standard_Boolean Forward,
763 const Standard_Boolean RecP,
764 const Standard_Boolean RecS,
765 const Standard_Boolean RecRst,
766 const math_Vector& Soldep)
767{
768 Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Spine);
769 if(fsp.IsNull()) Standard_ConstructionError::Raise
81bba717 770 ("PerformSurf : this is not the spine of the fillet");
7fd59977 771 Handle(BRepBlend_Line) lin;
772
81bba717 773 // Flexible parameters!
7fd59977 774 Standard_Real locfleche, MaxStep;
775 SimulParams(HGuide,fsp,MaxStep,locfleche);
776 Handle(ChFiDS_SecHArray1) sec;
777 gp_Pnt2d pf,pl,ppcf,ppcl;
778
779 Standard_Real PFirst = First;
780 if(fsp->IsConstant()){
781 BRepBlend_SurfRstConstRad func(HS2,HS1,PC1,HGuide);
782 func.Set(HSref1,PCref1);
783 Handle(Adaptor3d_HCurveOnSurface) HC = new Adaptor3d_HCurveOnSurface();
543a9964 784 HC->ChangeCurve().Load(PC1, HS1);
7fd59977 785 BRepBlend_SurfCurvConstRadInv finvc(HS2,HC,HGuide);
786 BRepBlend_SurfPointConstRadInv finvp(HS2,HGuide);
787 BRepBlend_ConstRadInv finv(HS2,HSref1,HGuide);
788 finv.Set(Standard_False,PCref1);
789
790 Standard_Real rad = fsp->Radius();
791 Standard_Integer petitchoix = 1;
792 if(Or2 == TopAbs_REVERSED) petitchoix = 3;
793 if(Choix%2 == 0) petitchoix++;
794 finv.Set(rad,Choix);
795 finvc.Set(rad,petitchoix);
796 finvp.Set(rad,petitchoix);
797 func.Set(rad,petitchoix);
798 func.Set(myShape);
799
800 done = SimulData(Data,HGuide,lin,HS2,I2,HS1,PC1,I1,Decroch1,
801 func,finv,finvp,finvc,
802 PFirst,MaxStep,locfleche,TolGuide,First,Last,
803 Soldep,4,Inside,Appro,Forward,RecP,RecS,RecRst);
804 if(!done) {
81bba717 805 Standard_Failure::Raise("SimulSurf : Failed process!");
7fd59977 806 }
807 Standard_Integer nbp = lin->NbPoints();
808 sec = new ChFiDS_SecHArray1(1,nbp);
809 for(Standard_Integer i = 1; i <= nbp; i++){
810 ChFiDS_CircSection& isec = sec->ChangeValue(i);
811 Standard_Real u,v,w,param,p1,p2;
812 gp_Circ ci;
813 const Blend_Point& p = lin->Point(i);
814 p.ParametersOnS(u,v);
815 w = p.ParameterOnC();
816 param = p.Parameter();
817 func.Section(param,u,v,w,p1,p2,ci);
818 isec.Set(ci,p1,p2);
819 if(i == 1) {pf.SetCoord(u,v);p.ParametersOnS2(u,v);ppcf.SetCoord(u,v);}
820 if(i == nbp) {pl.SetCoord(u,v);p.ParametersOnS2(u,v);ppcl.SetCoord(u,v);}
821 }
822 }
823 else {
824 BRepBlend_SurfRstEvolRad func(HS2,HS1,PC1,HGuide,fsp->Law(HGuide));
825 Handle(Adaptor3d_HCurveOnSurface) HC = new Adaptor3d_HCurveOnSurface();
543a9964 826 HC->ChangeCurve().Load(PC1, HS1);
7fd59977 827 BRepBlend_SurfCurvEvolRadInv finvc(HS2,HC,HGuide,fsp->Law(HGuide));
828 BRepBlend_SurfPointEvolRadInv finvp(HS2,HGuide,fsp->Law(HGuide));
829 BRepBlend_EvolRadInv finv(HS2,HSref1,HGuide,fsp->Law(HGuide));
830 finv.Set(Standard_False,PCref1);
831 Standard_Integer petitchoix = 1;
832 if(Or2 == TopAbs_REVERSED) petitchoix = 3;
833 if(Choix%2 == 0) petitchoix++;
834 finv.Set(Choix);
835 finvc.Set(petitchoix);
836 finvp.Set(petitchoix);
837 func.Set(petitchoix);
838 func.Set(myShape);
839 done = SimulData(Data,HGuide,lin,HS2,I2,HS1,PC1,I1,Decroch1,
840 func,finv,finvp,finvc,
841 PFirst,MaxStep,locfleche,TolGuide,First,Last,
842 Soldep,4,Inside,Appro,Forward,RecP,RecS,RecRst);
81bba717 843 if(!done) Standard_Failure::Raise("SimulSurf : Fail !");
7fd59977 844 Standard_Integer nbp = lin->NbPoints();
845 sec = new ChFiDS_SecHArray1(1,nbp);
846 for(Standard_Integer i = 1; i <= nbp; i++){
847 ChFiDS_CircSection& isec = sec->ChangeValue(i);
848 Standard_Real u,v,w,param,p1,p2;
849 gp_Circ ci;
850 const Blend_Point& p = lin->Point(i);
851 p.ParametersOnS(u,v);
852 w = p.ParameterOnC();
853 param = p.Parameter();
854 func.Section(param,u,v,w,p1,p2,ci);
855 isec.Set(ci,p1,p2);
856 if(i == 1) {pf.SetCoord(u,v);p.ParametersOnS2(u,v);ppcf.SetCoord(u,v);}
857 if(i == nbp) {pl.SetCoord(u,v);p.ParametersOnS2(u,v);ppcl.SetCoord(u,v);}
858 }
859 }
860 Data->SetSimul(sec);
861// gp_Pnt2d pbid;
862 Data->Set2dPoints(ppcf,ppcl,pf,pl);
863 ChFi3d_FilCommonPoint(lin->StartPointOnFirst(),lin->TransitionOnS1(),
864 Standard_True, Data->ChangeVertexFirstOnS2(),tolesp);
865 ChFi3d_FilCommonPoint(lin->EndPointOnFirst(),lin->TransitionOnS1(),
866 Standard_False,Data->ChangeVertexLastOnS2(),tolesp);
867 ChFi3d_FilCommonPoint(lin->StartPointOnSecond(),lin->TransitionOnS2(),
868 Standard_True, Data->ChangeVertexFirstOnS1(),tolesp);
869 ChFi3d_FilCommonPoint(lin->EndPointOnSecond(),lin->TransitionOnS2(),
870 Standard_False, Data->ChangeVertexLastOnS1(),tolesp);
871}
872
873//=======================================================================
874//function : SimulSurf
875//purpose :
876//=======================================================================
877
878void ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
879 const Handle(ChFiDS_HElSpine)& HGuide,
880 const Handle(ChFiDS_Spine)& Spine,
881 const Standard_Integer Choix,
882 const Handle(BRepAdaptor_HSurface)& HS1,
883 const Handle(Adaptor3d_TopolTool)& I1,
884 const TopAbs_Orientation Or1,
885 const Handle(BRepAdaptor_HSurface)& HS2,
886 const Handle(Adaptor3d_TopolTool)& I2,
887 const Handle(BRepAdaptor_HCurve2d)& PC2,
888 const Handle(BRepAdaptor_HSurface)& HSref2,
889 const Handle(BRepAdaptor_HCurve2d)& PCref2,
890 Standard_Boolean& Decroch2,
81bba717 891 const Standard_Real /*Arrow*/,
7fd59977 892 const Standard_Real TolGuide,
893 Standard_Real& First,
894 Standard_Real& Last,
895 const Standard_Boolean Inside,
896 const Standard_Boolean Appro,
897 const Standard_Boolean Forward,
898 const Standard_Boolean RecP,
899 const Standard_Boolean RecS,
900 const Standard_Boolean RecRst,
901 const math_Vector& Soldep)
902{
903 Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Spine);
904 if(fsp.IsNull()) Standard_ConstructionError::Raise
81bba717 905 ("PerformSurf : it is not the spine of a fillet");
7fd59977 906 Handle(BRepBlend_Line) lin;
907
81bba717 908 // Flexible parameters!
7fd59977 909 Standard_Real locfleche, MaxStep;
910 SimulParams(HGuide,fsp,MaxStep,locfleche);
911 Handle(ChFiDS_SecHArray1) sec;
912 gp_Pnt2d pf,pl,ppcf,ppcl;
913
914 Standard_Real PFirst = First;
915 if(fsp->IsConstant()){
916 BRepBlend_SurfRstConstRad func(HS1,HS2,PC2,HGuide);
917 func.Set(HSref2,PCref2);
918 Handle(Adaptor3d_HCurveOnSurface) HC = new Adaptor3d_HCurveOnSurface();
543a9964 919 HC->ChangeCurve().Load(PC2, HS2);
7fd59977 920 BRepBlend_SurfCurvConstRadInv finvc(HS1,HC,HGuide);
921 BRepBlend_SurfPointConstRadInv finvp(HS1,HGuide);
922 BRepBlend_ConstRadInv finv(HS1,HSref2,HGuide);
923 finv.Set(Standard_False,PCref2);
924
925 Standard_Real rad = fsp->Radius();
926 Standard_Integer petitchoix = 1;
927 if(Or1 == TopAbs_REVERSED) petitchoix = 3;
928 if(Choix%2 == 0) petitchoix++;
929 finv.Set(rad,Choix);
930 finvc.Set(rad,petitchoix);
931 finvp.Set(rad,petitchoix);
932 func.Set(rad,petitchoix);
933 func.Set(myShape);
934
935 done = SimulData(Data,HGuide,lin,HS1,I1,HS2,PC2,I2,Decroch2,
936 func,finv,finvp,finvc,
937 PFirst,MaxStep,locfleche,TolGuide,First,Last,
938 Soldep,4,Inside,Appro,Forward,RecP,RecS,RecRst);
81bba717 939 if(!done) Standard_Failure::Raise("SimulSurf : Failed Processing!");
7fd59977 940 Standard_Integer nbp = lin->NbPoints();
941 sec = new ChFiDS_SecHArray1(1,nbp);
942 for(Standard_Integer i = 1; i <= nbp; i++){
943 ChFiDS_CircSection& isec = sec->ChangeValue(i);
944 Standard_Real u,v,w,param,p1,p2;
945 gp_Circ ci;
946 const Blend_Point& p = lin->Point(i);
947 p.ParametersOnS(u,v);
948 w = p.ParameterOnC();
949 param = p.Parameter();
950 func.Section(param,u,v,w,p1,p2,ci);
951 isec.Set(ci,p1,p2);
952 if(i == 1) {pf.SetCoord(u,v);p.ParametersOnS2(u,v);ppcf.SetCoord(u,v);}
953 if(i == nbp) {pl.SetCoord(u,v);p.ParametersOnS2(u,v);ppcl.SetCoord(u,v);}
954 }
955 }
956 else {
957 BRepBlend_SurfRstEvolRad func(HS1,HS2,PC2,HGuide,fsp->Law(HGuide));
958 Handle(Adaptor3d_HCurveOnSurface) HC = new Adaptor3d_HCurveOnSurface();
543a9964 959 HC->ChangeCurve().Load(PC2, HS2);
7fd59977 960 BRepBlend_SurfCurvEvolRadInv finvc(HS1,HC,HGuide,fsp->Law(HGuide));
961 BRepBlend_SurfPointEvolRadInv finvp(HS1,HGuide,fsp->Law(HGuide));
962 BRepBlend_EvolRadInv finv(HS1,HSref2,HGuide,fsp->Law(HGuide));
963 finv.Set(Standard_False,PCref2);
964 Standard_Integer petitchoix = 1;
965 if(Or1 == TopAbs_REVERSED) petitchoix = 3;
966 if(Choix%2 == 0) petitchoix++;
967 finv.Set(Choix);
968 finvc.Set(petitchoix);
969 finvp.Set(petitchoix);
970 func.Set(petitchoix);
971 func.Set(myShape);
972 done = SimulData(Data,HGuide,lin,HS1,I1,HS2,PC2,I2,Decroch2,
973 func,finv,finvp,finvc,
974 PFirst,MaxStep,locfleche,TolGuide,First,Last,
975 Soldep,4,Inside,Appro,Forward,RecP,RecS,RecRst);
81bba717 976 if(!done) Standard_Failure::Raise("SimulSurf : Fail !");
7fd59977 977 Standard_Integer nbp = lin->NbPoints();
978 sec = new ChFiDS_SecHArray1(1,nbp);
979 for(Standard_Integer i = 1; i <= nbp; i++){
980 ChFiDS_CircSection& isec = sec->ChangeValue(i);
981 Standard_Real u,v,w,param,p1,p2;
982 gp_Circ ci;
983 const Blend_Point& p = lin->Point(i);
984 p.ParametersOnS(u,v);
985 w = p.ParameterOnC();
986 param = p.Parameter();
987 func.Section(param,u,v,w,p1,p2,ci);
988 isec.Set(ci,p1,p2);
989 if(i == 1) {pf.SetCoord(u,v);p.ParametersOnS2(u,v);ppcf.SetCoord(u,v);}
990 if(i == nbp) {pl.SetCoord(u,v);p.ParametersOnS2(u,v);ppcl.SetCoord(u,v);}
991 }
992 }
993 Data->SetSimul(sec);
994 //gp_Pnt2d pbid;
995 Data->Set2dPoints(pf,pl,ppcf,ppcl);
996 ChFi3d_FilCommonPoint(lin->StartPointOnFirst(),lin->TransitionOnS1(),
997 Standard_True, Data->ChangeVertexFirstOnS1(),tolesp);
998 ChFi3d_FilCommonPoint(lin->EndPointOnFirst(),lin->TransitionOnS1(),
999 Standard_False,Data->ChangeVertexLastOnS1(),tolesp);
1000 ChFi3d_FilCommonPoint(lin->StartPointOnSecond(),lin->TransitionOnS2(),
1001 Standard_True, Data->ChangeVertexFirstOnS2(),tolesp);
1002 ChFi3d_FilCommonPoint(lin->EndPointOnSecond(),lin->TransitionOnS2(),
1003 Standard_False, Data->ChangeVertexLastOnS2(),tolesp);
1004}
1005
1006
1007
1008//=======================================================================
1009//function : SimulSurf
1010//purpose :
1011//=======================================================================
1012
1013void ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
1014 const Handle(ChFiDS_HElSpine)& HGuide,
1015 const Handle(ChFiDS_Spine)& Spine,
1016 const Standard_Integer Choix,
1017 const Handle(BRepAdaptor_HSurface)& HS1,
1018 const Handle(Adaptor3d_TopolTool)& I1,
1019 const Handle(BRepAdaptor_HCurve2d)& PC1,
1020 const Handle(BRepAdaptor_HSurface)& HSref1,
1021 const Handle(BRepAdaptor_HCurve2d)& PCref1,
1022 Standard_Boolean& Decroch1,
1023 const TopAbs_Orientation Or1,
1024 const Handle(BRepAdaptor_HSurface)& HS2,
1025 const Handle(Adaptor3d_TopolTool)& I2,
1026 const Handle(BRepAdaptor_HCurve2d)& PC2,
1027 const Handle(BRepAdaptor_HSurface)& HSref2,
1028 const Handle(BRepAdaptor_HCurve2d)& PCref2,
1029 Standard_Boolean& Decroch2,
1030 const TopAbs_Orientation Or2,
1031 const Standard_Real /*Fleche*/,
1032 const Standard_Real TolGuide,
1033 Standard_Real& First,
1034 Standard_Real& Last,
1035 const Standard_Boolean Inside,
1036 const Standard_Boolean Appro,
1037 const Standard_Boolean Forward,
1038 const Standard_Boolean RecP1,
1039 const Standard_Boolean RecRst1,
1040 const Standard_Boolean RecP2,
1041 const Standard_Boolean RecRst2,
1042 const math_Vector& Soldep)
1043{
1044 Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Spine);
1045 if(fsp.IsNull()) Standard_ConstructionError::Raise
81bba717 1046 ("PerformSurf : it is not the spine of a fillet");
7fd59977 1047 Handle(BRepBlend_Line) lin;
1048
81bba717 1049 // Flexible parameters!
7fd59977 1050 Standard_Real locfleche, MaxStep;
1051 SimulParams(HGuide,fsp,MaxStep,locfleche);
1052 Handle(ChFiDS_SecHArray1) sec;
1053// gp_Pnt2d pf,pl;
1054
1055 Standard_Integer ch1 = 1, ch2 = 2;
1056 Standard_Real PFirst = First;
1057
1058 if(fsp->IsConstant()){
1059 BRepBlend_RstRstConstRad func(HS1, PC1, HS2, PC2, HGuide);
1060 func.Set(HSref1, PCref1, HSref2, PCref2);
1061 Handle(Adaptor3d_HCurveOnSurface) HC1 = new Adaptor3d_HCurveOnSurface();
543a9964 1062 HC1->ChangeCurve().Load(PC1, HS1);
7fd59977 1063 Handle(Adaptor3d_HCurveOnSurface) HC2 = new Adaptor3d_HCurveOnSurface();
543a9964 1064 HC2->ChangeCurve().Load(PC2, HS2);
7fd59977 1065 BRepBlend_SurfCurvConstRadInv finv1(HSref1, HC2, HGuide);
1066 BRepBlend_CurvPointRadInv finvp1(HGuide, HC2);
1067 BRepBlend_SurfCurvConstRadInv finv2(HSref2, HC1, HGuide);
1068 BRepBlend_CurvPointRadInv finvp2(HGuide, HC1);
1069
1070 finv1.Set(PCref1);
1071 finv2.Set(PCref2);
1072
1073
1074 Standard_Real rad = fsp->Radius();
1075 if(Or1 == TopAbs_REVERSED) ch1 = 3;
1076 if(Or2 == TopAbs_REVERSED) ch2 = 3;
1077
1078 finv1.Set(rad, ch1);
1079 finvp1.Set(Choix);
1080 finv2.Set(rad, ch2);
1081 finvp2.Set(Choix);
1082 func.Set(rad, Choix);
1083 func.Set(myShape);
1084
1085 done = SimulData(Data, HGuide, lin, HS1, PC1, I1, Decroch1, HS2, PC2, I2, Decroch2,
1086 func, finv1, finvp1, finv2, finvp2,
1087 PFirst, MaxStep, locfleche, TolGuide, First, Last,
1088 Soldep, 4, Inside, Appro, Forward, RecP1, RecRst1, RecP2, RecRst2);
81bba717 1089 if(!done) Standard_Failure::Raise("SimulSurf : Failed processing!");
7fd59977 1090 Standard_Integer nbp = lin->NbPoints();
1091 sec = new ChFiDS_SecHArray1(1,nbp);
1092 for(Standard_Integer i = 1; i <= nbp; i++){
1093 ChFiDS_CircSection& isec = sec->ChangeValue(i);
1094 Standard_Real u, v, param, p1, p2;
1095 gp_Circ ci;
1096 const Blend_Point& p = lin->Point(i);
1097 u = p.ParameterOnC1();
1098 v = p.ParameterOnC2();
1099 param = p.Parameter();
1100 func.Section(param, u, v, p1, p2, ci);
1101 isec.Set(ci, p1, p2);
1102// if(i == 1) {pf.SetCoord(u,v);}
1103// if(i == nbp) {pl.SetCoord(u,v);}
1104 }
1105 }
1106 else {
1107 BRepBlend_RstRstEvolRad func(HS1,PC1, HS2, PC2, HGuide, fsp->Law(HGuide));
1108 func.Set(HSref1, PCref1, HSref2, PCref2);
1109 Handle(Adaptor3d_HCurveOnSurface) HC1 = new Adaptor3d_HCurveOnSurface();
543a9964 1110 HC1->ChangeCurve().Load(PC1, HS1);
7fd59977 1111 Handle(Adaptor3d_HCurveOnSurface) HC2 = new Adaptor3d_HCurveOnSurface();
543a9964 1112 HC2->ChangeCurve().Load(PC2, HS2);
7fd59977 1113
1114 BRepBlend_SurfCurvEvolRadInv finv1(HSref1, HC2, HGuide, fsp->Law(HGuide));
1115 BRepBlend_CurvPointRadInv finvp1(HGuide, HC2);
1116 BRepBlend_SurfCurvEvolRadInv finv2(HSref2, HC1, HGuide, fsp->Law(HGuide));
1117 BRepBlend_CurvPointRadInv finvp2(HGuide, HC1);
1118
1119 finv1.Set(PCref1);
1120 finv2.Set(PCref2);
1121
1122 Standard_Integer ch11 = 1, ch22 = 2;
1123
1124 if(Or1 == TopAbs_REVERSED) ch11 = 3;
1125 if(Or2 == TopAbs_REVERSED) ch22 = 3;
1126
1127
1128 finv1.Set(ch11);
1129 finvp1.Set(Choix);
1130 finv2.Set(ch22);
1131 finvp2.Set(Choix);
1132 func.Set(Choix);
1133 func.Set(myShape);
1134
1135 done = SimulData(Data, HGuide, lin, HS1, PC1, I1, Decroch1, HS2, PC2, I2, Decroch2,
1136 func, finv1, finvp1, finv2, finvp2,
1137 PFirst, MaxStep, locfleche, TolGuide, First, Last,
1138 Soldep, 4, Inside, Appro, Forward, RecP1, RecRst1, RecP2, RecRst2);
1139
81bba717 1140 if(!done) Standard_Failure::Raise("SimulSurf : Fail !");
7fd59977 1141 Standard_Integer nbp = lin->NbPoints();
1142 sec = new ChFiDS_SecHArray1(1, nbp);
1143 for(Standard_Integer i = 1; i <= nbp; i++){
1144 ChFiDS_CircSection& isec = sec->ChangeValue(i);
1145 Standard_Real u, v, param, p1, p2;
1146 gp_Circ ci;
1147 const Blend_Point& p = lin->Point(i);
1148 u = p.ParameterOnC1();
1149 v = p.ParameterOnC2();
1150 param = p.Parameter();
1151 func.Section(param, u, v, p1, p2, ci);
1152 isec.Set(ci, p1, p2);
1153// if(i == 1) {pf.SetCoord(u,v);}
1154// if(i == nbp) {pl.SetCoord(u,v);}
1155 }
1156 }
1157 Data->SetSimul(sec);
1158// gp_Pnt2d pbid;
1159// Data->Set2dPoints(pf,pl,pbid,pbid);
1160
1161 ChFi3d_FilCommonPoint(lin->StartPointOnFirst(),lin->TransitionOnS1(),
1162 Standard_True, Data->ChangeVertexFirstOnS1(),tolesp);
1163 ChFi3d_FilCommonPoint(lin->EndPointOnFirst(),lin->TransitionOnS1(),
1164 Standard_False,Data->ChangeVertexLastOnS1(),tolesp);
1165 ChFi3d_FilCommonPoint(lin->StartPointOnSecond(),lin->TransitionOnS2(),
1166 Standard_True, Data->ChangeVertexFirstOnS2(),tolesp);
1167 ChFi3d_FilCommonPoint(lin->EndPointOnSecond(),lin->TransitionOnS2(),
1168 Standard_False, Data->ChangeVertexLastOnS2(),tolesp);
1169}
1170
1171
1172
1173
1174
1175
1176
1177//=======================================================================
1178//function : PerformFirstSection
1179//purpose :
1180//=======================================================================
1181
1182Standard_Boolean ChFi3d_FilBuilder::PerformFirstSection
1183(const Handle(ChFiDS_Spine)& Spine,
1184 const Handle(ChFiDS_HElSpine)& HGuide,
1185 const Standard_Integer Choix,
1186 Handle(BRepAdaptor_HSurface)& S1,
1187 Handle(BRepAdaptor_HSurface)& S2,
1188 const Handle(Adaptor3d_TopolTool)& I1,
1189 const Handle(Adaptor3d_TopolTool)& I2,
1190 const Standard_Real Par,
1191 math_Vector& SolDep,
1192 TopAbs_State& Pos1,
1193 TopAbs_State& Pos2) const
1194{
1195 Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Spine);
1196 if(fsp.IsNull()) Standard_ConstructionError::Raise
81bba717 1197 ("PerformSurf : this is not the spine of a fillet");
7fd59977 1198 Standard_Real TolGuide = HGuide->Resolution(tolesp);
1199 if(fsp->IsConstant()){
1200 BRepBlend_ConstRad Func(S1,S2,HGuide);
1201 Func.Set(fsp->Radius(),Choix);
1202 Func.Set(myShape);
af99433e 1203 BRepBlend_Walking TheWalk(S1,S2,I1,I2,HGuide);
7fd59977 1204 return TheWalk.PerformFirstSection(Func,Par,SolDep,
1205 tolesp,TolGuide,Pos1,Pos2);
1206 }
1207 else {
1208 BRepBlend_EvolRad Func(S1,S2,HGuide,fsp->Law(HGuide));
1209 Func.Set(Choix);
1210 Func.Set(myShape);
af99433e 1211 BRepBlend_Walking TheWalk(S1,S2,I1,I2,HGuide);
7fd59977 1212 return TheWalk.PerformFirstSection(Func,Par,SolDep,
1213 tolesp,TolGuide,Pos1,Pos2);
1214 }
1215}
1216
1217//=======================================================================
1218//function : PerformSurf
1219//purpose :
1220//=======================================================================
1221
1222Standard_Boolean
1223ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData,
1224 const Handle(ChFiDS_HElSpine)& HGuide,
1225 const Handle(ChFiDS_Spine)& Spine,
1226 const Standard_Integer Choix,
1227 const Handle(BRepAdaptor_HSurface)& S1,
1228 const Handle(Adaptor3d_TopolTool)& I1,
1229 const Handle(BRepAdaptor_HSurface)& S2,
1230 const Handle(Adaptor3d_TopolTool)& I2,
1231 const Standard_Real MaxStep,
1232 const Standard_Real Fleche,
1233 const Standard_Real TolGuide,
1234 Standard_Real& First,
1235 Standard_Real& Last,
1236 const Standard_Boolean Inside,
1237 const Standard_Boolean Appro,
1238 const Standard_Boolean Forward,
1239 const Standard_Boolean RecOnS1,
1240 const Standard_Boolean RecOnS2,
1241 const math_Vector& Soldep,
dde68833 1242 Standard_Integer& intf,
1243 Standard_Integer& intl)
7fd59977 1244{
0797d9d3 1245#ifdef OCCT_DEBUG
7fd59977 1246 OSD_Chronometer ch;
1247#endif
1248 Handle(ChFiDS_SurfData) Data = SeqData(1);
1249 Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Spine);
1250 if(fsp.IsNull()) Standard_ConstructionError::Raise
81bba717 1251 ("PerformSurf : this is not the spine of a fillet");
7fd59977 1252 Standard_Boolean gd1,gd2,gf1,gf2, maybesingular;
1253 Handle(BRepBlend_Line) lin;
1254 TopAbs_Orientation Or = S1->ChangeSurface().Face().Orientation();
1255 Standard_Real PFirst = First;
1256 if(intf) First = fsp->FirstParameter(1);
1257 if(intl) Last = fsp->LastParameter(fsp->NbEdges());
1258 if(fsp->IsConstant()){
1259 BRepBlend_ConstRad Func(S1,S2,HGuide);
1260 BRepBlend_ConstRadInv FInv(S1,S2,HGuide);
1261 Func.Set(fsp->Radius(),Choix);
1262 FInv.Set(fsp->Radius(),Choix);
1263 Func.Set(myShape);
1264
0797d9d3 1265#ifdef OCCT_DEBUG
7fd59977 1266 ChFi3d_InitChron(ch); //init perf ComputeData
1267#endif
1268
1269 done = ComputeData(Data,HGuide,Spine,lin,S1,I1,S2,I2,Func,FInv,
1270 PFirst,MaxStep,Fleche,TolGuide,First,Last,
1271 Inside,Appro,Forward,Soldep,intf,intl,
1272 gd1,gd2,gf1,gf2,RecOnS1,RecOnS2);
1273
0797d9d3 1274#ifdef OCCT_DEBUG
7fd59977 1275 ChFi3d_ResultChron(ch , t_computedata);// result perf ComputeData
1276#endif
1277
81bba717 1278 if(!done) return Standard_False; // recovery is possible PMN 14/05/1998
7fd59977 1279
0797d9d3 1280#ifdef OCCT_DEBUG
7fd59977 1281 ChFi3d_InitChron(ch);// init perf CompleteData
1282#endif
1283
1284 done = CompleteData(Data,Func,lin,S1,S2,Or,gd1,gd2,gf1,gf2);
1285
0797d9d3 1286#ifdef OCCT_DEBUG
7fd59977 1287 ChFi3d_ResultChron(ch , t_completedata);// result perf CompleteData
1288#endif
1289
81bba717 1290 if(!done) Standard_Failure::Raise("PerformSurf : Failed approximation!");
7fd59977 1291 maybesingular = (Func.GetMinimalDistance()<=100*tolapp3d);
1292 }
1293 else {
1294 BRepBlend_EvolRad Func(S1, S2, HGuide, fsp->Law(HGuide));
1295 BRepBlend_EvolRadInv FInv(S1, S2, HGuide, fsp->Law(HGuide));
1296 Func.Set(Choix);
1297 FInv.Set(Choix);
1298 Func.Set(myShape);
1299
0797d9d3 1300#ifdef OCCT_DEBUG
7fd59977 1301 ChFi3d_InitChron(ch);// init perf ComputeData
1302#endif
1303
1304 done = ComputeData(Data,HGuide,Spine,lin,S1,I1,S2,I2,Func,FInv,
1305 PFirst,MaxStep,Fleche,TolGuide,First,Last,
1306 Inside,Appro,Forward,Soldep,intf,intl,
1307 gd1,gd2,gf1,gf2,RecOnS1,RecOnS2);
0797d9d3 1308#ifdef OCCT_DEBUG
7fd59977 1309 ChFi3d_ResultChron(ch , t_computedata); //result perf ComputeData
1310#endif
1311
1312 if(!done) return Standard_False;
1313
0797d9d3 1314#ifdef OCCT_DEBUG
7fd59977 1315 ChFi3d_InitChron(ch);// init perf CompleteData
1316#endif
1317
1318 done = CompleteData(Data,Func,lin,S1,S2,Or,gd1,gd2,gf1,gf2);
1319
0797d9d3 1320#ifdef OCCT_DEBUG
7fd59977 1321 ChFi3d_ResultChron(ch , t_completedata);// result perf CompleteData
1322#endif
1323
81bba717 1324 if(!done) Standard_Failure::Raise("PerformSurf : Failed approximation!");
7fd59977 1325 maybesingular = (Func.GetMinimalDistance()<=100*tolapp3d);
1326 }
1327 if (maybesingular) SplitSurf(SeqData, lin);
1328 return Standard_True;
1329}
1330
1331//=======================================================================
1332//function : PerformSurf
1333//purpose :
1334//=======================================================================
1335
1336void ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData,
1337 const Handle(ChFiDS_HElSpine)& HGuide,
1338 const Handle(ChFiDS_Spine)& Spine,
1339 const Standard_Integer Choix,
1340 const Handle(BRepAdaptor_HSurface)& HS1,
1341 const Handle(Adaptor3d_TopolTool)& I1,
1342 const Handle(BRepAdaptor_HCurve2d)& PC1,
1343 const Handle(BRepAdaptor_HSurface)& HSref1,
1344 const Handle(BRepAdaptor_HCurve2d)& PCref1,
1345 Standard_Boolean& Decroch1,
1346 const Handle(BRepAdaptor_HSurface)& HS2,
1347 const Handle(Adaptor3d_TopolTool)& I2,
1348 const TopAbs_Orientation Or2,
1349 const Standard_Real MaxStep,
1350 const Standard_Real Fleche,
1351 const Standard_Real TolGuide,
1352 Standard_Real& First,
1353 Standard_Real& Last,
1354 const Standard_Boolean Inside,
1355 const Standard_Boolean Appro,
1356 const Standard_Boolean Forward,
1357 const Standard_Boolean RecP,
1358 const Standard_Boolean RecS,
1359 const Standard_Boolean RecRst,
1360 const math_Vector& Soldep)
1361{
1362 Handle(ChFiDS_SurfData) Data = SeqData(1);
1363 Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Spine);
1364 if(fsp.IsNull()) Standard_ConstructionError::Raise
81bba717 1365 ("PerformSurf : this is not the spine of a fillet");
7fd59977 1366 Handle(BRepBlend_Line) lin;
1367 Standard_Real PFirst = First;
1368 Standard_Boolean maybesingular;
1369
1370 if(fsp->IsConstant()){
1371 BRepBlend_SurfRstConstRad func(HS2,HS1,PC1,HGuide);
1372 func.Set(HSref1,PCref1);
1373 Handle(Adaptor3d_HCurveOnSurface) HC = new Adaptor3d_HCurveOnSurface();
543a9964 1374 HC->ChangeCurve().Load(PC1, HS1);
7fd59977 1375 BRepBlend_SurfCurvConstRadInv finvc(HS2,HC,HGuide);
1376 BRepBlend_SurfPointConstRadInv finvp(HS2,HGuide);
1377 BRepBlend_ConstRadInv finv(HS2,HSref1,HGuide);
1378 finv.Set(Standard_False,PCref1);
1379
1380 Standard_Real rad = fsp->Radius();
1381 Standard_Integer petitchoix = 1;
1382 if(Or2 == TopAbs_REVERSED) petitchoix = 3;
1383 if(Choix%2 == 0) petitchoix++;
1384 finv.Set(rad,Choix);
1385 finvc.Set(rad,petitchoix);
1386 finvp.Set(rad,petitchoix);
1387 func.Set(rad,petitchoix);
1388 func.Set(myShape);
1389
1390 done = ComputeData(Data,HGuide,lin,HS2,I2,HS1,PC1,I1,Decroch1,
1391 func,finv,finvp,finvc,
1392 PFirst,MaxStep,Fleche,TolGuide,First,Last,
1393 Soldep,Inside,Appro,Forward,RecP,RecS,RecRst);
1394 if(!done) {
1395 Spine->SetErrorStatus(ChFiDS_WalkingFailure);
81bba717 1396 Standard_Failure::Raise("PerformSurf : Failed processing!");
7fd59977 1397 }
1398 TopAbs_Orientation Or = HS2->ChangeSurface().Face().Orientation();
1399 done = CompleteData(Data,func,lin,HS1,HS2,Or,1);
81bba717 1400 if(!done) Standard_Failure::Raise("PerformSurf : Failed approximation!");
7fd59977 1401 maybesingular = (func.GetMinimalDistance()<=100*tolapp3d);
1402 }
1403 else {
7fd59977 1404 BRepBlend_SurfRstEvolRad func(HS2,HS1,PC1,HGuide,fsp->Law(HGuide));
1405 func.Set(HSref1,PCref1);
1406 Handle(Adaptor3d_HCurveOnSurface) HC = new Adaptor3d_HCurveOnSurface();
543a9964 1407 HC->ChangeCurve().Load(PC1, HS1);
7fd59977 1408 BRepBlend_SurfCurvEvolRadInv finvc(HS2,HC,HGuide,fsp->Law(HGuide));
1409 BRepBlend_SurfPointEvolRadInv finvp(HS2,HGuide,fsp->Law(HGuide));
1410 BRepBlend_EvolRadInv finv(HS2,HSref1,HGuide,fsp->Law(HGuide));
1411 finv.Set(Standard_False,PCref1);
1412 Standard_Integer petitchoix = 1;
1413 if(Or2 == TopAbs_REVERSED) petitchoix = 3;
1414 if(Choix%2 == 0) petitchoix++;
1415 finv.Set(Choix);
1416 finvc.Set(petitchoix);
1417 finvp.Set(petitchoix);
1418 func.Set(petitchoix);
1419 func.Set(myShape);
7fd59977 1420 done = ComputeData(Data,HGuide,lin,HS2,I2,HS1,PC1,I1,Decroch1,
1421 func,finv,finvp,finvc,
1422 PFirst,MaxStep,Fleche,TolGuide,First,Last,
1423 Soldep,Inside,Appro,Forward,RecP,RecS,RecRst);
1424 if(!done) {
1425 Spine->SetErrorStatus(ChFiDS_WalkingFailure);
81bba717 1426 Standard_Failure::Raise("PerformSurf : Failed processing!");
7fd59977 1427 }
1428 TopAbs_Orientation Or = HS2->ChangeSurface().Face().Orientation();
1429 done = CompleteData(Data,func,lin,HS1,HS2,Or,1);
81bba717 1430 if(!done) Standard_Failure::Raise("PerformSurf : Failed approximation!");
7fd59977 1431 maybesingular = (func.GetMinimalDistance()<=100*tolapp3d);
1432 }
1433 if (maybesingular) SplitSurf(SeqData, lin);
1434}
1435
1436//=======================================================================
1437//function : PerformSurf
1438//purpose :
1439//=======================================================================
1440
1441void ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData,
1442 const Handle(ChFiDS_HElSpine)& HGuide,
1443 const Handle(ChFiDS_Spine)& Spine,
1444 const Standard_Integer Choix,
1445 const Handle(BRepAdaptor_HSurface)& HS1,
1446 const Handle(Adaptor3d_TopolTool)& I1,
1447 const TopAbs_Orientation Or1,
1448 const Handle(BRepAdaptor_HSurface)& HS2,
1449 const Handle(Adaptor3d_TopolTool)& I2,
1450 const Handle(BRepAdaptor_HCurve2d)& PC2,
1451 const Handle(BRepAdaptor_HSurface)& HSref2,
1452 const Handle(BRepAdaptor_HCurve2d)& PCref2,
1453 Standard_Boolean& Decroch2,
1454 const Standard_Real MaxStep,
1455 const Standard_Real Fleche,
1456 const Standard_Real TolGuide,
1457 Standard_Real& First,
1458 Standard_Real& Last,
1459 const Standard_Boolean Inside,
1460 const Standard_Boolean Appro,
1461 const Standard_Boolean Forward,
1462 const Standard_Boolean RecP,
1463 const Standard_Boolean RecS,
1464 const Standard_Boolean RecRst,
1465 const math_Vector& Soldep)
1466{
1467 Handle(ChFiDS_SurfData) Data = SeqData(1);;
1468 Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Spine);
1469 if(fsp.IsNull()) Standard_ConstructionError::Raise
81bba717 1470 ("PerformSurf : this is not the spine of a fillet");
7fd59977 1471 Handle(BRepBlend_Line) lin;
1472 Standard_Real PFirst = First;
1473 Standard_Boolean maybesingular;
1474
1475 if(fsp->IsConstant()){
1476 BRepBlend_SurfRstConstRad func(HS1,HS2,PC2,HGuide);
1477 func.Set(HSref2,PCref2);
1478 Handle(Adaptor3d_HCurveOnSurface) HC = new Adaptor3d_HCurveOnSurface();
543a9964 1479 HC->ChangeCurve().Load(PC2, HS2);
7fd59977 1480 BRepBlend_SurfCurvConstRadInv finvc(HS1,HC,HGuide);
1481 BRepBlend_SurfPointConstRadInv finvp(HS1,HGuide);
1482 BRepBlend_ConstRadInv finv(HS1,HSref2,HGuide);
1483 finv.Set(Standard_False,PCref2);
1484
1485 Standard_Real rad = fsp->Radius();
1486 Standard_Integer petitchoix = 1;
1487 if(Or1 == TopAbs_REVERSED) petitchoix = 3;
1488 if(Choix%2 == 0) petitchoix++;
1489 finv.Set(rad,Choix);
1490 finvc.Set(rad,petitchoix);
1491 finvp.Set(rad,petitchoix);
1492 func.Set(rad,petitchoix);
1493 func.Set(myShape);
1494
1495 done = ComputeData(Data,HGuide,lin,HS1,I1,HS2,PC2,I2,Decroch2,
1496 func,finv,finvp,finvc,
1497 PFirst,MaxStep,Fleche,TolGuide,First,Last,
1498 Soldep,Inside,Appro,Forward,RecP,RecS,RecRst);
1499 if(!done) {
1500 Spine->SetErrorStatus(ChFiDS_WalkingFailure);
81bba717 1501 Standard_Failure::Raise("PerformSurf : Failed processing!");
7fd59977 1502 }
1503 TopAbs_Orientation Or = HS1->ChangeSurface().Face().Orientation();
1504 done = CompleteData(Data,func,lin,HS1,HS2,Or,0);
81bba717 1505 if(!done) Standard_Failure::Raise("PerformSurf : Failed approximation!");
7fd59977 1506 maybesingular = (func.GetMinimalDistance()<=100*tolapp3d);
1507 }
1508 else {
1509 BRepBlend_SurfRstEvolRad func(HS1,HS2,PC2,HGuide,fsp->Law(HGuide));
1510 func.Set(HSref2,PCref2);
1511 Handle(Adaptor3d_HCurveOnSurface) HC = new Adaptor3d_HCurveOnSurface();
543a9964 1512 HC->ChangeCurve().Load(PC2, HS2);
7fd59977 1513 BRepBlend_SurfCurvEvolRadInv finvc(HS1,HC,HGuide,fsp->Law(HGuide));
1514 BRepBlend_SurfPointEvolRadInv finvp(HS1,HGuide,fsp->Law(HGuide));
1515 BRepBlend_EvolRadInv finv(HS1,HSref2,HGuide,fsp->Law(HGuide));
1516 finv.Set(Standard_False,PCref2);
1517 Standard_Integer petitchoix = 1;
1518 if(Or1 == TopAbs_REVERSED) petitchoix = 3;
1519 if(Choix%2 == 0) petitchoix++;
1520 finv.Set(Choix);
1521 finvc.Set(petitchoix);
1522 finvp.Set(petitchoix);
1523 func.Set(petitchoix);
1524 func.Set(myShape);
1525
1526 done = ComputeData(Data,HGuide,lin,HS1,I1,HS2,PC2,I2,Decroch2,
1527 func,finv,finvp,finvc,
1528 PFirst,MaxStep,Fleche,TolGuide,First,Last,
1529 Soldep,Inside,Appro,Forward,RecP,RecS,RecRst);
1530 if(!done) {
1531 Spine->SetErrorStatus(ChFiDS_WalkingFailure);
81bba717 1532 Standard_Failure::Raise("PerformSurf : Failed processing!");
7fd59977 1533 }
1534 TopAbs_Orientation Or = HS1->ChangeSurface().Face().Orientation();
1535 done = CompleteData(Data,func,lin,HS1,HS2,Or,0);
81bba717 1536 if(!done) Standard_Failure::Raise("PerformSurf : Failed approximation!");
7fd59977 1537 maybesingular = (func.GetMinimalDistance()<=100*tolapp3d);
1538 }
1539 if (maybesingular) SplitSurf(SeqData, lin);
1540}
1541
1542
1543
1544
1545
1546
1547//=======================================================================
1548//function : PerformSurf
1549//purpose :
1550//=======================================================================
1551
1552void ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData,
1553 const Handle(ChFiDS_HElSpine)& HGuide,
1554 const Handle(ChFiDS_Spine)& Spine,
1555 const Standard_Integer Choix,
1556 const Handle(BRepAdaptor_HSurface)& HS1,
1557 const Handle(Adaptor3d_TopolTool)& I1,
1558 const Handle(BRepAdaptor_HCurve2d)& PC1,
1559 const Handle(BRepAdaptor_HSurface)& HSref1,
1560 const Handle(BRepAdaptor_HCurve2d)& PCref1,
1561 Standard_Boolean& Decroch1,
1562 const TopAbs_Orientation Or1,
1563 const Handle(BRepAdaptor_HSurface)& HS2,
1564 const Handle(Adaptor3d_TopolTool)& I2,
1565 const Handle(BRepAdaptor_HCurve2d)& PC2,
1566 const Handle(BRepAdaptor_HSurface)& HSref2,
1567 const Handle(BRepAdaptor_HCurve2d)& PCref2,
1568 Standard_Boolean& Decroch2,
1569 const TopAbs_Orientation Or2,
1570 const Standard_Real MaxStep,
1571 const Standard_Real Fleche,
1572 const Standard_Real TolGuide,
1573 Standard_Real& First,
1574 Standard_Real& Last,
1575 const Standard_Boolean Inside,
1576 const Standard_Boolean Appro,
1577 const Standard_Boolean Forward,
1578 const Standard_Boolean RecP1,
1579 const Standard_Boolean RecRst1,
1580 const Standard_Boolean RecP2,
1581 const Standard_Boolean RecRst2,
1582 const math_Vector& Soldep)
1583{
1584 Handle(ChFiDS_SurfData) Data = SeqData(1);;
1585 Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Spine);
1586 if(fsp.IsNull()) Standard_ConstructionError::Raise
81bba717 1587 ("PerformSurf : this is not the spine of a fillet");
7fd59977 1588 Handle(BRepBlend_Line) lin;
1589 Standard_Real PFirst = First;
1590 Standard_Boolean maybesingular;
1591
1592 if(fsp->IsConstant()){
1593 BRepBlend_RstRstConstRad func(HS1, PC1, HS2, PC2, HGuide);
1594 func.Set(HSref1, PCref1, HSref2, PCref2);
1595 Handle(Adaptor3d_HCurveOnSurface) HC1 = new Adaptor3d_HCurveOnSurface();
543a9964 1596 HC1->ChangeCurve().Load(PC1, HS1);
7fd59977 1597 Handle(Adaptor3d_HCurveOnSurface) HC2 = new Adaptor3d_HCurveOnSurface();
543a9964 1598 HC2->ChangeCurve().Load(PC2, HS2);
7fd59977 1599 BRepBlend_SurfCurvConstRadInv finv1(HSref1, HC2, HGuide);
1600 BRepBlend_CurvPointRadInv finvp1(HGuide, HC2);
1601 BRepBlend_SurfCurvConstRadInv finv2(HSref2, HC1, HGuide);
1602 BRepBlend_CurvPointRadInv finvp2(HGuide, HC1);
1603
1604 finv1.Set(PCref1);
1605 finv2.Set(PCref2);
1606
1607 Standard_Integer ch1 = 1, ch2 = 2;
1608 Standard_Real rad = fsp->Radius();
1609 if(Or1 == TopAbs_REVERSED) ch1 = 3;
1610 if(Or2 == TopAbs_REVERSED) ch2 = 3;
1611
1612 finv1.Set(rad, ch1);
1613 finvp1.Set(Choix);
1614 finv2.Set(rad, ch2);
1615 finvp2.Set(Choix);
1616 func.Set(rad, Choix);
1617 func.Set(myShape);
1618
1619 done = ComputeData(Data, HGuide, lin, HS1, PC1, I1, Decroch1, HS2, PC2, I2, Decroch2,
1620 func, finv1, finvp1, finv2, finvp2,
1621 PFirst, MaxStep, Fleche, TolGuide, First, Last,
1622 Soldep, Inside, Appro, Forward, RecP1, RecRst1, RecP2, RecRst2);
1623 if(!done) {
1624 Spine->SetErrorStatus(ChFiDS_WalkingFailure);
81bba717 1625 Standard_Failure::Raise("PerformSurf : Failed processing!");
7fd59977 1626 }
1627 TopAbs_Orientation Or = HS1->ChangeSurface().Face().Orientation();
1628 done = CompleteData(Data, func, lin, HS1, HS2, Or);
81bba717 1629 if(!done) Standard_Failure::Raise("PerformSurf : Failed approximation!");
7fd59977 1630 maybesingular = (func.GetMinimalDistance()<=100*tolapp3d);
1631 }
1632 else {
1633 BRepBlend_RstRstEvolRad func(HS1,PC1, HS2, PC2, HGuide, fsp->Law(HGuide));
1634 func.Set(HSref1, PCref1, HSref2, PCref2);
1635 Handle(Adaptor3d_HCurveOnSurface) HC1 = new Adaptor3d_HCurveOnSurface();
543a9964 1636 HC1->ChangeCurve().Load(PC1, HS1);
7fd59977 1637 Handle(Adaptor3d_HCurveOnSurface) HC2 = new Adaptor3d_HCurveOnSurface();
543a9964 1638 HC2->ChangeCurve().Load(PC2, HS2);
7fd59977 1639
1640 BRepBlend_SurfCurvEvolRadInv finv1(HSref1, HC2, HGuide, fsp->Law(HGuide));
1641 BRepBlend_CurvPointRadInv finvp1(HGuide, HC2);
1642 BRepBlend_SurfCurvEvolRadInv finv2(HSref2, HC1, HGuide, fsp->Law(HGuide));
1643 BRepBlend_CurvPointRadInv finvp2(HGuide, HC1);
1644
1645 finv1.Set(PCref1);
1646 finv2.Set(PCref2);
1647
1648 Standard_Integer ch1 = 1, ch2 = 2;
1649
1650 if(Or1 == TopAbs_REVERSED) ch1 = 3;
1651 if(Or2 == TopAbs_REVERSED) ch2 = 3;
1652
1653
1654 finv1.Set(ch1);
1655 finvp1.Set(Choix);
1656 finv2.Set(ch2);
1657 finvp2.Set(Choix);
1658 func.Set(Choix);
1659 func.Set(myShape);
1660
1661 done = ComputeData(Data, HGuide, lin, HS1, PC1, I1, Decroch1, HS2, PC2,I2, Decroch2,
1662 func, finv1, finvp1, finv2, finvp2,
1663 PFirst, MaxStep, Fleche, TolGuide, First, Last,
1664 Soldep, Inside, Appro, Forward, RecP1, RecRst1, RecP2, RecRst2);
1665
1666 if(!done) {
1667 Spine->SetErrorStatus(ChFiDS_WalkingFailure);
81bba717 1668 Standard_Failure::Raise("PerformSurf : Failed processing!");
7fd59977 1669 }
1670 TopAbs_Orientation Or = HS1->ChangeSurface().Face().Orientation();
1671 done = CompleteData(Data, func, lin, HS1, HS2, Or);
81bba717 1672 if(!done) Standard_Failure::Raise("PerformSurf : Failed approximation!");
7fd59977 1673 maybesingular = (func.GetMinimalDistance()<=100*tolapp3d);
1674
1675
1676 }
1677 if (maybesingular) SplitSurf(SeqData, lin);
1678}
1679
1680
1681
1682
1683//=======================================================================
1684//function : SplitSurf
1685//purpose :
1686//=======================================================================
1687
1688void ChFi3d_FilBuilder::SplitSurf(ChFiDS_SequenceOfSurfData& SeqData,
1689 const Handle(BRepBlend_Line)& Line)
1690{
1691 Standard_Integer ii, Nbpnt=Line->NbPoints();
1692 if (Nbpnt <3) return;
1693 Standard_Real UFirst,ULast,VFirst,VLast;
1694 TopOpeBRepDS_DataStructure& DStr = myDS->ChangeDS();
1695 Standard_Integer ISurf;
1696 Handle(ChFiDS_SurfData) ref = SeqData(1);
1697 Blend_Point P;
1698
1699 ISurf= ref->Surf();
1700 Handle(Geom_Surface) Surf = DStr.Surface(ISurf).Surface();
1701 Surf->Bounds(UFirst,ULast,VFirst,VLast);
1702 Handle(Geom_Curve) Courbe1 = Surf->UIso(UFirst);
1703 Handle(Geom_Curve) Courbe2 = Surf->UIso(ULast);
1704 ChFi3d_SearchSing Fonc(Courbe1, Courbe2);
1705
1706 TColStd_SequenceOfReal LesVi;
1707 Standard_Real precedant, suivant, courant;
1708 Standard_Real a, b, c;
1709
81bba717 1710 // (1) Finds vi so that iso v=vi is punctual
7fd59977 1711 VFirst = Min( ref->InterferenceOnS1().FirstParameter(),
1712 ref->InterferenceOnS2().FirstParameter() );
1713 VLast = Max( ref->InterferenceOnS1().LastParameter(),
1714 ref->InterferenceOnS2().LastParameter() );
1715
81bba717 1716 // (1.1) Finds the first point inside
7fd59977 1717 for (ii=1; ii<=Nbpnt && Line->Point(ii).Parameter()<VFirst; ii++) {}
1718 if (ii==1) ii++;
1719 P = Line->Point(ii);
1720 b = P.Parameter();
1721 courant = P.PointOnS1().Distance(P.PointOnS2());
1722 P = Line->Point(ii-1);
1723 a = P.Parameter();
1724 precedant = P.PointOnS1().Distance(P.PointOnS2());
1725 ii ++;
1726
81bba717 1727 // (1.2) Find a minimum by "points"
7fd59977 1728 for ( ; ii<=Nbpnt && Line->Point(ii).Parameter()<=VLast; ii++) {
1729 for (;ii<=Nbpnt &&
1730 Line->Point(ii).Parameter()<VLast &&
1731 Line->Point(ii).Parameter()-b<Precision::PConfusion(); ii++) {}
1732
1733 const Blend_Point& pnt = Line->Point(ii);
1734 c = pnt.Parameter();
1735 suivant = pnt.PointOnS1().Distance(pnt.PointOnS2());
1736 if ( (courant < precedant) && (courant < suivant) ) {
81bba717 1737 // (1.3) Find the exact minimum
7fd59977 1738 math_FunctionRoot Resol(Fonc, (a+c)/2,
1739 tol2d,//Surf->VResolution(toleps),
1740 a, c,
1741 50);
1742 if (Resol.IsDone()) {
1743 Standard_Real Val, racine=Resol.Root();
1744
1745 Fonc.Value(Resol.Root(), Val);
1746 if (Val< tolapp3d) {
81bba717 1747 // the solution (avoiding the risks of confusion)
7fd59977 1748 if (LesVi.Length()==0) {
1749 if ( (racine > VFirst+tol2d) &&
1750 (racine < VLast -tol2d) ) {
1751 LesVi.Append(racine);
1752 }
1753 }
1754 else {
1755 if ( (racine > LesVi(LesVi.Length()) + tol2d) &&
1756 (racine < VLast-tol2d) ) {
1757 LesVi.Append(racine);
1758 }
1759 }
1760 }
1761 }
1762 else {
63c629aa 1763# if CHFI3D_DEB
81bba717 1764 cout << "Failed calculation of the minimum length" << endl;
7fd59977 1765# endif
1766 }
1767 }
81bba717 1768 // update if non duplication
7fd59977 1769 a = b;
1770 precedant = courant;
1771 b = c;
1772 courant = suivant;
1773 }
1774
81bba717 1775 // (2) Update of the sequence of SurfData
7fd59977 1776 if (LesVi.Length()>0) {
1777 TopOpeBRepDS_DataStructure& DStru = myDS->ChangeDS();
1778 Handle(ChFiDS_SurfData) SD;
1779 TopOpeBRepDS_Surface S;
1780 TopOpeBRepDS_Curve C1, C2;
1781 Standard_Real T, VertexTol;
1782 gp_Pnt P3d, P1, P2;
1783 ChFiDS_CommonPoint LePoint;
1784 for (ii=1 ; ii<=LesVi.Length(); ii++) {
1785
1786 T = LesVi(ii);
81bba717 1787 // (2.0) copy and insertion
7fd59977 1788 SD = new (ChFiDS_SurfData);
1789 SD->Copy(ref);
1790 SeqData.InsertBefore(ii, SD);
1791 S = DStru.Surface(ref->Surf());
1792 SD->ChangeSurf(DStru.AddSurface(S));
1793 C1 = DStru.Curve(SD->InterferenceOnS1().LineIndex());
1794 SD->ChangeInterferenceOnS1().SetLineIndex( DStru.AddCurve(C1));
1795 C2 = DStru.Curve(SD->InterferenceOnS2().LineIndex());
1796 SD->ChangeInterferenceOnS2().SetLineIndex(DStru.AddCurve(C2));
1797
81bba717 1798 // (2.1) Modification of common Point
7fd59977 1799 SD-> ChangeVertexLastOnS1().Reset();
1800 SD-> ChangeVertexLastOnS2().Reset();
1801 ref->ChangeVertexFirstOnS1().Reset();
1802 ref->ChangeVertexFirstOnS2().Reset();
1803 Courbe1->D0(T, P1);
1804 Courbe2->D0(T, P2);
1805 P3d.SetXYZ((P1.XYZ()+ P2.XYZ())/2);
1806 VertexTol = P1.Distance(P2);
1807 VertexTol += Max(C1.Tolerance(), C2.Tolerance());
1808
1809 SD->ChangeVertexLastOnS1().SetPoint(P3d);
1810 SD->ChangeVertexLastOnS2().SetPoint(P3d);
1811 ref->ChangeVertexFirstOnS1().SetPoint(P3d);
1812 ref->ChangeVertexFirstOnS2().SetPoint(P3d);
1813 SD->ChangeVertexLastOnS1().SetTolerance(VertexTol);
1814 SD->ChangeVertexLastOnS2().SetTolerance(VertexTol);
1815 ref->ChangeVertexFirstOnS1().SetTolerance(VertexTol);
1816 ref->ChangeVertexFirstOnS2().SetTolerance(VertexTol);
1817
81bba717 1818 // (2.2) Modification of interferences
7fd59977 1819 SD->ChangeInterferenceOnS1().SetLastParameter(T);
1820 SD->ChangeInterferenceOnS2().SetLastParameter(T);
1821 ref->ChangeInterferenceOnS1().SetFirstParameter(T);
1822 ref->ChangeInterferenceOnS2().SetFirstParameter(T);
1823
81bba717 1824 // Parameters on ElSpine
7fd59977 1825 SD->LastSpineParam(T);
1826 ref->FirstSpineParam(T);
1827 }
1828 }
1829}
1830
1831//=======================================================================
1832//function : ExtentOneCorner
1833//purpose :
1834//=======================================================================
1835
1836void ChFi3d_FilBuilder::ExtentOneCorner(const TopoDS_Vertex& V,
1837 const Handle(ChFiDS_Stripe)& S)
1838{
81bba717 1839 // review by using the data at end of fillets (point, radius, normal
1840 // to the faces and tangents of the guideline).
7fd59977 1841 Standard_Integer Sens = 0;
7fd59977 1842 Standard_Real Coeff = 0.5;
1843 Handle(ChFiDS_Spine) Spine = S->Spine();
1844 ChFi3d_IndexOfSurfData(V,S,Sens);
1845 Standard_Real dU = Spine->LastParameter(Spine->NbEdges());
1846 if (Spine->IsTangencyExtremity((Sens == 1)))
81bba717 1847 return; //No extension in the queue
7fd59977 1848
1849 if (Spine->Status((Sens == 1)) == ChFiDS_FreeBoundary) {
81bba717 1850 Coeff *= 2; // It is necessary to go to the end and to evaluate the length
7fd59977 1851 }
1852
1853 if (Sens == 1) {
1854 Spine->SetFirstParameter(-dU*Coeff);
1855 Spine->SetFirstTgt(0.);
1856 }
1857 else{
1858 Spine->SetLastParameter(dU*(1.+Coeff));
1859 Spine->SetLastTgt(dU);
1860 }
1861}
1862
1863//=======================================================================
1864//function : ExtentTwoCorner
1865//purpose :
1866//=======================================================================
1867
1868void ChFi3d_FilBuilder::ExtentTwoCorner(const TopoDS_Vertex& V,
1869 const ChFiDS_ListOfStripe& LS)
1870{
81bba717 1871 // Review by using the data at end of fillets (point, radius, normal
1872 // to faces and tangents to the guideline.
7fd59977 1873 Standard_Integer Sens;
1874 Standard_Real Coeff = 0.3, Eval=0.0, dU, rad;
7fd59977 1875 ChFiDS_ListIteratorOfListOfStripe itel(LS);
1876 Standard_Boolean FF = Standard_True;
1877 Handle(ChFiDS_Stripe) Stripe;
1878 Handle(ChFiDS_Spine) Spine;
1879
81bba717 1880 // A value of symetric extension is calculated
7fd59977 1881 for ( ; itel.More(); itel.Next()) {
1882 Stripe = itel.Value();
1883 Spine = Stripe->Spine();
1884 dU = Spine->LastParameter(Spine->NbEdges())*Coeff;
1885 Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Spine);
1886 if (fsp->IsConstant())
1887 rad = fsp->Radius();
1888 else
1889 {
1890 TopoDS_Edge E = ChFi3d_EdgeFromV1( V, itel.Value(), Sens);
1891 rad = MaxRad( fsp, E );
1892 /*
1893 IE = ChFi3d_IndexOfSurfData(V,itel.Value(),Sens);
1894 rad = MaxRad(fsp, IE);
1895 */
1896 }
1897 rad *= 1.5;
1898 if (rad > dU) dU = rad;
1899 if (dU > Eval) Eval = dU;
1900 }
1901
81bba717 1902 // One applies
7fd59977 1903 for (itel.Initialize(LS) ; itel.More(); itel.Next()) {
96a95605 1904 ChFi3d_IndexOfSurfData(V,itel.Value(),Sens);
7fd59977 1905 if (!FF && Stripe == itel.Value()) Sens = -Sens;
1906 Stripe = itel.Value();
1907 Spine = Stripe->Spine();
81bba717 1908 if (! Spine->IsTangencyExtremity((Sens == 1))) { //No extension on queue
7fd59977 1909 if (Sens == 1){
1910 Spine->SetFirstParameter(-Eval);
1911 Spine->SetFirstTgt(0.);
1912 }
1913 else{
1914 dU = Spine->LastParameter(Spine->NbEdges());
1915 Spine->SetLastParameter(dU+Eval);
1916 Spine->SetLastTgt(dU);
1917 }
1918 FF = Standard_False;
1919 }
1920 }
1921}
1922
1923
1924//=======================================================================
1925//function : ExtentThreeCorner
1926//purpose :
1927//=======================================================================
1928
1929void ChFi3d_FilBuilder::ExtentThreeCorner(const TopoDS_Vertex& V,
1930 const ChFiDS_ListOfStripe& LS)
1931{
81bba717 1932 // Review by using the data at end of fillets (point, radius, normal
1933 // to faces and tangents to the guideline.
7fd59977 1934 Standard_Integer Sens = 0;
7fd59977 1935 Standard_Real Coeff = 0.1;
1936 ChFiDS_ListOfStripe check;
1937// Standard_Boolean FF = Standard_True;
1938 for(ChFiDS_ListIteratorOfListOfStripe itel(LS); itel.More(); itel.Next()) {
1939 Handle(ChFiDS_Stripe) Stripe = itel.Value();
1940 ChFi3d_IndexOfSurfData(V,Stripe,Sens);
1941 for(ChFiDS_ListIteratorOfListOfStripe ich(check); ich.More(); ich.Next()){
1942 if(Stripe == ich.Value()){
1943 Sens = -Sens;
1944 break;
1945 }
1946 }
1947 Handle(ChFiDS_Spine) Spine = Stripe->Spine();
81bba717 1948 if (Spine->IsTangencyExtremity((Sens == 1))) return; //No extension on queue
7fd59977 1949 Standard_Real dU = Spine->LastParameter(Spine->NbEdges());
1950 if (Sens == 1){
1951 Spine->SetFirstParameter(-dU*Coeff);
1952 Spine->SetFirstTgt(0.);
1953 }
1954 else{
1955 Spine->SetLastParameter(dU*(1.+Coeff));
1956 Spine->SetLastTgt(dU);
1957 }
1958 check.Append(Stripe);
1959 }
1960}
1961
1962
1963//=======================================================================
1964//function : SetRegul
1965//purpose :
1966//=======================================================================
1967
1968void ChFi3d_FilBuilder::SetRegul()
1969
1970{
1971 ChFiDS_ListIteratorOfRegularities it;
1972 TopTools_ListIteratorOfListOfShape itc;
1973 TopTools_ListIteratorOfListOfShape its1;
1974 TopTools_ListIteratorOfListOfShape its2;
1975 BRep_Builder B;
1976 for (it.Initialize(myRegul); it.More(); it.Next()){
1977 const ChFiDS_Regul& reg = it.Value();
1978 itc.Initialize(myCoup->NewEdges(reg.Curve()));
1979 if(itc.More()){
1980 TopoDS_Edge E = TopoDS::Edge(itc.Value());
1981 if(reg.IsSurface1()) its1.Initialize(myCoup->NewFaces(reg.S1()));
1982 else its1.Initialize(myCoup->Merged(myDS->Shape(reg.S1()),TopAbs_IN));
1983 if(reg.IsSurface2()) its2.Initialize(myCoup->NewFaces(reg.S2()));
1984 else its2.Initialize(myCoup->Merged(myDS->Shape(reg.S2()),TopAbs_IN));
1985 if(its1.More() && its2.More()){
1986 TopoDS_Face F1 = TopoDS::Face(its1.Value());
1987 TopoDS_Face F2 = TopoDS::Face(its2.Value());
1988 GeomAbs_Shape cont = ChFi3d_evalconti(E,F1,F2);
1989 B.Continuity(E,F1,F2,cont);
1990 }
1991 }
1992 }
1993}