1 // Created on: 1995-04-26
2 // Created by: Flore Lantheaume
3 // Copyright (c) 1995-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
6 // This file is part of Open CASCADE Technology software library.
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.
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
18 #include <Adaptor3d_TopolTool.hxx>
19 #include <Blend_Point.hxx>
20 #include <BlendFunc_SectionShape.hxx>
21 #include <BRepAdaptor_Curve2d.hxx>
22 #include <BRepAdaptor_HCurve2d.hxx>
23 #include <BRepAdaptor_HSurface.hxx>
24 #include <BRepAdaptor_Surface.hxx>
25 #include <BRepBlend_Chamfer.hxx>
26 #include <BRepBlend_ChamfInv.hxx>
27 #include <BRepBlend_ChAsym.hxx>
28 #include <BRepBlend_ChAsymInv.hxx>
29 #include <BRepBlend_Line.hxx>
30 #include <BRepBlend_Walking.hxx>
31 #include <BRepTools.hxx>
33 #include <ChFi3d_Builder_0.hxx>
34 #include <ChFi3d_ChBuilder.hxx>
35 #include <ChFiDS_ChamfSpine.hxx>
36 #include <ChFiDS_CircSection.hxx>
37 #include <ChFiDS_HData.hxx>
38 #include <ChFiDS_HElSpine.hxx>
39 #include <ChFiDS_ListIteratorOfListOfStripe.hxx>
40 #include <ChFiDS_ListIteratorOfRegularities.hxx>
41 #include <ChFiDS_ListOfStripe.hxx>
42 #include <ChFiDS_Regul.hxx>
43 #include <ChFiDS_SecHArray1.hxx>
44 #include <ChFiDS_Spine.hxx>
45 #include <ChFiDS_Stripe.hxx>
46 #include <ChFiDS_SurfData.hxx>
48 #include <Extrema_GenLocateExtPS.hxx>
49 #include <GeomAdaptor_HCurve.hxx>
50 #include <Standard_ConstructionError.hxx>
51 #include <Standard_DomainError.hxx>
52 #include <Standard_NotImplemented.hxx>
54 #include <TopoDS_Edge.hxx>
55 #include <TopoDS_Face.hxx>
56 #include <TopoDS_Shape.hxx>
57 #include <TopoDS_Vertex.hxx>
58 #include <TopOpeBRepBuild_HBuilder.hxx>
59 #include <TopOpeBRepDS_HDataStructure.hxx>
60 #include <TopTools_ListIteratorOfListOfShape.hxx>
63 extern Standard_Boolean ChFi3d_GettraceCHRON();
66 //=======================================================================
67 //function : SearchCommonFaces
68 //purpose : search the 2 common faces <F1> and <F2> of the edge <E>
69 // uses the EFMap and take the 2 first good faces
70 //=======================================================================
72 void SearchCommonFaces(const ChFiDS_Map& EFMap,
78 TopTools_ListIteratorOfListOfShape It;
82 for ( It.Initialize(EFMap(E)); It.More(); It.Next() ) {
83 Fc = TopoDS::Face(It.Value());
86 else if ( !Fc.IsSame(F1) ) {
92 if (!F1.IsNull() && F2.IsNull() && BRepTools::IsReallyClosed( E, F1 ))
96 //=======================================================================
97 //function : ExtentSpinesOnCommonFace
98 //purpose : Extend spines of two chamfers by distance dis1,dis2
99 // on their common face
100 // Two guide lines Spine1 and Spine2 cross in V
101 // isfirst(i) = False if Spine(i) is oriented to V (i = 1,2)
102 //=======================================================================
104 void ExtentSpineOnCommonFace(Handle(ChFiDS_Spine)& Spine1,
105 Handle(ChFiDS_Spine)& Spine2,
106 const TopoDS_Vertex& V,
107 const Standard_Real dis1,
108 const Standard_Real dis2,
109 const Standard_Boolean isfirst1,
110 const Standard_Boolean isfirst2)
112 Standard_Real tolesp = 1.e-7;
114 // alpha, the opening angle between two
115 // tangents of two guidelines in V is found
116 Standard_Real tga1,tga2;
117 Standard_Real d1plus = 0., d2plus = 0.;
121 Spine1->D1(Spine1->Absc(V),tmp,tg1);
122 Spine2->D1(Spine2->Absc(V),tmp,tg2);
130 Standard_Real cosalpha,sinalpha;
131 cosalpha = tg1.Dot(tg2);
132 sinalpha = sqrt(1-cosalpha*cosalpha);
136 temp = cosalpha+dis2/dis1;
137 if( Abs(temp) > tolesp ){
138 tga1 = sinalpha/temp;
141 temp = cosalpha+dis1/dis2;
142 if( Abs(temp) > tolesp ){
143 tga2 = sinalpha/temp;
147 //extension by the calculated distance
151 Spine1->SetFirstParameter(-d1plus);
152 Spine1->SetFirstTgt(0.);
155 Standard_Real param = Spine1->LastParameter(Spine1->NbEdges());
156 Spine1->SetLastParameter(d1plus+param);
157 Spine1->SetLastTgt(param);
163 Spine2->SetFirstParameter(-d2plus);
164 Spine2->SetFirstTgt(0.);
167 Standard_Real param = Spine2->LastParameter(Spine2->NbEdges());
168 Spine2->SetLastParameter(d2plus+param);
169 Spine2->SetLastTgt(param);
174 //=======================================================================
175 //function : ChFi3d_ChBuilder
177 //=======================================================================
179 ChFi3d_ChBuilder::ChFi3d_ChBuilder(const TopoDS_Shape& S,
180 const Standard_Real Ta) :
181 ChFi3d_Builder(S, Ta)
186 //=======================================================================
188 //purpose : create a new stripe with a spine containing the edge <E>
189 // add on the spine the tangential edges to <E>
190 //=======================================================================
192 void ChFi3d_ChBuilder::Add(const TopoDS_Edge& E)
195 if(!Contains(E) && myEFMap.Contains(E)){
196 Handle(ChFiDS_Stripe) Stripe = new ChFiDS_Stripe();
197 Handle(ChFiDS_Spine)& Sp = Stripe->ChangeSpine();
198 Sp = new ChFiDS_ChamfSpine(tolesp);
199 Handle(ChFiDS_ChamfSpine) Spine = Handle(ChFiDS_ChamfSpine)::DownCast(Sp);
201 TopoDS_Edge E_wnt = E;
202 E_wnt.Orientation(TopAbs_FORWARD);
203 Spine->SetEdges(E_wnt);
204 if(PerformElement(Spine)){
205 PerformExtremity(Spine);
207 myListStripe.Append(Stripe);
213 //=======================================================================
215 //purpose : create a new stripe with a ChamfSpine containing the edge <E>
216 // with the distance <Dis> on the face <F>
217 // . Add the tangential edges continuous to E in the spine
219 //=======================================================================
221 void ChFi3d_ChBuilder::Add(const Standard_Real Dis,
222 const TopoDS_Edge& E,
223 const TopoDS_Face& F)
225 if (!Contains(E) && myEFMap.Contains(E)) {
227 // Take the 2 common faces of the egde <E>
229 SearchCommonFaces(myEFMap,E,F1,F2);
231 if (! F1.IsSame(F) && F2.IsSame(F) ) {
237 TopoDS_Edge E_wnt = E;
238 E_wnt.Orientation(TopAbs_FORWARD);
239 BRepAdaptor_Surface Sb1,Sb2;
242 TopAbs_Orientation Or1,Or2;
243 ChFi3d::ConcaveSide(Sb1,Sb2,E_wnt,Or1,Or2);
244 Handle(ChFiDS_Stripe) Stripe = new ChFiDS_Stripe();
245 Handle(ChFiDS_Spine)& Sp = Stripe->ChangeSpine();
246 Sp = new ChFiDS_ChamfSpine(tolesp);
247 Handle(ChFiDS_ChamfSpine)
248 Spine = Handle(ChFiDS_ChamfSpine)::DownCast(Sp);
250 Spine->SetEdges(E_wnt);
251 if(PerformElement(Spine)){
253 myListStripe.Append(Stripe);
257 PerformExtremity(Spine);
264 //=======================================================================
266 //purpose : set the distances <Dis>of the contour of
268 //=======================================================================
270 void ChFi3d_ChBuilder::SetDist(const Standard_Real Dis,
271 const Standard_Integer IC,
272 const TopoDS_Face& F)
275 if(IC <= NbElements()) {
276 Handle(ChFiDS_ChamfSpine) csp = Handle(ChFiDS_ChamfSpine)::DownCast(Value(IC));
278 // Search the first edge which has a common face equal to F
279 TopoDS_Face F1,F2,FirstF1,FirstF2;
280 //TopAbs_Orientation Or1,Or2;
281 //Standard_Integer Choix, ChoixConge;
282 BRepAdaptor_Surface Sb1,Sb2;
283 Standard_Integer i = 1;
284 Standard_Boolean Found = Standard_False;
285 while ( (i <= csp->NbEdges()) && (!Found) ) {
286 SearchCommonFaces(myEFMap,csp->Edges(i),F1,F2);
291 Found = ( F1.IsSame(F) || F2.IsSame(F) );
296 if ( F2.IsSame(F) ) {
304 throw Standard_DomainError("the face is not common to any of edges of the contour");
310 //=======================================================================
313 //=======================================================================
315 void ChFi3d_ChBuilder::GetDist(const Standard_Integer IC,
316 Standard_Real& Dis) const
318 Handle(ChFiDS_ChamfSpine) chsp = Handle(ChFiDS_ChamfSpine)::DownCast(Value(IC));
324 //=======================================================================
326 //purpose : create a new stripe with a ChAsymSpine containing the edge <E>
327 // with the distance <Dis> and the angle Angle on the face <F>
328 // . Add the tangential edges continuous to E in the spine
330 //=======================================================================
332 void ChFi3d_ChBuilder::Add(const Standard_Real Dis1,
333 const Standard_Real Dis2,
334 const TopoDS_Edge& E,
335 const TopoDS_Face& F)
337 if (!Contains(E) && myEFMap.Contains(E)) {
339 // Take the 2 common faces of the egde <E>
341 SearchCommonFaces(myEFMap,E,F1,F2);
343 if (! F1.IsSame(F) && F2.IsSame(F) ) {
349 TopoDS_Edge E_wnt = E;
350 E_wnt.Orientation(TopAbs_FORWARD);
351 BRepAdaptor_Surface Sb1,Sb2;
354 TopAbs_Orientation Or1,Or2;
355 Standard_Integer Choix = ChFi3d::ConcaveSide(Sb1,Sb2,E_wnt,Or1,Or2);
357 Handle(ChFiDS_Stripe) Stripe = new ChFiDS_Stripe();
358 Handle(ChFiDS_Spine)& Sp = Stripe->ChangeSpine();
359 Sp = new ChFiDS_ChamfSpine(tolesp);
360 Handle(ChFiDS_ChamfSpine)
361 Spine = Handle(ChFiDS_ChamfSpine)::DownCast(Sp);
363 Spine->SetEdges(E_wnt);
364 if(PerformElement(Spine)){
366 myListStripe.Append(Stripe);
368 Standard_Integer ChoixConge;
369 SearchCommonFaces(myEFMap,Spine->Edges(1),F1,F2);
372 ChoixConge = ChFi3d::ConcaveSide(Sb1,Sb2,
377 // compare the 2 computed choices to know how to set the
378 // distances of the Spine according to the choice done
379 // on the added edge <e>
380 if ( ChoixConge%2 != Choix%2 )
381 Spine->SetDists(Dis2, Dis1);
382 else Spine->SetDists(Dis1, Dis2);
384 PerformExtremity(Spine);
391 //=======================================================================
392 //function : SetDists
393 //purpose : set the distances <Dis1> and <Dis2> of the contour of
395 //=======================================================================
397 void ChFi3d_ChBuilder::SetDists(const Standard_Real Dis1,
398 const Standard_Real Dis2,
399 const Standard_Integer IC,
400 const TopoDS_Face& F)
403 if(IC <= NbElements()) {
404 Handle(ChFiDS_ChamfSpine) csp = Handle(ChFiDS_ChamfSpine)::DownCast(Value(IC));
406 // Search the first edge which has a common face equal to F
407 TopoDS_Face F1,F2,FirstF1,FirstF2;
408 TopAbs_Orientation Or1,Or2;
409 Standard_Integer Choix, ChoixConge;
410 BRepAdaptor_Surface Sb1,Sb2;
411 Standard_Integer i = 1;
412 Standard_Boolean Found = Standard_False;
413 while ( (i <= csp->NbEdges()) && (!Found) ) {
414 SearchCommonFaces(myEFMap,csp->Edges(i),F1,F2);
419 Found = ( F1.IsSame(F) || F2.IsSame(F) );
424 if ( F2.IsSame(F) ) {
430 Choix = ChFi3d::ConcaveSide(Sb1,Sb2,
433 Sb1.Initialize(FirstF1);
434 Sb2.Initialize(FirstF2);
435 ChoixConge = ChFi3d::ConcaveSide(Sb1,Sb2,
438 if ( ChoixConge%2 != Choix%2 )
439 csp->SetDists(Dis2,Dis1);
440 else csp->SetDists(Dis1,Dis2);
443 throw Standard_DomainError("the face is not common to any of edges of the contour");
449 //=======================================================================
452 //=======================================================================
454 void ChFi3d_ChBuilder::Dists(const Standard_Integer IC,
456 Standard_Real& dis2) const
458 Handle(ChFiDS_ChamfSpine) chsp = Handle(ChFiDS_ChamfSpine)::DownCast(Value(IC));
459 Standard_Real temp1, temp2;
460 chsp->Dists(temp1,temp2);
466 //=======================================================================
468 //purpose : create a new stripe with a ChAsymSpine containing the edge <E>
469 // with the distance <Dis> and the angle Angle on the face <F>
470 // . Add the tangential edges continuous to E in the spine
472 //=======================================================================
474 void ChFi3d_ChBuilder::AddDA(const Standard_Real Dis1,
475 const Standard_Real Angle,
476 const TopoDS_Edge& E,
477 const TopoDS_Face& F)
479 if (!Contains(E) && myEFMap.Contains(E)) {
481 // Take the 2 common faces of the egde <E>
483 SearchCommonFaces(myEFMap,E,F1,F2);
485 if (! F1.IsSame(F) && F2.IsSame(F) ) {
491 TopoDS_Edge E_wnt = E;
492 E_wnt.Orientation(TopAbs_FORWARD);
493 BRepAdaptor_Surface Sb1,Sb2;
496 TopAbs_Orientation Or1,Or2;
497 Standard_Integer Choix = ChFi3d::ConcaveSide(Sb1,Sb2,E_wnt,Or1,Or2);
499 Handle(ChFiDS_Stripe) Stripe = new ChFiDS_Stripe();
500 Handle(ChFiDS_Spine)& Sp = Stripe->ChangeSpine();
501 Sp = new ChFiDS_ChamfSpine(tolesp);
502 Handle(ChFiDS_ChamfSpine)
503 Spine = Handle(ChFiDS_ChamfSpine)::DownCast(Sp);
505 Spine->SetEdges(E_wnt);
506 if(PerformElement(Spine)){
508 myListStripe.Append(Stripe);
510 Standard_Integer ChoixConge;
511 SearchCommonFaces(myEFMap,Spine->Edges(1),F1,F2);
514 ChoixConge = ChFi3d::ConcaveSide(Sb1,Sb2,
518 // compare the 2 computed choices to know how to set the
519 // distances of the Spine according to the choice done
520 // on the added edge <e>
521 if ( ChoixConge%2 != Choix%2 ) {
522 Spine->SetDistAngle(Dis1, Angle, Standard_False);
525 Spine->SetDistAngle(Dis1, Angle, Standard_True);
528 PerformExtremity(Spine);
535 //=======================================================================
536 //function : SetDistAngle
537 //purpose : set the distances <Dis> and <Angle> of the contour of
539 //=======================================================================
541 void ChFi3d_ChBuilder::SetDistAngle(const Standard_Real Dis,
542 const Standard_Real Angle,
543 const Standard_Integer IC,
544 const TopoDS_Face& F)
547 if(IC <= NbElements()) {
548 Handle(ChFiDS_ChamfSpine) csp = Handle(ChFiDS_ChamfSpine)::DownCast(Value(IC));
550 // Search the first edge which has a common face equal to F
551 TopoDS_Face F1,F2,FirstF1,FirstF2;
552 TopAbs_Orientation Or1,Or2;
553 Standard_Integer Choix, ChoixConge;
554 BRepAdaptor_Surface Sb1,Sb2;
555 Standard_Integer i = 1;
556 Standard_Boolean Found = Standard_False;
557 // Standard_Boolean DisOnF1 = Standard_True;
559 while ( (i <= csp->NbEdges()) && (!Found) ) {
560 SearchCommonFaces(myEFMap,csp->Edges(i),F1,F2);
565 Found = ( F1.IsSame(F) || F2.IsSame(F) );
570 if ( F2.IsSame(F) ) {
576 Choix = ChFi3d::ConcaveSide(Sb1,Sb2,
579 Sb1.Initialize(FirstF1);
580 Sb2.Initialize(FirstF2);
581 ChoixConge = ChFi3d::ConcaveSide(Sb1,Sb2,
584 if ( ChoixConge%2 != Choix%2 ) {
585 csp->SetDistAngle(Dis, Angle, Standard_False);
588 csp->SetDistAngle(Dis, Angle, Standard_True);
592 throw Standard_DomainError("the face is not common to any edges of the contour");
598 //=======================================================================
599 //function : GetDistAngle
601 //=======================================================================
603 void ChFi3d_ChBuilder::GetDistAngle(const Standard_Integer IC,
605 Standard_Real& Angle,
606 Standard_Boolean& DisOnFace1) const
608 Handle(ChFiDS_ChamfSpine) chsp = Handle(ChFiDS_ChamfSpine)::DownCast(Value(IC));
610 chsp->GetDistAngle(Dis, Angle, DisOnFace1);
613 //=======================================================================
614 //function : IsChamfer
616 //=======================================================================
617 ChFiDS_ChamfMethod ChFi3d_ChBuilder::IsChamfer(const Standard_Integer IC) const
619 Handle(ChFiDS_ChamfSpine) chsp = Handle(ChFiDS_ChamfSpine)::DownCast(Value(IC));
621 ChFiDS_ChamfMethod ret = chsp->IsChamfer();
627 //=======================================================================
628 //function : ResetContour
630 //=======================================================================
632 void ChFi3d_ChBuilder::ResetContour(const Standard_Integer IC)
634 if(IC <= NbElements()) {
635 Handle(ChFiDS_ChamfSpine) chsp = Handle(ChFiDS_ChamfSpine)::DownCast(Value(IC));
636 chsp->Reset(Standard_True);
640 //--------------------------------AJOUT----------------------------------
641 //=======================================================================
642 //function : Simulate
644 //=======================================================================
646 void ChFi3d_ChBuilder::Simulate (const Standard_Integer IC)
649 if(ChFi3d_GettraceCHRON()){
650 simul.Reset();elspine.Reset();chemine.Reset();
654 ChFiDS_ListIteratorOfListOfStripe itel;
655 Standard_Integer i = 1;
656 for (itel.Initialize(myListStripe);itel.More(); itel.Next(), i++) {
658 PerformSetOfSurf(itel.Value(), Standard_True);
663 if(ChFi3d_GettraceCHRON()){
665 cout<<"Total simulation time : ";
667 cout<<"Spine construction time : ";
669 cout<<"and progression time : ";
675 //---------------------------AJOUT---------------------------------------
676 //=======================================================================
679 //=======================================================================
681 Standard_Integer ChFi3d_ChBuilder::NbSurf (const Standard_Integer IC) const
683 ChFiDS_ListIteratorOfListOfStripe itel;
684 Standard_Integer i = 1;
685 for (itel.Initialize(myListStripe);itel.More(); itel.Next(), i++) {
687 return itel.Value()->SetOfSurfData()->Length();
694 //--------------------------AJOUT---------------------------------------
695 //=======================================================================
698 //=======================================================================
700 Handle(ChFiDS_SecHArray1) ChFi3d_ChBuilder::Sect (const Standard_Integer IC,
701 const Standard_Integer IS) const
703 ChFiDS_ListIteratorOfListOfStripe itel;
704 Standard_Integer i = 1;
705 Handle(ChFiDS_SecHArray1) res;
706 for (itel.Initialize(myListStripe);itel.More(); itel.Next(), i++) {
708 Handle(Standard_Transient) bid = itel.Value()->SetOfSurfData()->Value(IS)->Simul();
709 res = Handle(ChFiDS_SecHArray1)::DownCast(bid);
713 return Handle(ChFiDS_SecHArray1)();
717 //-------------------MODIFS---------------------------------------------
718 //=======================================================================
719 //function : SimulKPart
720 //purpose : Stores simulating sections in simul
721 //=======================================================================
723 void ChFi3d_ChBuilder::SimulKPart(const Handle(ChFiDS_SurfData)& SD ) const
725 TopOpeBRepDS_DataStructure& DStr = myDS->ChangeDS();
726 Handle(Geom_Surface) S = DStr.Surface(SD->Surf()).Surface();
727 gp_Pnt2d p1f = SD->InterferenceOnS1().PCurveOnSurf()->
728 Value(SD->InterferenceOnS1().FirstParameter());
729 gp_Pnt2d p1l = SD->InterferenceOnS1().PCurveOnSurf()->
730 Value(SD->InterferenceOnS1().LastParameter());
731 gp_Pnt2d p2f = SD->InterferenceOnS2().PCurveOnSurf()->
732 Value(SD->InterferenceOnS2().FirstParameter());
733 gp_Pnt2d p2l = SD->InterferenceOnS2().PCurveOnSurf()->
734 Value(SD->InterferenceOnS2().LastParameter());
735 GeomAdaptor_Surface AS(S);
736 Handle(ChFiDS_SecHArray1) sec;
737 Standard_Real u1,v1,u2,v2;
738 GeomAbs_SurfaceType typ = AS.GetType();
744 u1 = Max(p1f.X(),p2f.X());
745 u2 = Min(p1l.X(),p2l.X());
746 sec = new ChFiDS_SecHArray1(1,2);
747 gp_Pln Pl = AS.Plane();
748 ChFiDS_CircSection& sec1 = sec->ChangeValue(1);
749 ChFiDS_CircSection& sec2 = sec->ChangeValue(2);
750 sec1.Set(ElSLib::PlaneUIso(Pl.Position(),u1),v1,v2);
751 sec2.Set(ElSLib::PlaneUIso(Pl.Position(),u2),v1,v2);
758 u1 = Max(p1f.X(),p2f.X());
759 u2 = Min(p1l.X(),p2l.X());
760 Standard_Real ang = (u2-u1);
761 gp_Cone Co = AS.Cone();
762 Standard_Real rad = Co.RefRadius(), sang = Co.SemiAngle();
763 Standard_Integer n = (Standard_Integer) (36.*ang/M_PI + 1);
765 sec = new ChFiDS_SecHArray1(1, n);
766 for (Standard_Integer i = 1; i <= n; i++) {
767 ChFiDS_CircSection& isec = sec->ChangeValue(i);
768 Standard_Real u = u1 + (i - 1)*(u2 - u1)/(n-1);
769 isec.Set(ElSLib::ConeUIso(Co.Position(), rad, sang, u), v1, v2);
779 //------------------------MODIFS---------------------------------------
780 //=======================================================================
781 //function : SimulSurf
783 //=======================================================================
786 ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
787 const Handle(ChFiDS_HElSpine)& HGuide,
788 const Handle(ChFiDS_Spine)& Spine,
789 const Standard_Integer Choix,
790 const Handle(BRepAdaptor_HSurface)& S1,
791 const Handle(Adaptor3d_TopolTool)& I1,
792 const Handle(BRepAdaptor_HSurface)& S2,
793 const Handle(Adaptor3d_TopolTool)& I2,
794 const Standard_Real TolGuide,
795 Standard_Real& First,
797 const Standard_Boolean Inside,
798 const Standard_Boolean Appro,
799 const Standard_Boolean Forward,
800 const Standard_Boolean RecOnS1,
801 const Standard_Boolean RecOnS2,
802 const math_Vector& Soldep,
803 Standard_Integer& intf,
804 Standard_Integer& intl)
807 Handle(ChFiDS_ChamfSpine)
808 chsp = Handle(ChFiDS_ChamfSpine)::DownCast(Spine);
811 throw Standard_ConstructionError("SimulSurf : this is not the spine of a chamfer");
814 Standard_Real radius;
815 // Flexible parameters!
816 Standard_Real la = HGuide->LastParameter(), fi = HGuide->FirstParameter();
817 Standard_Real longueur = la - fi;
818 Standard_Real MaxStep = longueur * 0.05;
819 Standard_Real radiusspine = 0, locfleche, w;
822 // As ElSpine is parameterized by a curvilinear quasi-abscissa,
823 // the min radius is estimated as 1/D2 max;
824 //for(Standard_Integer i = 0; i <= 20; i++){
826 for( i = 0; i <= 20; i++){
828 HGuide->D2(w,Pbid,d1,d2);
829 Standard_Real temp = d2.SquareMagnitude();
830 if(temp>radiusspine) radiusspine = temp;
833 Handle(BRepBlend_Line) lin;
834 Standard_Real PFirst = First;
835 if(intf) First = chsp->FirstParameter(1);
836 if(intl) Last = chsp->LastParameter(chsp->NbEdges());
840 if (chsp->IsChamfer() == ChFiDS_Sym) {
843 radius = Max(dis, radiusspine);
844 locfleche = radius*1.e-2; //graphic criterion
846 BRepBlend_Chamfer Func(S1,S2,HGuide);
847 BRepBlend_ChamfInv FInv(S1,S2,HGuide);
848 Func.Set(dis, dis, Choix);
849 FInv.Set(dis, dis, Choix);
851 done = SimulData(Data,HGuide,lin,S1,I1,S2,I2,
852 Func,FInv,PFirst,MaxStep,locfleche,
853 TolGuide,First,Last,Inside,Appro,Forward,
854 Soldep,4,RecOnS1,RecOnS2);
856 if ( !done ) return Standard_False;
857 Handle(ChFiDS_SecHArray1) sec;
858 gp_Pnt2d pf1,pl1,pf2,pl2;
860 Standard_Integer nbp = lin->NbPoints();
861 sec = new ChFiDS_SecHArray1(1,nbp);
862 for( i = 1; i <= nbp; i++ ){
863 ChFiDS_CircSection& isec = sec->ChangeValue(i);
864 Standard_Real u1,v1,u2,v2,ww,p1,p2;
866 const Blend_Point& p = lin->Point(i);
867 p.ParametersOnS1(u1,v1);
868 p.ParametersOnS2(u2,v2);
870 Func.Section(ww,u1,v1,u2,v2,p1,p2,line);
871 isec.Set(line,p1,p2);
872 if(i == 1) {pf1.SetCoord(u1,v1); pf2.SetCoord(u2,v2);}
873 if(i == nbp) {pl1.SetCoord(u1,v1); pl2.SetCoord(u2,v2);}
877 Data->Set2dPoints(pf1,pl1,pf2,pl2);
878 ChFi3d_FilCommonPoint(lin->StartPointOnFirst(),lin->TransitionOnS1(),
879 Standard_True, Data->ChangeVertexFirstOnS1(),tolesp);
880 ChFi3d_FilCommonPoint(lin->EndPointOnFirst(),lin->TransitionOnS1(),
881 Standard_False,Data->ChangeVertexLastOnS1(),tolesp);
882 ChFi3d_FilCommonPoint(lin->StartPointOnSecond(),lin->TransitionOnS2(),
883 Standard_True, Data->ChangeVertexFirstOnS2(),tolesp);
884 ChFi3d_FilCommonPoint(lin->EndPointOnSecond(),lin->TransitionOnS2(),
885 Standard_False, Data->ChangeVertexLastOnS2(),tolesp);
887 Standard_Boolean reverse = (!Forward || Inside);
889 Standard_Boolean ok = Standard_False;
890 const ChFiDS_CommonPoint& cp1 = Data->VertexFirstOnS1();
892 TopoDS_Face F1 = S1->ChangeSurface().Face();
894 intf = !SearchFace(Spine,cp1,F1,bid);
897 const ChFiDS_CommonPoint& cp2 = Data->VertexFirstOnS2();
898 if(cp2.IsOnArc() && !ok){
899 TopoDS_Face F2 = S2->ChangeSurface().Face();
901 intf = !SearchFace(Spine,cp2,F2,bid);
905 Standard_Boolean ok = Standard_False;
906 const ChFiDS_CommonPoint& cp1 = Data->VertexLastOnS1();
908 TopoDS_Face F1 = S1->ChangeSurface().Face();
910 intl = !SearchFace(Spine,cp1,F1,bid);
913 const ChFiDS_CommonPoint& cp2 = Data->VertexLastOnS2();
914 if(cp2.IsOnArc() && !ok){
915 TopoDS_Face F2 = S2->ChangeSurface().Face();
917 intl = !SearchFace(Spine,cp2,F2,bid);
921 else if (chsp->IsChamfer() == ChFiDS_TwoDist) {
922 Standard_Real dis1, dis2;
923 chsp->Dists(dis1, dis2);
924 radius = Max(dis1, dis2);
925 radius = Max(radius, radiusspine);
926 locfleche = radius*1.e-2; //graphic criterion
928 BRepBlend_Chamfer Func(S1,S2,HGuide);
929 BRepBlend_ChamfInv FInv(S1,S2,HGuide);
930 Func.Set(dis1,dis2,Choix);
931 FInv.Set(dis1,dis2,Choix);
933 done = SimulData(Data,HGuide,lin,S1,I1,S2,I2,
934 Func,FInv,PFirst,MaxStep,locfleche,
935 TolGuide,First,Last,Inside,Appro,Forward,
936 Soldep,4,RecOnS1,RecOnS2);
938 if ( !done ) return Standard_False;
939 Handle(ChFiDS_SecHArray1) sec;
940 gp_Pnt2d pf1,pl1,pf2,pl2;
942 Standard_Integer nbp = lin->NbPoints();
943 sec = new ChFiDS_SecHArray1(1,nbp);
944 for( i = 1; i <= nbp; i++ ){
945 ChFiDS_CircSection& isec = sec->ChangeValue(i);
946 Standard_Real u1,v1,u2,v2,ww,p1,p2;
948 const Blend_Point& p = lin->Point(i);
949 p.ParametersOnS1(u1,v1);
950 p.ParametersOnS2(u2,v2);
952 Func.Section(ww,u1,v1,u2,v2,p1,p2,line);
953 isec.Set(line,p1,p2);
954 if(i == 1) {pf1.SetCoord(u1,v1); pf2.SetCoord(u2,v2);}
955 if(i == nbp) {pl1.SetCoord(u1,v1); pl2.SetCoord(u2,v2);}
959 Data->Set2dPoints(pf1,pl1,pf2,pl2);
960 ChFi3d_FilCommonPoint(lin->StartPointOnFirst(),lin->TransitionOnS1(),
961 Standard_True, Data->ChangeVertexFirstOnS1(),tolesp);
962 ChFi3d_FilCommonPoint(lin->EndPointOnFirst(),lin->TransitionOnS1(),
963 Standard_False,Data->ChangeVertexLastOnS1(),tolesp);
964 ChFi3d_FilCommonPoint(lin->StartPointOnSecond(),lin->TransitionOnS2(),
965 Standard_True, Data->ChangeVertexFirstOnS2(),tolesp);
966 ChFi3d_FilCommonPoint(lin->EndPointOnSecond(),lin->TransitionOnS2(),
967 Standard_False, Data->ChangeVertexLastOnS2(),tolesp);
969 Standard_Boolean reverse = (!Forward || Inside);
971 Standard_Boolean ok = Standard_False;
972 const ChFiDS_CommonPoint& cp1 = Data->VertexFirstOnS1();
974 TopoDS_Face F1 = S1->ChangeSurface().Face();
976 intf = !SearchFace(Spine,cp1,F1,bid);
979 const ChFiDS_CommonPoint& cp2 = Data->VertexFirstOnS2();
980 if(cp2.IsOnArc() && !ok){
981 TopoDS_Face F2 = S2->ChangeSurface().Face();
983 intf = !SearchFace(Spine,cp2,F2,bid);
987 Standard_Boolean ok = Standard_False;
988 const ChFiDS_CommonPoint& cp1 = Data->VertexLastOnS1();
990 TopoDS_Face F1 = S1->ChangeSurface().Face();
992 intl = !SearchFace(Spine,cp1,F1,bid);
995 const ChFiDS_CommonPoint& cp2 = Data->VertexLastOnS2();
996 if(cp2.IsOnArc() && !ok){
997 TopoDS_Face F2 = S2->ChangeSurface().Face();
999 intl = !SearchFace(Spine,cp2,F2,bid);
1004 Standard_Real dis, angle;
1005 Standard_Boolean disonF1;
1006 chsp->GetDistAngle(dis, angle, disonF1);
1007 radius = Max(dis, dis * tan(angle));
1008 radius = Max(radius, radiusspine);
1009 locfleche = radius*1.e-2; //graphic criterion
1011 Standard_Integer Ch = FindChoiceDistAngle(Choix, disonF1);
1014 BRepBlend_ChAsym Func(S1,S2,HGuide);
1015 BRepBlend_ChAsymInv FInv(S1,S2,HGuide);
1017 Func.Set(dis, angle, Ch);
1018 FInv.Set(dis, angle, Ch);
1020 done = SimulData(Data,HGuide,lin,S1,I1,S2,I2,
1021 Func,FInv,PFirst,MaxStep,locfleche,
1022 TolGuide,First,Last,Inside,Appro,Forward,
1023 Soldep,4,RecOnS1,RecOnS2);
1025 if ( !done ) return Standard_False;
1026 Handle(ChFiDS_SecHArray1) sec;
1027 gp_Pnt2d pf1,pl1,pf2,pl2;
1029 Standard_Integer nbp = lin->NbPoints();
1030 sec = new ChFiDS_SecHArray1(1,nbp);
1031 for( i = 1; i <= nbp; i++ ){
1032 ChFiDS_CircSection& isec = sec->ChangeValue(i);
1033 Standard_Real u1,v1,u2,v2,ww,p1,p2;
1035 const Blend_Point& p = lin->Point(i);
1036 p.ParametersOnS1(u1,v1);
1037 p.ParametersOnS2(u2,v2);
1039 Func.Section(ww,u1,v1,u2,v2,p1,p2,line);
1040 isec.Set(line,p1,p2);
1041 if(i == 1) {pf1.SetCoord(u1,v1); pf2.SetCoord(u2,v2);}
1042 if(i == nbp) {pl1.SetCoord(u1,v1); pl2.SetCoord(u2,v2);}
1045 Data->SetSimul(sec);
1046 Data->Set2dPoints(pf1,pl1,pf2,pl2);
1047 ChFi3d_FilCommonPoint(lin->StartPointOnFirst(),lin->TransitionOnS1(),
1048 Standard_True, Data->ChangeVertexFirstOnS1(),tolesp);
1049 ChFi3d_FilCommonPoint(lin->EndPointOnFirst(),lin->TransitionOnS1(),
1050 Standard_False,Data->ChangeVertexLastOnS1(),tolesp);
1051 ChFi3d_FilCommonPoint(lin->StartPointOnSecond(),lin->TransitionOnS2(),
1052 Standard_True, Data->ChangeVertexFirstOnS2(),tolesp);
1053 ChFi3d_FilCommonPoint(lin->EndPointOnSecond(),lin->TransitionOnS2(),
1054 Standard_False, Data->ChangeVertexLastOnS2(),tolesp);
1056 Standard_Boolean reverse = (!Forward || Inside);
1057 if(intf && reverse){
1058 Standard_Boolean ok = Standard_False;
1059 const ChFiDS_CommonPoint& cp1 = Data->VertexFirstOnS1();
1061 TopoDS_Face F1 = S1->ChangeSurface().Face();
1063 intf = !SearchFace(Spine,cp1,F1,bid);
1066 const ChFiDS_CommonPoint& cp2 = Data->VertexFirstOnS2();
1067 if(cp2.IsOnArc() && !ok){
1068 TopoDS_Face F2 = S2->ChangeSurface().Face();
1070 intf = !SearchFace(Spine,cp2,F2,bid);
1075 Standard_Boolean ok = Standard_False;
1076 const ChFiDS_CommonPoint& cp1 = Data->VertexLastOnS1();
1078 TopoDS_Face F1 = S1->ChangeSurface().Face();
1080 intl = !SearchFace(Spine,cp1,F1,bid);
1083 const ChFiDS_CommonPoint& cp2 = Data->VertexLastOnS2();
1084 if(cp2.IsOnArc() && !ok){
1085 TopoDS_Face F2 = S2->ChangeSurface().Face();
1087 intl = !SearchFace(Spine,cp2,F2,bid);
1092 BRepBlend_ChAsym Func(S2,S1,HGuide);
1093 BRepBlend_ChAsymInv FInv(S2,S1,HGuide);
1095 Func.Set(dis, angle, Ch);
1096 FInv.Set(dis, angle, Ch);
1098 Standard_Real Rtemp;
1100 Soldep(1) = Soldep(3);
1103 Soldep(2) = Soldep(4);
1106 done = SimulData(Data,HGuide,lin,S2,I2,S1,I1,
1107 Func,FInv,PFirst,MaxStep,locfleche,
1108 TolGuide,First,Last,Inside,Appro,Forward,
1109 Soldep,4,RecOnS2,RecOnS1);
1111 if ( !done ) return Standard_False;
1112 Handle(ChFiDS_SecHArray1) sec;
1113 gp_Pnt2d pf1,pl1,pf2,pl2;
1115 Standard_Integer nbp = lin->NbPoints();
1116 sec = new ChFiDS_SecHArray1(1,nbp);
1117 for( i = 1; i <= nbp; i++ ){
1118 ChFiDS_CircSection& isec = sec->ChangeValue(i);
1119 Standard_Real u1,v1,u2,v2,ww,p1,p2;
1121 const Blend_Point& p = lin->Point(i);
1122 p.ParametersOnS1(u1,v1);
1123 p.ParametersOnS2(u2,v2);
1125 Func.Section(ww,u1,v1,u2,v2,p1,p2,line);
1126 isec.Set(line,p1,p2);
1127 if(i == 1) {pf1.SetCoord(u1,v1); pf2.SetCoord(u2,v2);}
1128 if(i == nbp) {pl1.SetCoord(u1,v1); pl2.SetCoord(u2,v2);}
1131 Data->SetSimul(sec);
1132 Data->Set2dPoints(pf1,pl1,pf2,pl2);
1133 ChFi3d_FilCommonPoint(lin->StartPointOnFirst(),lin->TransitionOnS1(),
1134 Standard_True, Data->ChangeVertexFirstOnS1(),tolesp);
1135 ChFi3d_FilCommonPoint(lin->EndPointOnFirst(),lin->TransitionOnS1(),
1136 Standard_False,Data->ChangeVertexLastOnS1(),tolesp);
1137 ChFi3d_FilCommonPoint(lin->StartPointOnSecond(),lin->TransitionOnS2(),
1138 Standard_True, Data->ChangeVertexFirstOnS2(),tolesp);
1139 ChFi3d_FilCommonPoint(lin->EndPointOnSecond(),lin->TransitionOnS2(),
1140 Standard_False, Data->ChangeVertexLastOnS2(),tolesp);
1142 Standard_Boolean reverse = (!Forward || Inside);
1143 if(intf && reverse){
1144 Standard_Boolean ok = Standard_False;
1145 const ChFiDS_CommonPoint& cp1 = Data->VertexFirstOnS1();
1147 TopoDS_Face F1 = S1->ChangeSurface().Face();
1149 intf = !SearchFace(Spine,cp1,F1,bid);
1152 const ChFiDS_CommonPoint& cp2 = Data->VertexFirstOnS2();
1153 if(cp2.IsOnArc() && !ok){
1154 TopoDS_Face F2 = S2->ChangeSurface().Face();
1156 intf = !SearchFace(Spine,cp2,F2,bid);
1161 Standard_Boolean ok = Standard_False;
1162 const ChFiDS_CommonPoint& cp1 = Data->VertexLastOnS1();
1164 TopoDS_Face F1 = S1->ChangeSurface().Face();
1166 intl = !SearchFace(Spine,cp1,F1,bid);
1169 const ChFiDS_CommonPoint& cp2 = Data->VertexLastOnS2();
1170 if(cp2.IsOnArc() && !ok){
1171 TopoDS_Face F2 = S2->ChangeSurface().Face();
1173 intl = !SearchFace(Spine,cp2,F2,bid);
1178 return Standard_True;
1181 void ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)& ,
1182 const Handle(ChFiDS_HElSpine)& ,
1183 const Handle(ChFiDS_Spine)& ,
1184 const Standard_Integer ,
1185 const Handle(BRepAdaptor_HSurface)& ,
1186 const Handle(Adaptor3d_TopolTool)& ,
1187 const Handle(BRepAdaptor_HCurve2d)& ,
1188 const Handle(BRepAdaptor_HSurface)& ,
1189 const Handle(BRepAdaptor_HCurve2d)& ,
1191 const Handle(BRepAdaptor_HSurface)& ,
1192 const Handle(Adaptor3d_TopolTool)& ,
1193 const TopAbs_Orientation ,
1194 const Standard_Real ,
1195 const Standard_Real ,
1198 const Standard_Boolean ,
1199 const Standard_Boolean ,
1200 const Standard_Boolean ,
1201 const Standard_Boolean ,
1202 const Standard_Boolean ,
1203 const Standard_Boolean ,
1204 const math_Vector& )
1206 throw Standard_Failure("SimulSurf Not Implemented");
1208 void ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)& ,
1209 const Handle(ChFiDS_HElSpine)& ,
1210 const Handle(ChFiDS_Spine)& ,
1211 const Standard_Integer ,
1212 const Handle(BRepAdaptor_HSurface)& ,
1213 const Handle(Adaptor3d_TopolTool)& ,
1214 const TopAbs_Orientation ,
1215 const Handle(BRepAdaptor_HSurface)& ,
1216 const Handle(Adaptor3d_TopolTool)& ,
1217 const Handle(BRepAdaptor_HCurve2d)& ,
1218 const Handle(BRepAdaptor_HSurface)& ,
1219 const Handle(BRepAdaptor_HCurve2d)& ,
1221 const Standard_Real ,
1222 const Standard_Real ,
1225 const Standard_Boolean ,
1226 const Standard_Boolean ,
1227 const Standard_Boolean ,
1228 const Standard_Boolean ,
1229 const Standard_Boolean ,
1230 const Standard_Boolean ,
1231 const math_Vector& )
1233 throw Standard_Failure("SimulSurf Not Implemented");
1235 void ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)& ,
1236 const Handle(ChFiDS_HElSpine)& ,
1237 const Handle(ChFiDS_Spine)& ,
1238 const Standard_Integer ,
1239 const Handle(BRepAdaptor_HSurface)& ,
1240 const Handle(Adaptor3d_TopolTool)& ,
1241 const Handle(BRepAdaptor_HCurve2d)& ,
1242 const Handle(BRepAdaptor_HSurface)& ,
1243 const Handle(BRepAdaptor_HCurve2d)& ,
1245 const TopAbs_Orientation ,
1246 const Handle(BRepAdaptor_HSurface)& ,
1247 const Handle(Adaptor3d_TopolTool)& ,
1248 const Handle(BRepAdaptor_HCurve2d)& ,
1249 const Handle(BRepAdaptor_HSurface)& ,
1250 const Handle(BRepAdaptor_HCurve2d)& ,
1252 const TopAbs_Orientation ,
1253 const Standard_Real ,
1254 const Standard_Real ,
1257 const Standard_Boolean ,
1258 const Standard_Boolean ,
1259 const Standard_Boolean ,
1260 const Standard_Boolean ,
1261 const Standard_Boolean ,
1262 const Standard_Boolean ,
1263 const Standard_Boolean ,
1264 const math_Vector& )
1266 throw Standard_Failure("SimulSurf Not Implemented");
1268 //------------------------MODIFS---------------------------------------
1269 //=======================================================================
1270 //function : PerformFirstSection
1271 //purpose : to implement the first section if there is no KPart
1272 //=======================================================================
1274 Standard_Boolean ChFi3d_ChBuilder::PerformFirstSection
1275 (const Handle(ChFiDS_Spine)& Spine,
1276 const Handle(ChFiDS_HElSpine)& HGuide,
1277 const Standard_Integer Choix,
1278 Handle(BRepAdaptor_HSurface)& S1,
1279 Handle(BRepAdaptor_HSurface)& S2,
1280 const Handle(Adaptor3d_TopolTool)& I1,
1281 const Handle(Adaptor3d_TopolTool)& I2,
1282 const Standard_Real Par,
1283 math_Vector& SolDep,
1285 TopAbs_State& Pos2) const
1287 Handle(ChFiDS_ChamfSpine)
1288 chsp = Handle(ChFiDS_ChamfSpine)::DownCast(Spine);
1291 throw Standard_ConstructionError("PerformSurf : this is not the spine of a chamfer");
1293 Standard_Real TolGuide = HGuide->Resolution(tolesp) ;
1296 if (chsp->IsChamfer() == ChFiDS_Sym) {
1300 BRepBlend_Chamfer Func(S1,S2,HGuide);
1301 Func.Set(dis,dis,Choix);
1302 BRepBlend_Walking TheWalk(S1,S2,I1,I2,HGuide);
1304 //calculate an approximate starting solution
1305 gp_Vec TgF, TgL, tmp1, tmp2, d1gui;
1306 gp_Pnt pt1, pt2, ptgui;
1309 ( HGuide->Curve() ).D1(Par,ptgui,d1gui);
1310 // ptgui = (S1->Surface()).Value(SolDep(1),SolDep(2));
1313 Func.Tangent(SolDep(1),SolDep(2),SolDep(3),SolDep(4),TgF,TgL,tmp1,tmp2);
1315 Standard_Boolean rev1 = Standard_False;
1316 Standard_Boolean rev2 = Standard_False;
1317 Standard_Real sign = (TgF.Crossed(d1gui)).Dot(TgL);
1320 rev1 = Standard_True;
1322 rev2 = Standard_True;
1334 temp = (TgF.XYZ()).Multiplied(dis);
1335 pt1.SetXYZ( (ptgui.XYZ()).Added(temp) );
1336 temp = (TgL.XYZ()).Multiplied(dis);
1337 pt2.SetXYZ( (ptgui.XYZ()).Added(temp) );
1339 Standard_Real tol = tolesp*1.e2;
1340 // Standard_Real u,v;
1341 Extrema_GenLocateExtPS proj1(S1->Surface(), tol, tol);
1342 proj1.Perform(pt1, SolDep(1), SolDep(2));
1343 Extrema_GenLocateExtPS proj2(S2->Surface(), tol, tol);
1344 proj2.Perform(pt2, SolDep(3), SolDep(4));
1346 if( proj1.IsDone() ){
1347 (proj1.Point()).Parameter(SolDep(1),SolDep(2));
1349 if( proj2.IsDone() ){
1350 (proj2.Point()).Parameter(SolDep(3),SolDep(4));
1353 return TheWalk.PerformFirstSection(Func,Par,SolDep,
1354 tolesp,TolGuide,Pos1,Pos2);
1356 else if (chsp->IsChamfer() == ChFiDS_TwoDist) {
1357 Standard_Real dis1, dis2;
1358 chsp->Dists(dis1, dis2);
1360 BRepBlend_Chamfer Func(S1,S2,HGuide);
1361 Func.Set(dis1,dis2,Choix);
1362 BRepBlend_Walking TheWalk(S1,S2,I1,I2,HGuide);
1364 //calculate an approximate starting solution
1365 gp_Vec TgF, TgL, tmp1, tmp2, d1gui;
1366 gp_Pnt pt1, pt2, ptgui;
1369 ( HGuide->Curve() ).D1(Par,ptgui,d1gui);
1370 // ptgui = (S1->Surface()).Value(SolDep(1),SolDep(2));
1373 Func.Tangent(SolDep(1),SolDep(2),SolDep(3),SolDep(4),TgF,TgL,tmp1,tmp2);
1375 Standard_Boolean rev1 = Standard_False;
1376 Standard_Boolean rev2 = Standard_False;
1377 Standard_Real sign = (TgF.Crossed(d1gui)).Dot(TgL);
1380 rev1 = Standard_True;
1382 rev2 = Standard_True;
1394 temp = (TgF.XYZ()).Multiplied(dis1);
1395 pt1.SetXYZ( (ptgui.XYZ()).Added(temp) );
1396 temp = (TgL.XYZ()).Multiplied(dis2);
1397 pt2.SetXYZ( (ptgui.XYZ()).Added(temp) );
1399 Standard_Real tol = tolesp*1.e2;
1400 // Standard_Real u,v;
1402 Extrema_GenLocateExtPS proj1(S1->Surface(), tol, tol);
1403 proj1.Perform(pt1, SolDep(1), SolDep(2));
1404 Extrema_GenLocateExtPS proj2(S2->Surface(), tol, tol);
1405 proj2.Perform(pt2, SolDep(3), SolDep(4));
1407 if( proj1.IsDone() ){
1408 (proj1.Point()).Parameter(SolDep(1),SolDep(2));
1410 if( proj2.IsDone() ){
1411 (proj2.Point()).Parameter(SolDep(3),SolDep(4));
1414 return TheWalk.PerformFirstSection(Func,Par,SolDep,
1415 tolesp,TolGuide,Pos1,Pos2);
1418 Standard_Real dis1, angle;
1419 Standard_Boolean disonF1;
1420 chsp->GetDistAngle(dis1, angle, disonF1);
1422 Standard_Integer Ch = FindChoiceDistAngle(Choix, disonF1);
1425 BRepBlend_ChAsym Func(S1,S2,HGuide);
1426 Func.Set(dis1, angle, Ch);
1427 BRepBlend_Walking TheWalk(S1,S2,I1,I2,HGuide);
1429 //calculate an approximate starting solution
1430 gp_Vec TgF, TgL, tmp1, tmp2, d1gui;
1431 gp_Pnt pt1, pt2, ptgui;
1434 ( HGuide->Curve() ).D1(Par,ptgui,d1gui);
1435 // ptgui = (S1->Surface()).Value(SolDep(1),SolDep(2));
1438 Func.Tangent(SolDep(1),SolDep(2),SolDep(3),SolDep(4),TgF,TgL,tmp1,tmp2);
1440 Standard_Boolean rev1 = Standard_False;
1441 Standard_Boolean rev2 = Standard_False;
1442 Standard_Real sign = (TgF.Crossed(d1gui)).Dot(TgL);
1445 rev1 = Standard_True;
1447 rev2 = Standard_True;
1459 temp = (TgF.XYZ()).Multiplied(dis1);
1460 pt1.SetXYZ( (ptgui.XYZ()).Added(temp) );
1462 Standard_Real dis2, tmpcos, tmpsin;
1463 tmpcos = TgF.Dot(TgL);
1464 tmpsin = sqrt(1. - tmpcos * tmpcos);
1466 dis2 = dis1 / (tmpcos + tmpsin / tan(angle));
1468 temp = (TgL.XYZ()).Multiplied(dis2);
1469 pt2.SetXYZ( (ptgui.XYZ()).Added(temp) );
1471 Standard_Real tol = tolesp*1.e2;
1472 // Standard_Real u,v;
1473 Extrema_GenLocateExtPS proj1(S1->Surface(), tol, tol);
1474 proj1.Perform(pt1, SolDep(1), SolDep(2));
1475 Extrema_GenLocateExtPS proj2(S2->Surface(), tol, tol);
1476 proj2.Perform(pt2, SolDep(3), SolDep(4));
1477 if( proj1.IsDone() ){
1478 (proj1.Point()).Parameter(SolDep(1),SolDep(2));
1480 if( proj2.IsDone() ){
1481 (proj2.Point()).Parameter(SolDep(3),SolDep(4));
1484 return TheWalk.PerformFirstSection(Func,Par,SolDep,
1485 tolesp,TolGuide,Pos1,Pos2);
1488 Standard_Real Rtemp;
1489 BRepBlend_ChAsym Func(S2,S1,HGuide);
1490 Func.Set(dis1, angle, Ch);
1491 BRepBlend_Walking TheWalk(S2,S1,I2,I1,HGuide);
1493 //calculate an approximate starting solution
1494 gp_Vec TgF, TgL, tmp1, tmp2, d1gui;
1495 gp_Pnt pt1, pt2, ptgui;
1498 ( HGuide->Curve() ).D1(Par,ptgui,d1gui);
1499 // ptgui = (S1->Surface()).Value(SolDep(1),SolDep(2));
1501 SolDep(1) = SolDep(3);
1504 SolDep(2) = SolDep(4);
1508 Func.Tangent(SolDep(1),SolDep(2),SolDep(3),SolDep(4),TgF,TgL,tmp1,tmp2);
1510 Standard_Boolean rev1 = Standard_False;
1511 Standard_Boolean rev2 = Standard_False;
1512 Standard_Real sign = (TgF.Crossed(d1gui)).Dot(TgL);
1515 rev1 = Standard_True;
1517 rev2 = Standard_True;
1529 temp = (TgF.XYZ()).Multiplied(dis1);
1530 pt1.SetXYZ( (ptgui.XYZ()).Added(temp) );
1532 Standard_Real dis2, tmpcos, tmpsin;
1533 tmpcos = TgF.Dot(TgL);
1534 tmpsin = sqrt(1. - tmpcos * tmpcos);
1536 dis2 = dis1 / (tmpcos + tmpsin / tan(angle));
1538 temp = (TgL.XYZ()).Multiplied(dis2);
1539 pt2.SetXYZ( (ptgui.XYZ()).Added(temp) );
1541 Standard_Real tol = tolesp*1.e2;
1542 // Standard_Real u,v;
1543 Extrema_GenLocateExtPS proj1(S2->Surface(), tol, tol);
1544 proj1.Perform(pt1, SolDep(1), SolDep(2));
1545 Extrema_GenLocateExtPS proj2(S1->Surface(), tol, tol);
1546 proj2.Perform(pt2, SolDep(3), SolDep(4));
1547 if( proj1.IsDone() ) {
1548 (proj1.Point()).Parameter(SolDep(1),SolDep(2));
1550 if( proj2.IsDone() ){
1551 (proj2.Point()).Parameter(SolDep(3),SolDep(4));
1554 Standard_Boolean RetWalk = TheWalk.PerformFirstSection(Func,Par,SolDep,
1555 tolesp,TolGuide,Pos2,Pos1);
1557 SolDep(1) = SolDep(3);
1560 SolDep(2) = SolDep(4);
1569 //=======================================================================
1570 //function : PerformSurf
1572 //=======================================================================
1575 ChFi3d_ChBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData,
1576 const Handle(ChFiDS_HElSpine)& HGuide,
1577 const Handle(ChFiDS_Spine)& Spine,
1578 const Standard_Integer Choix,
1579 const Handle(BRepAdaptor_HSurface)& S1,
1580 const Handle(Adaptor3d_TopolTool)& I1,
1581 const Handle(BRepAdaptor_HSurface)& S2,
1582 const Handle(Adaptor3d_TopolTool)& I2,
1583 const Standard_Real MaxStep,
1584 const Standard_Real Fleche,
1585 const Standard_Real TolGuide,
1586 Standard_Real& First,
1587 Standard_Real& Last,
1588 const Standard_Boolean Inside,
1589 const Standard_Boolean Appro,
1590 const Standard_Boolean Forward,
1591 const Standard_Boolean RecOnS1,
1592 const Standard_Boolean RecOnS2,
1593 const math_Vector& Soldep,
1594 Standard_Integer& intf,
1595 Standard_Integer& intl)
1598 Handle(ChFiDS_SurfData) Data = SeqData(1);
1599 Handle(ChFiDS_ChamfSpine)
1600 chsp = Handle(ChFiDS_ChamfSpine)::DownCast(Spine);
1603 throw Standard_ConstructionError("PerformSurf : this is not the spine of a chamfer");
1605 Standard_Boolean gd1,gd2,gf1,gf2;
1606 Handle(BRepBlend_Line) lin;
1607 TopAbs_Orientation Or = S1->ChangeSurface().Face().Orientation();
1608 Standard_Real PFirst = First;
1609 if(intf) First = chsp->FirstParameter(1);
1610 if(intl) Last = chsp->LastParameter(chsp->NbEdges());
1612 if (chsp->IsChamfer() == ChFiDS_Sym) {
1613 BRepBlend_Chamfer Func(S1,S2,HGuide);
1614 BRepBlend_ChamfInv FInv(S1,S2,HGuide);
1617 Func.Set(dis, dis, Choix);
1618 FInv.Set(dis, dis, Choix);
1620 done = ComputeData(Data,HGuide,Spine,lin,S1,I1,S2,I2,Func,FInv,
1621 PFirst,MaxStep,Fleche,TolGuide,First,Last,
1622 Inside,Appro,Forward,Soldep,intf,intl,
1623 gd1,gd2,gf1,gf2,RecOnS1,RecOnS2);
1624 if(!done) return Standard_False; // ratrappage possible PMN 14/05/1998
1625 done = CompleteData(Data,Func,lin,S1,S2,Or,gd1,gd2,gf1,gf2);
1626 if(!done) throw Standard_Failure("PerformSurf : Fail of approximation!");
1628 else if (chsp->IsChamfer() == ChFiDS_TwoDist) {
1629 BRepBlend_Chamfer Func(S1,S2,HGuide);
1630 BRepBlend_ChamfInv FInv(S1,S2,HGuide);
1631 Standard_Real d1, d2;
1633 Func.Set(d1,d2,Choix);
1634 FInv.Set(d1,d2,Choix);
1636 done = ComputeData(Data,HGuide,Spine,lin,S1,I1,S2,I2,Func,FInv,
1637 PFirst,MaxStep,Fleche,TolGuide,First,Last,
1638 Inside,Appro,Forward,Soldep,intf,intl,
1639 gd1,gd2,gf1,gf2,RecOnS1,RecOnS2);
1640 if(!done) return Standard_False; // ratrappage possible PMN 14/05/1998
1641 done = CompleteData(Data,Func,lin,S1,S2,Or,gd1,gd2,gf1,gf2);
1642 if(!done) throw Standard_Failure("PerformSurf : Fail of approximation!");
1645 Standard_Real d1, angle;
1646 Standard_Boolean disonF1;
1647 chsp->GetDistAngle(d1, angle, disonF1);
1649 Standard_Integer Ch = FindChoiceDistAngle(Choix, disonF1);
1652 BRepBlend_ChAsym Func(S1,S2,HGuide);
1653 BRepBlend_ChAsymInv FInv(S1,S2,HGuide);
1654 Func.Set(d1, angle, Ch);
1655 FInv.Set(d1, angle, Ch);
1657 done = ComputeData(Data,HGuide,Spine,lin,S1,I1,S2,I2,Func,FInv,
1658 PFirst,MaxStep,Fleche,TolGuide,First,Last,
1659 Inside,Appro,Forward,Soldep,intf,intl,
1660 gd1,gd2,gf1,gf2,RecOnS1,RecOnS2);
1662 if(!done) return Standard_False; // ratrappage possible PMN 14/05/1998
1663 done = CompleteData(Data,Func,lin,S1,S2,Or,gd1,gd2,gf1,gf2);
1664 if(!done) throw Standard_Failure("PerformSurf : Fail of approximation!");
1667 Standard_Real Rtemp;
1668 BRepBlend_ChAsym Func(S2, S1, HGuide);
1669 BRepBlend_ChAsymInv FInv(S2, S1,HGuide);
1670 Func.Set(d1, angle, Ch);
1671 FInv.Set(d1, angle, Ch);
1674 Soldep(1) = Soldep(3);
1677 Soldep(2) = Soldep(4);
1680 TopAbs_Orientation Or2 = S2->ChangeSurface().Face().Orientation();
1682 done = ComputeData(Data,HGuide,Spine,lin,S2,I2,S1,I1,Func,FInv,
1683 PFirst,MaxStep,Fleche,TolGuide,First,Last,
1684 Inside,Appro,Forward,Soldep,intf,intl,
1685 gd2,gd1,gf2,gf1,RecOnS2,RecOnS1);
1687 ChFiDS_CommonPoint tmp = Data->VertexFirstOnS1();
1688 Data->ChangeVertexFirstOnS1() = Data->VertexFirstOnS2();
1689 Data->ChangeVertexFirstOnS2() = tmp;
1690 tmp = Data->VertexLastOnS1();
1691 Data->ChangeVertexLastOnS1() = Data->VertexLastOnS2();
1692 Data->ChangeVertexLastOnS2() = tmp;
1693 if(!done) return Standard_False; // ratrappage possible PMN 14/05/1998
1694 done = CompleteData(Data,Func,lin,S1,S2,Or2,gd1,gd2,gf1,gf2, Standard_True);
1695 if(!done) throw Standard_Failure("PerformSurf : Fail of approximation!");
1699 return Standard_True;
1701 void ChFi3d_ChBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& ,
1702 const Handle(ChFiDS_HElSpine)& ,
1703 const Handle(ChFiDS_Spine)& ,
1704 const Standard_Integer ,
1705 const Handle(BRepAdaptor_HSurface)& ,
1706 const Handle(Adaptor3d_TopolTool)& ,
1707 const Handle(BRepAdaptor_HCurve2d)& ,
1708 const Handle(BRepAdaptor_HSurface)& ,
1709 const Handle(BRepAdaptor_HCurve2d)& ,
1711 const Handle(BRepAdaptor_HSurface)& ,
1712 const Handle(Adaptor3d_TopolTool)& ,
1713 const TopAbs_Orientation ,
1714 const Standard_Real ,
1715 const Standard_Real ,
1716 const Standard_Real ,
1719 const Standard_Boolean ,
1720 const Standard_Boolean ,
1721 const Standard_Boolean ,
1722 const Standard_Boolean ,
1723 const Standard_Boolean ,
1724 const Standard_Boolean ,
1725 const math_Vector& )
1727 throw Standard_Failure("PerformSurf Not Implemented");
1729 void ChFi3d_ChBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& ,
1730 const Handle(ChFiDS_HElSpine)& ,
1731 const Handle(ChFiDS_Spine)& ,
1732 const Standard_Integer ,
1733 const Handle(BRepAdaptor_HSurface)& ,
1734 const Handle(Adaptor3d_TopolTool)& ,
1735 const TopAbs_Orientation ,
1736 const Handle(BRepAdaptor_HSurface)& ,
1737 const Handle(Adaptor3d_TopolTool)& ,
1738 const Handle(BRepAdaptor_HCurve2d)& ,
1739 const Handle(BRepAdaptor_HSurface)& ,
1740 const Handle(BRepAdaptor_HCurve2d)& ,
1742 const Standard_Real ,
1743 const Standard_Real ,
1744 const Standard_Real ,
1747 const Standard_Boolean ,
1748 const Standard_Boolean ,
1749 const Standard_Boolean ,
1750 const Standard_Boolean ,
1751 const Standard_Boolean ,
1752 const Standard_Boolean ,
1753 const math_Vector& )
1755 throw Standard_Failure("PerformSurf Not Implemented");
1758 void ChFi3d_ChBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& ,
1759 const Handle(ChFiDS_HElSpine)& ,
1760 const Handle(ChFiDS_Spine)& ,
1761 const Standard_Integer ,
1762 const Handle(BRepAdaptor_HSurface)& ,
1763 const Handle(Adaptor3d_TopolTool)& ,
1764 const Handle(BRepAdaptor_HCurve2d)& ,
1765 const Handle(BRepAdaptor_HSurface)& ,
1766 const Handle(BRepAdaptor_HCurve2d)& ,
1768 const TopAbs_Orientation ,
1769 const Handle(BRepAdaptor_HSurface)& ,
1770 const Handle(Adaptor3d_TopolTool)& ,
1771 const Handle(BRepAdaptor_HCurve2d)& ,
1772 const Handle(BRepAdaptor_HSurface)& ,
1773 const Handle(BRepAdaptor_HCurve2d)& ,
1775 const TopAbs_Orientation ,
1776 const Standard_Real ,
1777 const Standard_Real ,
1778 const Standard_Real ,
1781 const Standard_Boolean ,
1782 const Standard_Boolean ,
1783 const Standard_Boolean ,
1784 const Standard_Boolean ,
1785 const Standard_Boolean ,
1786 const Standard_Boolean ,
1787 const Standard_Boolean ,
1788 const math_Vector& )
1790 throw Standard_Failure("PerformSurf Not Implemented");
1793 //=======================================================================
1794 //function : ExtentOneCorner
1795 //purpose : extends the spine of the stripe S on the side of the vertex V
1796 // PMN : 28/11/97 : Reproduces the code of fillets, and it seems to work better...
1797 //=======================================================================
1799 void ChFi3d_ChBuilder::ExtentOneCorner(const TopoDS_Vertex& V,
1800 const Handle(ChFiDS_Stripe)& S)
1802 Standard_Integer Sens = 0;
1803 Standard_Real Coeff = 0.5;
1804 Handle(ChFiDS_Spine) Spine = S->Spine();
1805 ChFi3d_IndexOfSurfData(V,S,Sens);
1806 if (Spine->IsTangencyExtremity((Sens == 1))) return; //No extension on queue
1807 Standard_Real dU = Spine->LastParameter(Spine->NbEdges());
1809 Spine->SetFirstParameter(-dU*Coeff);
1810 Spine->SetFirstTgt(0.);
1813 Spine->SetLastParameter(dU*(1.+Coeff));
1814 Spine->SetLastTgt(dU);
1817 Standard_Integer Sens;
1818 Standard_Boolean isfirst;
1819 Standard_Integer Iedge = 1;
1820 Standard_Real d1, d2;
1822 Handle(ChFiDS_Spine) Spine = S->Spine();
1823 Handle(ChFiDS_ChamfSpine)
1824 chsp = Handle(ChFiDS_ChamfSpine)::DownCast(Spine);
1826 Standard_Integer IE = ChFi3d_IndexOfSurfData(V,S,Sens);
1827 isfirst = (Sens == 1);
1829 Iedge = Spine->NbEdges();
1831 TopTools_ListIteratorOfListOfShape It, Jt;
1832 TopoDS_Edge E1, E2, Ec;
1833 TopoDS_Face F1, F2, Fc;
1834 TopoDS_Edge EdgeSp = Spine->Edges(Iedge);
1836 ConexFaces(Spine,Iedge,F1,F2);
1838 for (Jt.Initialize(myVEMap(V));Jt.More();Jt.Next()) {
1839 Ec = TopoDS::Edge(Jt.Value());
1840 if (!Ec.IsSame(EdgeSp)){
1841 for (It.Initialize(myEFMap(Ec));It.More();It.Next()) {
1842 Fc = TopoDS::Face(It.Value());
1845 else if (Fc.IsSame(F2))
1851 gp_Vec tg1, tg2, tgsp;
1853 Spine->D1(Spine->Absc(V),ptgui,tgsp);
1858 BRepAdaptor_Curve curv;
1859 curv.Initialize(E1);
1860 curv.D1(curv.FirstParameter(),tmp,tg1); //pour eviter les projections
1862 // pbm d'erreurs d'approx : baisser la tolerance
1863 if( !tmp.IsEqual(ptgui,tolesp*1.e2) )
1864 curv.D1(curv.LastParameter(),tmp,tg1);
1867 curv.Initialize(E2);
1868 curv.D1(curv.FirstParameter(),tmp,tg2);
1870 if( !tmp.IsEqual(ptgui,tolesp*1.e2) )
1871 curv.D1(curv.LastParameter(),tmp,tg2);
1874 Standard_Real dspine;
1875 Standard_Real d1plus = 0.;
1876 Standard_Real d2plus = 0.;
1878 Standard_Real sinalpha = tg1.Dot(tgsp);
1880 Standard_Real cosalpha = Sqrt(1 - sinalpha*sinalpha);
1881 d1plus = -d1*sinalpha/cosalpha;
1883 sinalpha = tg2.Dot(tgsp);
1885 Standard_Real cosalpha = Sqrt(1 - sinalpha*sinalpha);
1886 d2plus = -d2*sinalpha/cosalpha;
1889 if (d2plus > d1plus)
1896 Spine->SetFirstParameter(-dspine);
1897 Spine->SetFirstTgt(0.);
1900 Standard_Real param = Spine->LastParameter(Spine->NbEdges());
1901 Spine->SetLastParameter(param+dspine);
1902 Spine->SetLastTgt(param);
1908 //=======================================================================
1909 //function : ExtentTwoCorner
1910 //purpose : extends the spines of the stripes contained in the list LS,
1911 // on the side of the vertex V
1912 //=======================================================================
1915 void ChFi3d_ChBuilder::ExtentTwoCorner(const TopoDS_Vertex& V,
1916 const ChFiDS_ListOfStripe& LS)
1918 Standard_Integer Sens = 0;
1919 ChFiDS_ListIteratorOfListOfStripe itel(LS);
1920 Standard_Boolean FF = Standard_True;
1921 Standard_Boolean isfirst[2];
1922 Standard_Integer Iedge[2];
1925 Handle(ChFiDS_Stripe) Stripe[2];
1926 Handle(ChFiDS_Spine) Spine[2];
1928 Standard_Integer i = 0;
1929 for (; itel.More(); itel.Next(),i++) {
1930 ChFi3d_IndexOfSurfData(V,itel.Value(),Sens);
1932 if ( Stripe[1] == itel.Value())
1935 Stripe[i] = itel.Value();
1936 isfirst[i] = (Sens == 1);
1937 Spine[i] = Stripe[i]->Spine();
1939 Iedge[i] = Spine[i]->NbEdges();
1940 FF = Standard_False;
1944 Handle(ChFiDS_ChamfSpine) chsp[2];
1945 Standard_Real d[4], dis[2] = { 0.0, 0.0 };
1948 Standard_Real tmpang, tmd;
1949 Standard_Boolean disonF1;
1952 for (i=0, j=0; i<2; i++, j += 2) {
1953 chsp[i] = Handle(ChFiDS_ChamfSpine)::DownCast(Spine[i]);
1954 ConexFaces(Spine[i],Iedge[i],F[j],F[j+1]);
1956 if (chsp[i]->IsChamfer() == ChFiDS_Sym) {
1957 chsp[i]->GetDist(d[j]);
1960 else if (chsp[i]->IsChamfer() == ChFiDS_TwoDist) {
1961 chsp[i]->Dists(d[j],d[j+1]);
1964 chsp[i]->GetDistAngle(tmd, tmpang, disonF1);
1965 // an approximate calculation of distance 2 is done
1968 d[j+1] = tmd * tan(tmpang);
1972 d[j] = tmd * tan(tmpang);
1979 Standard_Boolean notfound = Standard_True;
1981 while (notfound && (i<2)) {
1983 while (notfound && (j<2)) {
1984 if (F[i].IsSame(F[j+2])) {
1986 // dOnArc[0] = d[(i+1)%2];
1989 // dOnArc[1] = d[(j+1)%2 + 2];
1990 notfound = Standard_False;
1998 ChFiDS_State State[2];
2000 for (i=0; i<2; i++) {
2002 State[i] = Spine[i]->FirstStatus();
2004 State[i] = Spine[i]->LastStatus();
2007 if (State[0] == ChFiDS_AllSame ){
2009 // The greatest intersection of the chamfer is found (on the incident edge)
2010 // with the face at end
2013 if(dOnArc[j] > dOnArc[i]) {
2014 Standard_Integer temp = i;
2018 ExtentOneCorner( V, Stripe[i] ); */
2020 // it is necessary that two chamfers touch the face at end
2022 ExtentOneCorner( V, Stripe[j] );
2024 else if ((State[0] == ChFiDS_OnSame) && (State[1] == ChFiDS_OnSame)) {
2026 ExtentSpineOnCommonFace(Spine[0],Spine[1],V,dis[0],dis[1],
2027 isfirst[0],isfirst[1]);
2032 //=======================================================================
2033 //function : ExtentThreeCorner
2035 //=======================================================================
2037 void ChFi3d_ChBuilder::ExtentThreeCorner(const TopoDS_Vertex& V,
2038 const ChFiDS_ListOfStripe& LS)
2040 Standard_Integer Sens = 0;
2041 ChFiDS_ListOfStripe check;
2042 Standard_Boolean isfirst[3];
2043 Standard_Integer Iedge[3];
2047 Handle(ChFiDS_Spine) Spine[3];
2049 Standard_Integer i = 0;
2050 for(ChFiDS_ListIteratorOfListOfStripe itel(LS); itel.More(); itel.Next(), i++) {
2051 Handle(ChFiDS_Stripe) Stripe = itel.Value();
2052 ChFi3d_IndexOfSurfData(V,Stripe,Sens);
2053 for(ChFiDS_ListIteratorOfListOfStripe ich(check); ich.More(); ich.Next()){
2054 if(Stripe == ich.Value()){
2060 isfirst[i] = (Sens == 1);
2061 Spine[i] = Stripe->Spine();
2063 Iedge[i] = Spine[i]->NbEdges();
2065 check.Append(Stripe);
2068 Standard_Real d[3][2], tmd, tmpangle;
2069 Standard_Boolean disonF1;
2071 TopoDS_Face F[3][2];
2073 Handle(ChFiDS_ChamfSpine) chsp[3];
2075 for (i=0; i<3; i++) {
2076 chsp[i] = Handle(ChFiDS_ChamfSpine)::DownCast(Spine[i]);
2077 ConexFaces(Spine[i],Iedge[i],F[i][0],F[i][1]);
2079 if (chsp[i]->IsChamfer() == ChFiDS_Sym) {
2080 chsp[i]->GetDist(d[i][0]);
2083 else if (chsp[i]->IsChamfer() == ChFiDS_TwoDist) {
2084 chsp[i]->Dists(d[i][0],d[i][1]);
2087 chsp[i]->GetDistAngle(tmd, tmpangle, disonF1);
2088 // an approximate calculation of distance 2 is done
2092 d[i][1] = tmd * tan(tmpangle);
2095 d[i][0] = tmd * tan(tmpangle);
2102 // dis[i][j] distance from chamfer i on the common face with
2104 Standard_Real dis[3][3];
2106 for (i=0; i<3; i++) {
2107 // for (Standard_Integer ii=0; ii<3; ii++) {
2110 Standard_Boolean notfound = Standard_True;
2111 Standard_Integer k, l;
2113 while (notfound && (k<2)) {
2115 while (notfound && (l<2)) {
2116 if (F[i][k].IsSame(F[j][l])) {
2117 dis[i][j] = d[i][k];
2118 dis[j][i] = d[j][l];
2119 notfound = Standard_False;
2129 for (i=0; i<3; i++) {
2131 ExtentSpineOnCommonFace(Spine[i],Spine[j],V,dis[i][j],dis[j][i],
2132 isfirst[i],isfirst[j]);
2137 //=======================================================================
2138 //function : SetRegul
2140 //=======================================================================
2142 void ChFi3d_ChBuilder::SetRegul()
2145 ChFiDS_ListIteratorOfRegularities it;
2146 TopTools_ListIteratorOfListOfShape itc;
2147 TopTools_ListIteratorOfListOfShape its1;
2148 TopTools_ListIteratorOfListOfShape its2;
2149 BRepAdaptor_Surface S;
2150 BRepAdaptor_Curve2d PC;
2151 Standard_Real u,v,t;
2155 Standard_Real Seuil = M_PI/360.;
2156 Standard_Real Seuil2 = Seuil * Seuil;
2157 for (it.Initialize(myRegul); it.More(); it.Next()){
2158 const ChFiDS_Regul& reg = it.Value();
2159 itc.Initialize(myCoup->NewEdges(reg.Curve()));
2161 TopoDS_Edge E = TopoDS::Edge(itc.Value());
2162 if(reg.IsSurface1() && reg.IsSurface2()){
2163 its1.Initialize(myCoup->NewFaces(reg.S1()));
2164 its2.Initialize(myCoup->NewFaces(reg.S2()));
2165 if(its1.More() && its2.More()){
2166 TopoDS_Face F1 = TopoDS::Face(its1.Value());
2167 TopoDS_Face F2 = TopoDS::Face(its2.Value());
2168 S.Initialize(F1,Standard_False);
2169 PC.Initialize(E,F1);
2170 t = 0.5*(PC.FirstParameter() + PC.LastParameter());
2171 PC.Value(t).Coord(u,v);
2173 n1 = du.Crossed(dv);
2175 S.Initialize(F2,Standard_False);
2176 PC.Initialize(E,F2);
2177 PC.Value(t).Coord(u,v);
2179 n2 = du.Crossed(dv);
2181 if(n1.SquareMagnitude() > 1.e-14 && n2.SquareMagnitude() > 1.e-14){
2184 Standard_Real sina2 = n1.Crossed(n2).SquareMagnitude();
2185 if(sina2 < Seuil2) {
2186 GeomAbs_Shape cont = ChFi3d_evalconti(E,F1,F2);
2187 B.Continuity(E,F1,F2,cont);
2196 //=======================================================================
2197 //function : ConexFaces
2198 //purpose : F1, F2 are connected to edge so that F1 corresponds to distance
2199 //=======================================================================
2201 void ChFi3d_ChBuilder::ConexFaces (const Handle(ChFiDS_Spine)& Spine,
2202 const Standard_Integer IEdge,
2204 TopoDS_Face& F2) const
2206 BRepAdaptor_Surface Sb1,Sb2;
2207 TopAbs_Orientation tmp1,tmp2;
2208 Standard_Integer RC,Choix;
2209 TopoDS_Face f1,f2,ff1,ff2;
2211 //calculate the reference orientation
2212 // ChFi3d_Builder::StripeOrientations is private
2213 SearchCommonFaces(myEFMap,Spine->Edges(1),ff1,ff2);
2214 ff1.Orientation(TopAbs_FORWARD);
2215 Sb1.Initialize(ff1);
2216 ff2.Orientation(TopAbs_FORWARD);
2217 Sb2.Initialize(ff2);
2218 RC = ChFi3d::ConcaveSide(Sb1,Sb2,Spine->Edges(1),tmp1,tmp2);
2220 //calculate the connected faces
2221 SearchCommonFaces(myEFMap,Spine->Edges(IEdge),f1,f2);
2224 Choix = ChFi3d::ConcaveSide(Sb1,Sb2,Spine->Edges(IEdge),tmp1,tmp2);
2226 if (RC%2 != Choix%2) {
2237 //=======================================================================
2238 //function : FindChoiceDistAngle
2239 //purpose : F1, F2 connected to the edge so that F1 corresponds to distance
2240 //=======================================================================
2242 Standard_Integer ChFi3d_ChBuilder::FindChoiceDistAngle(const Standard_Integer Choice,
2243 const Standard_Boolean DisOnF1) const
2245 Standard_Integer ch = 0;