1 // Created on: 1993-12-15
2 // Created by: Isabelle GRIGNON
3 // Copyright (c) 1993-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 <Adaptor2d_HCurve2d.hxx>
19 #include <Adaptor3d_HSurface.hxx>
20 #include <Adaptor3d_TopolTool.hxx>
21 #include <AppBlend_Approx.hxx>
22 #include <Blend_CurvPointFuncInv.hxx>
23 #include <Blend_FuncInv.hxx>
24 #include <Blend_Function.hxx>
25 #include <Blend_RstRstFunction.hxx>
26 #include <Blend_SurfCurvFuncInv.hxx>
27 #include <Blend_SurfPointFuncInv.hxx>
28 #include <Blend_SurfRstFunction.hxx>
29 #include <BRep_Tool.hxx>
30 #include <BRepAdaptor_Curve.hxx>
31 #include <BRepAdaptor_HCurve.hxx>
32 #include <BRepAdaptor_HCurve2d.hxx>
33 #include <BRepAdaptor_HSurface.hxx>
34 #include <BRepAdaptor_Surface.hxx>
35 #include <BRepBlend_Line.hxx>
36 #include <BRepLib_MakeFace.hxx>
37 #include <BRepLProp_SLProps.hxx>
38 #include <BRepTools.hxx>
39 #include <BRepTools_WireExplorer.hxx>
40 #include <BRepTopAdaptor_TopolTool.hxx>
42 #include <ChFi3d_Builder.hxx>
43 #include <ChFi3d_Builder_0.hxx>
44 #include <ChFiDS_ChamfSpine.hxx>
45 #include <ChFiDS_CommonPoint.hxx>
46 #include <ChFiDS_ElSpine.hxx>
47 #include <ChFiDS_ErrorStatus.hxx>
48 #include <ChFiDS_FaceInterference.hxx>
49 #include <ChFiDS_FilSpine.hxx>
50 #include <ChFiDS_HData.hxx>
51 #include <ChFiDS_HElSpine.hxx>
52 #include <ChFiDS_ListIteratorOfListOfHElSpine.hxx>
53 #include <ChFiDS_ListOfHElSpine.hxx>
54 #include <ChFiDS_SequenceOfSurfData.hxx>
55 #include <ChFiDS_Spine.hxx>
56 #include <ChFiDS_State.hxx>
57 #include <ChFiDS_Stripe.hxx>
58 #include <ChFiDS_SurfData.hxx>
59 #include <ChFiKPart_ComputeData.hxx>
61 #include <Extrema_ExtPC.hxx>
62 #include <Extrema_ExtPS.hxx>
63 #include <Extrema_LocateExtPC.hxx>
64 #include <Extrema_POnCurv.hxx>
65 #include <Geom2d_Curve.hxx>
66 #include <Geom_BSplineCurve.hxx>
67 #include <Geom_BSplineSurface.hxx>
68 #include <Geom_Line.hxx>
69 #include <Geom_Plane.hxx>
70 #include <Geom_Surface.hxx>
71 #include <GeomAdaptor_HCurve.hxx>
72 #include <GeomAdaptor_HSurface.hxx>
73 #include <GeomAdaptor_Surface.hxx>
74 #include <GeomAPI_ProjectPointOnCurve.hxx>
77 #include <gp_Pnt2d.hxx>
80 #include <math_Vector.hxx>
81 #include <Precision.hxx>
82 #include <Standard_ConstructionError.hxx>
83 #include <Standard_NoSuchObject.hxx>
84 #include <Standard_NotImplemented.hxx>
85 #include <Standard_OutOfRange.hxx>
86 #include <TColgp_Array1OfPnt.hxx>
87 #include <TColgp_Array1OfVec.hxx>
88 #include <TColStd_Array1OfInteger.hxx>
89 #include <TColStd_Array1OfReal.hxx>
90 #include <TColStd_ListOfInteger.hxx>
92 #include <TopAbs_Orientation.hxx>
93 #include <TopAbs_ShapeEnum.hxx>
95 #include <TopExp_Explorer.hxx>
97 #include <TopoDS_Edge.hxx>
98 #include <TopoDS_Face.hxx>
99 #include <TopoDS_Shape.hxx>
100 #include <TopoDS_Vertex.hxx>
101 #include <TopoDS_Wire.hxx>
102 #include <TopOpeBRepBuild_HBuilder.hxx>
103 #include <TopOpeBRepDS_HDataStructure.hxx>
104 #include <TopTools_ListIteratorOfListOfShape.hxx>
108 #include <DrawTrSurf.hxx>
110 #include <OSD_Chronometer.hxx>
111 extern Standard_Real t_perfsetofkpart,t_perfsetofkgen,t_makextremities,t_performsurf,t_startsol;
112 extern Standard_Boolean ChFi3d_GettraceCHRON();
113 extern void ChFi3d_InitChron(OSD_Chronometer& ch);
114 extern void ChFi3d_ResultChron(OSD_Chronometer & ch, Standard_Real& time);
118 //===================================================================
119 // Definition by a plane
121 // It is considered that P1 and P2 are points associated to commonpoints compoint1 and
122 // compoint2, while E1 and E2 are edges containing P1 and P2.
123 // The plane containing three directions D12 T1 T2 ou D12 represente la direction formee
124 // par les points P1 et P2, T1 la tangente de E1 en P1 et T2 la tangente de
125 // E2 en P2 is found (if exists).
126 // Then fillet HConge is intersected by this plane
127 // to find associated curve 3d C3d and the curve 2d.
129 //====================================================================
130 static void ChFi3d_CoupeParPlan (const ChFiDS_CommonPoint & compoint1,
131 const ChFiDS_CommonPoint & compoint2,
132 Handle(GeomAdaptor_HSurface)& HConge,
133 const gp_Pnt2d & UV1,
134 const gp_Pnt2d & UV2,
135 const Standard_Real tol3d,
136 const Standard_Real tol2d,
137 Handle(Geom_Curve) &C3d,
138 Handle(Geom2d_Curve) &pcurve,
139 Standard_Real & tolreached,
140 Standard_Real & Pardeb,
141 Standard_Real & Parfin,
142 Standard_Boolean & plane)
143 { plane=Standard_True;
144 if(compoint1.IsOnArc() && compoint2.IsOnArc() ) {
146 BRepAdaptor_Curve BCurv1(compoint1.Arc());
147 BRepAdaptor_Curve BCurv2(compoint2.Arc());
148 Standard_Real parE1,parE2;
149 parE1=compoint1.ParameterOnArc();
150 parE2=compoint2.ParameterOnArc();
152 BCurv1.D1(parE1,P1,t1);
153 BCurv2.D1(parE2,P2,t2);
156 gp_Vec v12(P2.X()-P1.X(),P2.Y()-P1.Y(),P2.Z()-P1.Z());
158 gp_Dir nor =tgt1.Crossed(d12);
159 Handle (Geom_Plane) Plan=new Geom_Plane(P1,nor);
161 scal=Abs(nor.Dot(tgt2));
163 Handle(GeomAdaptor_HSurface) HPlan=new GeomAdaptor_HSurface(Plan);
164 Handle(Geom2d_Curve) C2dint2;
165 TColStd_Array1OfReal Pdeb(1,4),Pfin(1,4);
166 GeomAdaptor_Surface AS(Plan);
167 Extrema_ExtPS ext(P1,AS,1.e-3,1.e-3);
168 Extrema_ExtPS ext1 (P2,AS,1.e-3,1.e-3);
170 ext.Point(1).Parameter(u1,v1);
171 Pdeb(1)= UV1.X();Pdeb(2) = UV1.Y();
172 Pdeb(3)= u1;Pdeb(4) =v1;
173 ext1.Point(1).Parameter(u1,v1);
174 Pfin(1)= UV2.X();Pfin(2) = UV2.Y();
175 Pfin(3)= u1;Pfin(4) = v1;
176 if (ChFi3d_ComputeCurves(HConge,HPlan,Pdeb,Pfin,C3d,
177 pcurve,C2dint2,tol3d,tol2d,tolreached)){
178 Pardeb=C3d->FirstParameter();
179 Parfin=C3d->LastParameter();
181 else plane=Standard_False;
183 else plane=Standard_False;
185 else plane=Standard_False;
187 //=======================================================================
188 //function : SortieTangente
190 //=======================================================================
192 static Standard_Boolean SortieTangente(const ChFiDS_CommonPoint& CP,
193 const TopoDS_Face& /*F*/,
194 const Handle(ChFiDS_SurfData)& /*SD*/,
195 const Standard_Integer /*OnS*/,
196 const Standard_Real TolAngular)
198 if(!CP.HasVector()) return Standard_False;
201 Handle(Geom_Curve) C;
202 Standard_Real Uf, Ul;
203 C = BRep_Tool::Curve(CP.Arc(),Uf,Ul);
204 C->D1(CP.ParameterOnArc(), P, Darc);
206 return Dsurf.IsParallel(Darc, TolAngular);
209 //=======================================================================
210 //function : BonVoisin
212 //=======================================================================
214 static Standard_Boolean BonVoisin(const gp_Pnt& Point,
215 Handle(BRepAdaptor_HSurface)& HS,
217 Handle(GeomAdaptor_HSurface)& plane,
218 const TopoDS_Edge& cured,
221 const ChFiDS_Map& EFMap,
222 const Standard_Real tolesp)
224 Standard_Boolean bonvoisin = 1;
225 Standard_Real winter, Uf, Ul;
226 gp_Pnt papp = HS->Value(XDep, YDep);
227 Standard_Real dist = RealLast();
228 Handle(BRepAdaptor_HCurve) hc = new BRepAdaptor_HCurve();
229 Handle(Geom2d_Curve) PC;
230 Standard_Boolean found = 0;
233 for(Ex.Init(F,TopAbs_EDGE); Ex.More(); Ex.Next()){
234 const TopoDS_Edge& ecur = TopoDS::Edge(Ex.Current());
235 if(!ecur.IsSame(cured)){
236 hc->ChangeCurve().Initialize(ecur);
237 Standard_Real tolc = hc->ChangeCurve().Resolution(tolesp);
238 if(ChFi3d_InterPlaneEdge(plane,hc,winter,1,tolc)){
239 gp_Pnt np = hc->Value(winter);
240 Standard_Real ndist = np.SquareDistance(papp);
242 TopTools_ListIteratorOfListOfShape It;
244 Standard_Boolean isclosed = BRep_Tool::IsClosed(ecur, F);
245 Standard_Boolean isreallyclosed =
246 BRepTools::IsReallyClosed(ecur, F);
247 for(It.Initialize(EFMap(ecur));It.More();It.Next()){
248 ff = TopoDS::Face(It.Value());
249 Standard_Boolean issame = ff.IsSame(F);
250 // Modified by Sergey KHROMOV - Fri Dec 21 17:12:48 2001 Begin
251 // Standard_Boolean istg =
252 // BRep_Tool::Continuity(ecur,ff,F) != GeomAbs_C0;
253 Standard_Boolean istg = ChFi3d_isTangentFaces(ecur,ff,F);
254 // Modified by Sergey KHROMOV - Fri Dec 21 17:12:51 2001 End
255 if((!issame || (issame && isreallyclosed)) && istg) {
257 TopoDS_Edge newe = ecur;
258 newe.Orientation(TopAbs_FORWARD);
260 HS->ChangeSurface().Initialize(ff);
261 if(isclosed && !isreallyclosed){
262 TopoDS_Face fff = ff;
263 fff.Orientation(TopAbs_FORWARD);
265 for(Ex2.Init(fff,TopAbs_EDGE);
266 Ex2.More(); Ex2.Next()){
267 if(newe.IsSame(Ex2.Current())){
268 newe = TopoDS::Edge(Ex2.Current());
269 PC = BRep_Tool::CurveOnSurface(newe,fff,Uf,Ul);
274 else PC = BRep_Tool::CurveOnSurface(newe,ff,Uf,Ul);
275 PC->Value(winter).Coord(XDep,YDep);
277 gp_Pnt spt; gp_Vec sdu,sdv,nors;
278 HS->D1(XDep, YDep, spt, sdu, sdv);
279 nors = sdu.Crossed(sdv);
280 gp_Pnt cpt; gp_Vec cd;
281 hc->D1(winter,cpt,cd);
282 gp_Vec vref(Point, cpt);
283 TopoDS_Face fff = ff;
284 fff.Orientation(TopAbs_FORWARD);
285 if(vref.Dot(nors.Crossed(cd)) < 0.){
286 newe.Orientation(TopAbs_REVERSED);
288 PC = BRep_Tool::CurveOnSurface(newe,fff,Uf,Ul);
289 PC->Value(winter).Coord(XDep, YDep);
298 if(!found) bonvoisin = 0;
302 //=======================================================================
303 //function : Projection
304 //purpose : Projects a point on a curve
305 //=======================================================================
307 static Standard_Boolean Projection(Extrema_ExtPC& PExt,
309 const Adaptor3d_Curve& C,
313 Standard_Real Dist2, daux2;
314 Dist2 = C.Value(W).SquareDistance(P);
316 // It is checked if it is not already a solution
317 if (Dist2 < Tol * Tol)
318 return Standard_True;
320 Standard_Boolean Ok = Standard_False;
322 // On essai une resolution initialise
323 Extrema_LocateExtPC ext(P,C,W,Tol/10);
325 daux2 = C.Value(ext.Point().Parameter()).SquareDistance(P);
327 W = ext.Point().Parameter();
330 if (Dist2 < Tol * Tol)
331 return Standard_True;
337 if ( PExt.IsDone() ) {
338 for (Standard_Integer ii=1; ii<= PExt.NbExt(); ii++) {
339 if (PExt.SquareDistance(ii) < Dist2) {
340 Dist2 = PExt.SquareDistance(ii);
341 W = PExt.Point(ii).Parameter();
349 //=======================================================================
352 //=======================================================================
354 static void TgtKP(const Handle(ChFiDS_SurfData)& CD,
355 const Handle(ChFiDS_Spine)& Spine,
356 const Standard_Integer iedge,
357 const Standard_Boolean isfirst,
361 Standard_Real wtg = CD->InterferenceOnS1().Parameter(isfirst);
362 const BRepAdaptor_Curve& bc = Spine->CurrentElementarySpine(iedge);
363 if(Spine->Edges(iedge).Orientation() == TopAbs_FORWARD)
364 bc.D1(wtg+bc.FirstParameter(),ped,ded);
366 bc.D1(-wtg+bc.LastParameter(),ped,ded);
372 //=======================================================================
374 //purpose : Checks if a vector belongs to a Face
375 //=======================================================================
377 Standard_Boolean IsInput(const gp_Vec& Vec,
378 const TopoDS_Vertex& Ve,
379 const TopoDS_Face& Fa)
381 TopExp_Explorer FaceExp(Fa, TopAbs_WIRE);
382 BRepTools_WireExplorer WireExp;
383 Standard_Integer Trouve = 0;
386 TopoDS_Vertex Vf, Vl;
390 // Find edges and compute 3D vectors
391 for ( ; (FaceExp.More() && (Trouve<2)); FaceExp.Next()) {
392 W = TopoDS::Wire(FaceExp.Current());
393 for (Trouve=0, WireExp.Init(W) ;
394 WireExp.More() && (Trouve<2); WireExp.Next()) {
395 E = TopoDS::Edge(WireExp.Current());
396 TopExp::Vertices(E, Vf, Vl);
398 BRepAdaptor_Curve Cb(E);
399 Cb.D1(BRep_Tool::Parameter(Ve, E), Point, Vec3d[Trouve]);
402 else if (Vl.IsSame(Ve)) {
403 BRepAdaptor_Curve Cb(E);
404 Cb.D1(BRep_Tool::Parameter(Ve, E), Point, Vec3d[Trouve]);
405 Vec3d[Trouve].Reverse();
410 if (Trouve < 2) return Standard_False;
411 // Calculate the normal and the angles in the asssociated vector plane
413 Normal = Vec3d[0] ^ Vec3d[1];
414 if (Normal.SquareMagnitude() < Precision::Confusion()) {//Colinear case
415 return (Vec.IsParallel(Vec3d[0],Precision::Confusion()));
418 Standard_Real amin, amax;
419 amax = Vec3d[1].AngleWithRef(Vec3d[0], Normal);
426 // Projection of the vector
427 gp_Ax3 Axe(Point, Normal, Vec3d[0]);
429 Transf.SetTransformation (Axe);
430 gp_XYZ coord = Vec.XYZ();
431 Transf.Transforms(coord);
434 Transf.Transforms(coord);
435 gp_Vec theProj(coord);
438 Standard_Real Angle = theProj.AngleWithRef(Vec3d[0], Normal);
439 return ( (Angle >= amin) && (Angle<=amax));
442 //=======================================================================
444 //purpose : Find a neighbor G1 by an edge
445 //=======================================================================
447 Standard_Boolean IsG1(const ChFiDS_Map& TheMap,
448 const TopoDS_Edge& E,
449 const TopoDS_Face& FRef,
452 TopTools_ListIteratorOfListOfShape It;
453 // Find a neighbor of E different from FRef (general case).
454 for(It.Initialize(TheMap(E));It.More();It.Next()) {
455 if (!TopoDS::Face(It.Value()).IsSame(FRef)) {
456 FVoi = TopoDS::Face(It.Value());
457 // Modified by Sergey KHROMOV - Fri Dec 21 17:09:32 2001 Begin
458 // if (BRep_Tool::Continuity(E,FRef,FVoi) != GeomAbs_C0) {
459 if (ChFi3d_isTangentFaces(E,FRef,FVoi)) {
460 // Modified by Sergey KHROMOV - Fri Dec 21 17:09:33 2001 End
461 return Standard_True;
465 // If is was not found it is checked if E is a cutting edge,
466 // in which case FVoi = FRef is returned (less frequent case).
468 Standard_Boolean orset = Standard_False;
469 TopAbs_Orientation orient = TopAbs_FORWARD ;
471 for(Ex.Init(FRef,TopAbs_EDGE); Ex.More(); Ex.Next()){
472 ed = TopoDS::Edge(Ex.Current());
474 if(!orset){ orient = ed.Orientation(); orset = Standard_True; }
475 else if(ed.Orientation() == TopAbs::Reverse(orient)){
477 // Modified by Sergey KHROMOV - Fri Dec 21 17:15:12 2001 Begin
478 // if (BRep_Tool::Continuity(E,FRef,FRef) >= GeomAbs_G1) {
479 if (ChFi3d_isTangentFaces(E,FRef,FRef)) {
480 // Modified by Sergey KHROMOV - Fri Dec 21 17:15:16 2001 End
481 return Standard_True;
483 return Standard_False;
487 return Standard_False;
490 //=======================================================================
491 //function : SearchFaceOnV
492 //purpose : Finds the output face(s) of the path by a vertex
493 // The following criteria should be followed
494 // -1 : The face shares regular edges with FRef
495 // (too hard condition that should be reconsidered)
496 // -2 : The vector starting in CommonPoint "belongs" to the face
497 //========================================================================
498 static Standard_Integer SearchFaceOnV(const ChFiDS_CommonPoint& Pc,
499 const TopoDS_Face& FRef,
500 const ChFiDS_Map& VEMap,
501 const ChFiDS_Map& EFMap,
505 // it is checked that it leaves the current face.
506 Standard_Boolean FindFace = IsInput(Pc.Vector(), Pc.Vertex(), FRef);
508 FindFace = IsInput(Pc.Vector().Reversed(), Pc.Vertex(), FRef);
510 // If it does not leave, it is finished
515 Standard_Integer Num = 0;
516 Standard_Boolean Trouve;
517 TopTools_ListIteratorOfListOfShape ItE, ItF;
521 for(ItE.Initialize(VEMap(Pc.Vertex()));
522 ItE.More() && (Num < 2); ItE.Next()) {
523 E = TopoDS::Edge(ItE.Value());
524 for(ItF.Initialize(EFMap(E)), Trouve=Standard_False;
525 ItF.More()&&(!Trouve); ItF.Next()) {
526 if (TopoDS::Face(ItF.Value()).IsSame(FRef)) {
527 Trouve = Standard_True;
530 if (Trouve) Trouve = IsG1(EFMap, E, FRef, FVoi);
531 if (Trouve) Trouve = IsInput(Pc.Vector(), Pc.Vertex(), FVoi);
533 if (Num == 0) F1 = FVoi;
541 //=======================================================================
542 //function : ChangeTransition
543 //purpose : Changes the transition of the second common Point, when the surface
544 // does not cross the arc
545 // As it is supposed that the support Faces are the same, it is enough
546 // to examine the cas of cutting edges.
547 //========================================================================
548 static void ChangeTransition(const ChFiDS_CommonPoint& Precedant,
549 ChFiDS_CommonPoint& Courant,
550 Standard_Integer FaceIndex,
551 const Handle(TopOpeBRepDS_HDataStructure)& DS)
553 Standard_Boolean tochange = Standard_True;
555 const TopoDS_Face& F = TopoDS::Face(DS->Shape(FaceIndex));
556 const TopoDS_Edge& Arc = Precedant.Arc();
557 Handle(Geom2d_Curve) PCurve1, PCurve2;
558 PCurve1 = BRep_Tool::CurveOnSurface(Arc, F, f, l);
559 TopoDS_Shape aLocalShape = Arc.Reversed();
560 PCurve2 = BRep_Tool::CurveOnSurface(TopoDS::Edge(aLocalShape), F, f, l);
561 // PCurve2 = BRep_Tool::CurveOnSurface(TopoDS::Edge(Arc.Reversed()), F, f, l);
562 if (PCurve1 != PCurve2) {
563 // This is a cutting edge, it is necessary to make a small Geometric test
566 BRepAdaptor_Curve AC(Arc);
567 AC.D1(Precedant.ParameterOnArc(), P, tgarc);
568 tochange = tgarc.IsParallel(Precedant.Vector(), Precision::Confusion());
572 Courant.SetArc(Precision::Confusion(),
574 Precedant.ParameterOnArc(),
575 TopAbs::Reverse(Precedant.TransitionOnArc()));
579 //=======================================================================
580 //function : CallPerformSurf
581 //purpose : Encapsulates call to PerformSurf/SimulSurf
582 //========================================================================
584 void ChFi3d_Builder::
585 CallPerformSurf(Handle(ChFiDS_Stripe)& Stripe,
586 const Standard_Boolean Simul,
587 ChFiDS_SequenceOfSurfData& SeqSD,
588 Handle(ChFiDS_SurfData)& SD,
589 const Handle(ChFiDS_HElSpine)& HGuide,
590 const Handle(ChFiDS_Spine)& Spine,
591 const Handle(BRepAdaptor_HSurface)& HS1,
592 const Handle(BRepAdaptor_HSurface)& HS3,
595 const Handle(Adaptor3d_TopolTool)& It1,
596 const Handle(BRepAdaptor_HSurface)& HS2,
597 const Handle(BRepAdaptor_HSurface)& HS4,
600 const Handle(Adaptor3d_TopolTool)& It2,
601 const Standard_Real MaxStep,
602 const Standard_Real Fleche,
603 const Standard_Real /*TolGuide*/,
604 Standard_Real& First,
606 const Standard_Boolean Inside,
607 const Standard_Boolean /*Appro*/,
608 const Standard_Boolean forward,
609 const Standard_Boolean RecOnS1,
610 const Standard_Boolean RecOnS2,
612 Standard_Boolean& intf,
613 Standard_Boolean& intl,
614 Handle(BRepAdaptor_HSurface)& Surf1,
615 Handle(BRepAdaptor_HSurface)& Surf2)
620 Handle(BRepAdaptor_HSurface) HSon1, HSon2;
623 // Definition of the domain of path It1, It2
624 It1->Initialize((const Handle(Adaptor3d_HSurface)&)HSon1);
625 It2->Initialize((const Handle(Adaptor3d_HSurface)&)HSon2);
628 TopAbs_Orientation Or1 = HS1->ChangeSurface().Face().Orientation();
629 TopAbs_Orientation Or2 = HS2->ChangeSurface().Face().Orientation();
630 Standard_Integer Choix =
631 ChFi3d::NextSide(Or1,Or2,
632 Stripe->OrientationOnFace1(),
633 Stripe->OrientationOnFace2(),
635 Soldep(1) = pp1.X(); Soldep(2) = pp1.Y();
636 Soldep(3) = pp2.X(); Soldep(4) = pp2.Y();
638 Standard_Real thef = First, thel = Last;
639 Standard_Boolean isdone;
642 isdone = SimulSurf(SD,HGuide,Spine,Choix,HS1,It1,HS2,It2,tolesp,First,Last,
643 Inside,Inside,forward,RecOnS1,RecOnS2,Soldep,intf,intl);
648 ChFi3d_InitChron(ch1);//initial perform for PerformSurf
651 isdone = PerformSurf(SeqSD,HGuide,Spine,Choix,HS1,It1,HS2,It2,
652 MaxStep,Fleche,tolesp,
653 First,Last,Inside,Inside,forward,
654 RecOnS1,RecOnS2,Soldep,intf,intl);
656 ChFi3d_ResultChron(ch1,t_performsurf);// result perf for PerformSurf
664 Standard_Boolean reprise = Standard_False;
665 if (! HS3.IsNull()) {
667 It1->Initialize((const Handle(Adaptor3d_HSurface)&)HS3);
668 Or1 = HS3->ChangeSurface().Face().Orientation();
669 Soldep(1) = pp3.X(); Soldep(2) = pp3.Y();
670 reprise = Standard_True;
672 else if (! HS4.IsNull()) {
674 It2->Initialize((const Handle(Adaptor3d_HSurface)&)HS4);
675 Or2 = HS4->ChangeSurface().Face().Orientation();
676 Soldep(3) = pp4.X(); Soldep(4) = pp4.Y();
677 reprise = Standard_True;
681 Choix = ChFi3d::NextSide(Or1,Or2,
682 Stripe->OrientationOnFace1(),
683 Stripe->OrientationOnFace2(),
686 isdone = SimulSurf(SD,HGuide,Spine,Choix,HSon1,It1,HSon2,It2,
688 Inside,Inside,forward,RecOnS1,RecOnS2,
694 ChFi3d_InitChron(ch1);//init perf for PerformSurf
697 isdone = PerformSurf(SeqSD,HGuide,Spine,Choix,HSon1,It1,HSon2,It2,
698 MaxStep,Fleche,tolesp,
699 First,Last,Inside,Inside,forward,
700 RecOnS1,RecOnS2,Soldep,intf,intl);
702 ChFi3d_ResultChron(ch1,t_performsurf);// result perf for PerformSurf
711 //=======================================================================
712 //function : StripeOrientation
713 //purpose : Calculates the reference orientation determining the
714 // concave face for construction of the fillet.
715 //=======================================================================
717 Standard_Boolean ChFi3d_Builder::StripeOrientations
718 (const Handle(ChFiDS_Spine)& Spine,
719 TopAbs_Orientation& Or1,
720 TopAbs_Orientation& Or2,
721 Standard_Integer& ChoixConge) const
723 //TopTools_ListIteratorOfListOfShape It;
724 BRepAdaptor_Surface Sb1,Sb2;
725 TopAbs_Orientation Of1,Of2;
727 ChFi3d_conexfaces(Spine->Edges(1),ff1,ff2,myEFMap);
728 Of1 = ff1.Orientation();
729 ff1.Orientation(TopAbs_FORWARD);
731 Of2 = ff2.Orientation();
732 ff2.Orientation(TopAbs_FORWARD);
735 ChoixConge = ChFi3d::ConcaveSide(Sb1,Sb2,Spine->Edges(1),
737 Or1 = TopAbs::Compose(Or1,Of1);
738 Or2 = TopAbs::Compose(Or2,Of2);
739 return Standard_True;
743 //=======================================================================
744 //function : ConexFaces
746 //=======================================================================
748 void ChFi3d_Builder::ConexFaces (const Handle(ChFiDS_Spine)& Spine,
749 const Standard_Integer IEdge,
750 const Standard_Integer RC,
751 Handle(BRepAdaptor_HSurface)& HS1,
752 Handle(BRepAdaptor_HSurface)& HS2) const
754 if(HS1.IsNull()) HS1 = new BRepAdaptor_HSurface ();
755 if(HS2.IsNull()) HS2 = new BRepAdaptor_HSurface ();
756 BRepAdaptor_Surface& Sb1 = HS1->ChangeSurface();
757 BRepAdaptor_Surface& Sb2 = HS2->ChangeSurface();
760 ChFi3d_conexfaces(Spine->Edges(IEdge),ff1,ff2,myEFMap);
765 TopAbs_Orientation Or1,Or2;
766 Standard_Integer Choix = ChFi3d::ConcaveSide(Sb1,Sb2,Spine->Edges(IEdge),
768 if (RC%2 != Choix%2) {
774 //=======================================================================
775 //function : StartSol
776 //purpose : Calculates a starting solution :
777 // - one starts by parsing about ten points on the spine,
778 // - in case of fail one finds the solution on neighbor faces;
779 // section plane of edges of the adjacent face
780 // and identication of the face by connection to that edge.
781 //=======================================================================
783 void ChFi3d_Builder::StartSol(const Handle(ChFiDS_Stripe)& Stripe,
784 const Handle(ChFiDS_HElSpine)& HGuide,
785 Handle(BRepAdaptor_HSurface)& HS1,
786 Handle(BRepAdaptor_HSurface)& HS2,
787 Handle(BRepTopAdaptor_TopolTool)& I1,
788 Handle(BRepTopAdaptor_TopolTool)& I2,
791 Standard_Real& First) const
793 Handle(ChFiDS_Spine)& Spine = Stripe->ChangeSpine();
794 ChFiDS_ElSpine& els = HGuide->ChangeCurve();
795 Standard_Integer nbed = Spine->NbEdges();
796 Standard_Integer nbessaimax = 3*nbed;
797 if (nbessaimax < 10) nbessaimax = 10;
798 Standard_Real unsurnbessaimax = 1./nbessaimax;
799 Standard_Real wf = 0.9981 * Spine->FirstParameter(1) +
800 0.0019 * Spine->LastParameter(1);
801 Standard_Real wl = 0.9973 * Spine->LastParameter(nbed) +
802 0.0027 * Spine->FirstParameter(nbed);
804 Standard_Real TolE = 1.0e-7;
805 BRepAdaptor_Surface AS;
807 Standard_Integer nbessai;
808 Standard_Integer iedge = 0;
809 Standard_Integer RC = Stripe->Choix();
814 TopAbs_Orientation Or1,Or2;
815 Standard_Integer Choix = 0;
816 math_Vector SolDep(1,4);
817 Handle(Geom2d_Curve) PC;
820 Spine->FirstParameter(1),
821 Spine->LastParameter(nbed),
822 Precision::Confusion());
823 TopAbs_State Pos1,Pos2;
824 for(nbessai = 0; nbessai <= nbessaimax; nbessai++){
825 Standard_Real t = nbessai*unsurnbessaimax;
826 Standard_Real w = wf * (1. -t) + wl * t;
827 Standard_Integer ie = Spine->Index(w);
830 cured = Spine->Edges(iedge);
831 TolE = BRep_Tool::Tolerance(cured);
832 ConexFaces(Spine,iedge,RC,HS1,HS2);
833 f1 = HS1->ChangeSurface().Face();
834 f2 = HS2->ChangeSurface().Face();
835 Or1 = f1.Orientation();
836 Or2 = f2.Orientation();
837 Choix = ChFi3d::NextSide(Or1,Or2,
838 Stripe->OrientationOnFace1(),
839 Stripe->OrientationOnFace2(),
843 Standard_Real woned,Uf,Ul, ResU, ResV;
844 Spine->Parameter(iedge,w,woned,Standard_True);
845 cured.Orientation(TopAbs_FORWARD);
846 TopoDS_Face f1forward = f1, f2forward = f2;
847 f1forward.Orientation(TopAbs_FORWARD);
848 f2forward.Orientation(TopAbs_FORWARD);
849 PC = BRep_Tool::CurveOnSurface(cured,f1forward,Uf,Ul);
850 I1->Initialize((const Handle(Adaptor3d_HSurface)&)HS1);
851 PC->D1(woned, P1, derive);
852 // There are ponts on the border, and internal points are found
853 if (derive.Magnitude() > Precision::PConfusion()) {
855 derive.Rotate(M_PI/2);
857 ResU = AS.UResolution(TolE);
858 ResV = AS.VResolution(TolE);
859 derive *= 2*(Abs(derive.X())*ResU + Abs(derive.Y())*ResV);
860 P2d = P1.Translated(derive);
861 if (I1->Classify(P2d, Min(ResU, ResV), 0)== TopAbs_IN) {
865 P2d = P1.Translated(-derive);
866 if (I1->Classify(P2d, Min(ResU, ResV), 0)== TopAbs_IN) {
871 if(f1.IsSame(f2)) cured.Orientation(TopAbs_REVERSED);
872 PC = BRep_Tool::CurveOnSurface(cured,f2forward,Uf,Ul);
873 P2 = PC->Value(woned);
874 const Handle(Adaptor3d_HSurface)& HSon2 = HS2; // to avoid ambiguity
875 I2->Initialize(HSon2);
877 SolDep(1) = P1.X(); SolDep(2) = P1.Y();
878 SolDep(3) = P2.X(); SolDep(4) = P2.Y();
879 const BRepAdaptor_Curve& Ced = Spine->CurrentElementarySpine(iedge);
880 gp_Pnt pnt = Ced.Value(woned);
882 if (Projection(PExt, pnt, els, w, tolesp) &&
883 PerformFirstSection(Spine,HGuide,Choix,HS1,HS2,
884 I1,I2,w,SolDep,Pos1,Pos2)) {
885 P1.SetCoord(SolDep(1),SolDep(2));
886 P2.SetCoord(SolDep(3),SolDep(4));
891 // No solution was found for the faces adjacent to the trajectory.
892 // Now one tries the neighbor faces.
894 for(nbessai = 0; nbessai <= nbessaimax; nbessai++){
895 Standard_Real t = nbessai*unsurnbessaimax;
896 Standard_Real w = wf * (1. -t) + wl * t;
897 iedge = Spine->Index(w);
898 cured = Spine->Edges(iedge);
899 ConexFaces(Spine,iedge,RC,HS1,HS2);
900 f1 = HS1->ChangeSurface().Face();
901 f2 = HS2->ChangeSurface().Face();
902 Or1 = f1.Orientation();
903 Or2 = f2.Orientation();
904 Choix = ChFi3d::NextSide(Or1,Or2,
905 Stripe->OrientationOnFace1(),
906 Stripe->OrientationOnFace2(),
908 Standard_Real woned,Uf,Ul;
909 Spine->Parameter(iedge,w,woned,Standard_True);
910 TopoDS_Face f1forward = f1, f2forward = f2;
911 f1forward.Orientation(TopAbs_FORWARD);
912 f2forward.Orientation(TopAbs_FORWARD);
913 PC = BRep_Tool::CurveOnSurface(cured,f1forward,Uf,Ul);
914 P1 = PC->Value(woned);
915 PC = BRep_Tool::CurveOnSurface(cured,f2forward,Uf,Ul);
916 P2 = PC->Value(woned);
917 const Handle(Adaptor3d_HSurface)& HSon1 = HS1; // to avoid ambiguity
918 const Handle(Adaptor3d_HSurface)& HSon2 = HS2; // to avoid ambiguity
919 I1->Initialize(HSon1);
920 I2->Initialize(HSon2);
921 SolDep(1) = P1.X(); SolDep(2) = P1.Y();
922 SolDep(3) = P2.X(); SolDep(4) = P2.Y();
923 const BRepAdaptor_Curve& Ced = Spine->CurrentElementarySpine(iedge);
924 gp_Pnt pnt = Ced.Value(woned);
925 // Extrema_LocateExtPC ext(pnt,els,w,1.e-8);
927 // w = ext.Point().Parameter();
928 if (Projection(PExt, pnt, els, w, tolesp)) {
929 PerformFirstSection(Spine,HGuide,Choix,HS1,HS2,
930 I1,I2,w,SolDep,Pos1,Pos2);
934 Handle(Geom_Plane) pl = new Geom_Plane(P,V);
935 Handle(GeomAdaptor_HSurface) plane = new GeomAdaptor_HSurface(pl);
937 Standard_Boolean bonvoisin = 1, found = 0;
938 Standard_Integer NbChangement;
939 for (NbChangement = 1; bonvoisin && (!found) && (NbChangement < 5);
941 if(Pos1 != TopAbs_IN){
942 bonvoisin = BonVoisin(P, HS1, f1, plane, cured,
943 SolDep(1),SolDep(2), myEFMap, tolesp);
945 if(Pos2 != TopAbs_IN && bonvoisin){
946 bonvoisin = BonVoisin(P, HS2, f2, plane, cured,
947 SolDep(3),SolDep(4), myEFMap, tolesp);
950 f1 = HS1->ChangeSurface().Face();
951 f2 = HS2->ChangeSurface().Face();
952 Or1 = f1.Orientation();
953 Or2 = f2.Orientation();
954 Choix = ChFi3d::NextSide(Or1,Or2,
955 Stripe->OrientationOnFace1(),
956 Stripe->OrientationOnFace2(),
958 const Handle(Adaptor3d_HSurface)& HSon1new = HS1; // to avoid ambiguity
959 const Handle(Adaptor3d_HSurface)& HSon2new = HS2; // to avoid ambiguity
960 I1->Initialize(HSon1new);
961 I2->Initialize(HSon2new);
962 if(PerformFirstSection(Spine,HGuide,Choix,HS1,HS2,
963 I1,I2,w,SolDep,Pos1,Pos2)){
964 P1.SetCoord(SolDep(1),SolDep(2));
965 P2.SetCoord(SolDep(3),SolDep(4));
967 found = Standard_True;
974 Spine->SetErrorStatus(ChFiDS_StartsolFailure);
975 Standard_Failure::Raise("StartSol echec");
978 //=======================================================================
979 //function : ChFi3d_BuildPlane
981 //=======================================================================
983 static void ChFi3d_BuildPlane (TopOpeBRepDS_DataStructure& DStr,
984 Handle(BRepAdaptor_HSurface)& HS,
986 const Handle(ChFiDS_SurfData)& SD,
987 const Standard_Boolean isfirst,
988 const Standard_Integer ons)
990 Handle(Geom2d_Curve) Hc;
991 TopoDS_Face F = TopoDS::Face(DStr.Shape(SD->Index(ons)));
996 if (SD->Vertex(isfirst,ons).IsOnArc()){
997 Hc = BRep_Tool::CurveOnSurface
998 (SD->Vertex(isfirst,ons).Arc(),F,u,v);
999 Hc->Value(SD->Vertex(isfirst,ons).ParameterOnArc()).Coord(u,v);
1000 BRepLProp_SLProps theProp(HS->ChangeSurface(), u, v, 1, 1.e-12);
1001 if (theProp.IsNormalDefined()) {
1002 P = theProp.Value();
1003 Handle(Geom_Plane) Pln = new Geom_Plane(P, theProp.Normal());
1004 TopoDS_Face NewF = BRepLib_MakeFace(Pln, Precision::Confusion());
1005 NewF.Orientation(F.Orientation());
1006 pons.SetCoord(0.,0.);
1007 HS->ChangeSurface().Initialize(NewF);
1008 return; // everything is good !
1011 Standard_Failure::Raise("ChFi3d_BuildPlane : echec .");
1014 //=======================================================================
1015 //function : StartSol
1016 //purpose : If the commonpoint is not OnArc the input face
1017 // is returned and 2D point is updated,
1019 // if it is detached the input face
1020 // is returned and 2D point is updated,
1022 // either there is a neighbor tangent face and it is returned
1023 // with recalculated 2D point
1024 // or if there is no face
1025 // if the reference arc is Vref (extremity of the spine)
1026 // this is the end and the input face is returned
1027 // otherwise this is an obstacle and HC is updated.
1028 //=======================================================================
1031 ChFi3d_Builder::StartSol(const Handle(ChFiDS_Spine)& Spine,
1032 Handle(BRepAdaptor_HSurface)& HS, // New face
1033 gp_Pnt2d& pons,// " Localization
1034 Handle(BRepAdaptor_HCurve2d)& HC, // Representation of the obstacle
1036 const Handle(ChFiDS_SurfData)& SD,
1037 const Standard_Boolean isfirst,
1038 const Standard_Integer ons,
1039 Handle(BRepAdaptor_HSurface)& HSref, // The other representation
1040 Handle(BRepAdaptor_HCurve2d)& HCref, // of the obstacle
1041 Standard_Boolean& RecP,
1042 Standard_Boolean& RecS,
1043 Standard_Boolean& RecRst,
1044 Standard_Boolean& c1obstacle,
1045 Handle(BRepAdaptor_HSurface)& HSBis, // Face of support
1046 gp_Pnt2d& PBis, // and its point
1047 const Standard_Boolean decroch,
1048 const TopoDS_Vertex& Vref) const
1050 RecRst = RecS = RecP = c1obstacle = 0;
1051 TopOpeBRepDS_DataStructure& DStr = myDS->ChangeDS();
1052 TopoDS_Face Fv,Fref;
1054 Handle(Geom2d_Curve) pc;
1055 Standard_Real Uf,Ul;
1057 TopoDS_Face F = TopoDS::Face(DStr.Shape(SD->Index(ons)));
1058 if(!HSref.IsNull()) Fref = HSref->ChangeSurface().Face();
1059 const ChFiDS_CommonPoint& CP = SD->Vertex(isfirst,ons);
1063 Standard_Integer notons;
1064 if (ons == 1) notons = 2;
1066 const ChFiDS_CommonPoint& CPbis = SD->Vertex(isfirst,notons);
1067 if (CPbis.IsOnArc()) { // It is checked if it is not the extension zone
1068 // In case CP is not at the end of surfdata and it is not necesary to take it into account
1069 // except for separate cases (ie pointus) ...
1070 //ts and tns were earlier CP.Parameter() and CPbis.Parameter, but sometimes they had no values.
1071 Standard_Real ts=SD->Interference(ons).Parameter(isfirst), tns=SD->Interference(notons).Parameter(isfirst);
1072 Standard_Boolean isExtend;
1073 // Arbitrary test (to precise)
1074 if (isfirst) isExtend = (ts-tns > 100*tolesp);
1075 else isExtend = (tns-ts > 100*tolesp);
1076 if (isExtend && !CP.Point().IsEqual(CPbis.Point(), 0) ) {
1077 // the state is preserved and False is returned (extension by the expected plane).
1078 HS->ChangeSurface().Initialize(F);
1079 pc = SD->Interference(ons).PCurveOnFace();
1080 // The 2nd point is given by its trace on the support surface
1081 RecS = Standard_False;
1082 pons = pc->Value(tns);
1083 return Standard_False;
1088 if (CP.IsVertex() && !HC.IsNull() && !decroch){
1089 //The edge is changed, the parameter is updated and
1090 //eventually the support face and(or) the reference face.
1091 TopoDS_Vertex VCP = CP.Vertex();
1092 TopoDS_Edge EHC = HC->ChangeCurve2d().Edge();
1093 //One starts by searching in Fref another edge referencing VCP.
1094 TopExp_Explorer ex1,ex2;
1095 TopoDS_Edge newedge, edgereg;
1096 TopoDS_Face bidface = Fref, facereg;
1097 bidface.Orientation(TopAbs_FORWARD);
1098 for(ex1.Init(bidface,TopAbs_EDGE); ex1.More(); ex1.Next()){
1099 const TopoDS_Edge& cured = TopoDS::Edge(ex1.Current());
1100 Standard_Boolean found = 0;
1101 if(!cured.IsSame(EHC)){
1102 for(ex2.Init(cured,TopAbs_VERTEX); ex2.More() && !found; ex2.Next()){
1103 if(ex2.Current().IsSame(VCP)){
1104 if(IsG1(myEFMap,cured,Fref,Fv)){
1117 if(newedge.IsNull()){
1118 //It is checked if EHC is not a closed edge.
1119 TopoDS_Vertex V1,V2;
1120 TopExp::Vertices(EHC,V1,V2);
1123 Standard_Real w1 = BRep_Tool::Parameter(V1,EHC);
1124 Standard_Real w2 = BRep_Tool::Parameter(V2,EHC);
1125 const ChFiDS_FaceInterference& fi = SD->Interference(ons);
1126 const Handle(Geom2d_Curve)& pcf = fi.PCurveOnFace();
1127 Standard_Real ww = fi.Parameter(isfirst);
1130 if(!pcf.IsNull()) pww = pcf->Value(ww);
1131 else pww = SD->Get2dPoints(isfirst,ons);
1132 gp_Pnt2d p1 = HC->Value(w1);
1133 gp_Pnt2d p2 = HC->Value(w2);
1135 if(p1.Distance(pww) > p2.Distance(pww)){
1143 RecP = c1obstacle = 1;
1146 else if(!edgereg.IsNull()){
1147 // the reference edge and face are changed.
1149 HSref->ChangeSurface().Initialize(Fref);
1150 for(ex1.Init(facereg,TopAbs_EDGE); ex1.More() && newedge.IsNull(); ex1.Next()){
1151 const TopoDS_Edge& cured = TopoDS::Edge(ex1.Current());
1152 if(!cured.IsSame(edgereg)){
1153 for(ex2.Init(cured,TopAbs_VERTEX); ex2.More(); ex2.Next()){
1154 if(ex2.Current().IsSame(VCP)){
1155 if(!IsG1(myEFMap,cured,Fref,Fv)){
1164 // it is necessary to find the new support face of the fillet :
1165 // connected to FRef along the newedge.
1166 if(newedge.IsNull()) {
1167 Standard_Failure::Raise
1168 ("StartSol : chain is not possible, new obstacle not found");
1170 if(IsG1(myEFMap,newedge,Fref,Fv)){
1171 Standard_Failure::Raise
1172 ("StartSol : chain is not possible, config non processed");
1174 else if(Fv.IsNull()){
1175 Standard_Failure::Raise
1176 ("StartSol : chain is not possible, new obstacle not found");
1179 HS->ChangeSurface().Initialize(Fv);
1180 W = BRep_Tool::Parameter(VCP,newedge);
1181 HCref->ChangeCurve2d().Initialize(newedge,Fref);
1182 TopoDS_Face newface = Fv;
1183 newface.Orientation(TopAbs_FORWARD);
1185 for(ex.Init(newface,TopAbs_EDGE); ex.More(); ex.Next()){
1186 if(ex.Current().IsSame(newedge)){
1187 newedge = TopoDS::Edge(ex.Current());
1191 HC->ChangeCurve2d().Initialize(newedge,Fv);
1192 pons = HC->Value(W);
1194 RecP = c1obstacle = 1;
1196 } // End of Case Vertex && Obstacle
1198 else if (CP.IsOnArc() && !HC.IsNull() && !decroch){
1199 //Nothing is changed, the parameter is only updated.
1200 W = CP.ParameterOnArc();
1208 const TopoDS_Edge& E = CP.Arc();
1210 HS->ChangeSurface().Initialize(Fref);
1211 W = CP.ParameterOnArc();
1212 pc = BRep_Tool::CurveOnSurface(E,Fref,Uf,Ul);
1213 pons = pc->Value(W);
1217 if (SearchFace(Spine,CP,F,Fv)){
1218 HS->ChangeSurface().Initialize(Fv);
1220 if (CP.IsVertex()) {
1221 // One goes directly by the Vertex
1222 Standard_Integer Nb;
1224 // And it is checked that there are no other candidates
1225 Nb = SearchFaceOnV(CP, F, myVEMap, myEFMap, Fv, aux);
1227 pons = BRep_Tool::Parameters(CP.Vertex(), Fv);
1228 HS->ChangeSurface().Initialize(Fv);
1230 HSBis = new (BRepAdaptor_HSurface)(aux);
1231 PBis = BRep_Tool::Parameters(CP.Vertex(), aux);
1235 // otherwise one passes by the arc...
1237 Fv.Orientation(TopAbs_FORWARD);
1238 TopoDS_Edge newedge;
1240 for(ex.Init(Fv,TopAbs_EDGE); ex.More(); ex.Next()){
1241 if(ex.Current().IsSame(E)){
1242 newedge = TopoDS::Edge(ex.Current());
1246 //gp_Vec Varc, VSurf;
1247 // In cas of Tangent output, the current face becomes the support face
1248 if (SortieTangente(CP, F, SD, ons, 0.1)) {
1249 pc = BRep_Tool::CurveOnSurface(CP.Arc(),F,Uf,Ul);
1250 HSBis = new (BRepAdaptor_HSurface)(F);
1251 PBis = pc->Value(CP.ParameterOnArc());
1255 pc = BRep_Tool::CurveOnSurface(newedge,Fv,Uf,Ul);
1258 TopoDS_Edge newedge = E;
1260 Fv.Orientation(TopAbs_FORWARD);
1261 pc = BRep_Tool::CurveOnSurface(newedge,Fv,Uf,Ul);
1263 pons = pc->Value(CP.ParameterOnArc());
1266 else if(!Fv.IsNull()){
1270 for(ex.Init(E,TopAbs_VERTEX); ex.More(); ex.Next()){
1271 if(ex.Current().IsSame(Vref)){
1278 HS->ChangeSurface().Initialize(Fv);
1279 HSref->ChangeSurface().Initialize(F);
1280 W = CP.ParameterOnArc();
1281 HC = new BRepAdaptor_HCurve2d();
1282 TopoDS_Edge newedge;
1283 TopoDS_Face newface = Fv;
1284 newface.Orientation(TopAbs_FORWARD);
1286 for(ex.Init(newface,TopAbs_EDGE); ex.More(); ex.Next()){
1287 if(ex.Current().IsSame(E)){
1288 newedge = TopoDS::Edge(ex.Current());
1292 HC->ChangeCurve2d().Initialize(newedge,Fv);
1293 pons = HC->Value(W);
1294 HCref->ChangeCurve2d().Initialize(E,F);
1295 if(CP.IsVertex()) RecP = 1;
1300 HS->ChangeSurface().Initialize(F);
1301 W = CP.ParameterOnArc();
1302 pc = BRep_Tool::CurveOnSurface(E,F,Uf,Ul);
1303 pons = pc->Value(W);
1304 return Standard_False;
1307 else{ // there is no neighbor face, the state is preserved and False is returned.
1308 HS->ChangeSurface().Initialize(F);
1309 W = CP.ParameterOnArc();
1310 pc = BRep_Tool::CurveOnSurface(E,F,Uf,Ul);
1311 pons = pc->Value(W);
1312 return Standard_False;
1316 HS->ChangeSurface().Initialize(F);
1317 const ChFiDS_FaceInterference& FI = SD->Interference(ons);
1318 if(FI.PCurveOnFace().IsNull()) pons = SD->Get2dPoints(isfirst,ons);
1319 else pons = FI.PCurveOnFace()->Value(FI.Parameter(isfirst));
1321 return Standard_True;
1324 //=======================================================================
1325 //function : SearchFace
1327 //=======================================================================
1329 Standard_Boolean ChFi3d_Builder::SearchFace
1330 (const Handle(ChFiDS_Spine)& Spine,
1331 const ChFiDS_CommonPoint& Pc,
1332 const TopoDS_Face& FRef,
1333 TopoDS_Face& FVoi) const
1335 Standard_Boolean Trouve = Standard_False;
1336 if (! Pc.IsOnArc()) return Standard_False;
1340 // attention it is necessary to analyze all faces that turn around of the vertex
1342 cout<<"Commonpoint on vertex, the process hangs up"<<endl;
1344 if (Pc.HasVector()) { //General processing
1346 Standard_Integer nb_faces;
1347 nb_faces = SearchFaceOnV(Pc, FRef, myVEMap, myEFMap, FVoi, Fbis);
1348 return ( nb_faces > 0);
1350 else { // Processing using the spine
1351 Standard_Boolean FindFace=Standard_False;
1354 Spine->D1(Pc.Parameter(), Point, VecSpine);
1356 // It is checked if one leaves from the current face.
1357 FindFace = IsInput(VecSpine, Pc.Vertex(), FRef);
1360 FindFace = IsInput(VecSpine, Pc.Vertex(), FRef);
1362 // If one does not leave, it is ended
1365 return Standard_True;
1368 // Otherwise one finds the next among shared Faces
1369 // by a common edge G1
1370 TopTools_ListIteratorOfListOfShape ItE, ItF;
1371 for(ItE.Initialize(myVEMap(Pc.Vertex()));
1372 ItE.More() && (!FindFace); ItE.Next()) {
1373 E = TopoDS::Edge(ItE.Value());
1374 Trouve=Standard_False;
1375 for(ItF.Initialize(myEFMap(E));//, Trouve=Standard_False; 15.11.99 SVV
1376 ItF.More()&&(!Trouve); ItF.Next()) {
1377 if (TopoDS::Face(ItF.Value()).IsSame(FRef)) {
1378 Trouve = Standard_True;
1381 if (Trouve) FindFace = IsG1(myEFMap, E, FRef, FVoi);
1383 FindFace = Standard_False;
1384 if (Spine.IsNull()) {
1385 //La Spine peut etre nulle (ThreeCorner)
1387 cout << "FindFace sur vertex avec spine nulle! QUEZAKO ?" << endl;
1389 return Standard_False;
1392 // It is checked if the selected face actually possesses edges of the spine
1393 // containing the vertex on its front
1394 // This processing should go only if the Vertex belongs to the spine
1395 // This is a single case, for other vertexes it is required to do other things
1396 Trouve=Standard_False;
1397 for (Standard_Integer IE=1;//, Trouve=Standard_False; 15.11.99 SVV
1398 (IE<=Spine->NbEdges()) && (!Trouve); IE++) {
1399 E = Spine->Edges(IE);
1400 if ( (TopExp::FirstVertex(E).IsSame(Pc.Vertex()))
1401 ||(TopExp::LastVertex(E) .IsSame(Pc.Vertex())) ) {
1402 for(ItF.Initialize(myEFMap(E)), Trouve=Standard_False;
1403 ItF.More()&&(!Trouve); ItF.Next()) {
1404 if (TopoDS::Face(ItF.Value()).IsSame(FVoi)) {
1405 Trouve = Standard_True;
1416 return IsG1(myEFMap, Pc.Arc(), FRef, FVoi);
1418 return Standard_False;
1422 //=======================================================================
1423 //function : ChFi3d_SingularExtremity
1424 //purpose : load the vertex in the DS and calculate the pcurve
1425 // for an extremity in case of singular freeboundary
1426 // or periodic and singular at the cut.
1427 //=======================================================================
1428 static void ChFi3d_SingularExtremity( Handle(ChFiDS_Stripe)& stripe,
1429 TopOpeBRepDS_DataStructure& DStr,
1430 const TopoDS_Vertex& Vtx,
1431 const Standard_Real tol3d,
1432 const Standard_Real tol2d)
1434 Handle(ChFiDS_SurfData) Fd;
1435 Standard_Real tolreached;
1436 Standard_Real Pardeb, Parfin;
1437 gp_Pnt2d VOnS1, VOnS2;
1438 Handle(Geom_Curve) C3d;
1439 Handle(Geom2d_Curve) PCurv;
1440 TopOpeBRepDS_Curve Crv;
1441 // SurfData and its CommonPoints,
1442 Standard_Integer Ivtx, Icurv;
1443 Standard_Boolean isfirst;
1445 if (stripe->Spine()->IsPeriodic()) {
1446 isfirst = Standard_True;
1447 Fd = stripe->SetOfSurfData()->Sequence().First();
1450 Standard_Integer sens;
1451 Standard_Integer num = ChFi3d_IndexOfSurfData(Vtx,stripe,sens);
1452 Fd = stripe->SetOfSurfData()->Sequence().Value(num);
1453 isfirst = (sens == 1);
1456 const ChFiDS_CommonPoint& CV1 = Fd->Vertex(isfirst,1);
1457 const ChFiDS_CommonPoint& CV2 = Fd->Vertex(isfirst,2);
1458 // Is it always degenerated ?
1459 if ( CV1.Point().IsEqual( CV2.Point(), 0) ) {
1460 Ivtx = ChFi3d_IndexPointInDS(CV1, DStr);
1462 VOnS1 = Fd->InterferenceOnS1().PCurveOnSurf()->
1463 Value(Fd->InterferenceOnS1().FirstParameter());
1464 VOnS2 = Fd->InterferenceOnS2().PCurveOnSurf()->
1465 Value(Fd->InterferenceOnS2().FirstParameter());
1468 VOnS1 = Fd->InterferenceOnS1().PCurveOnSurf()->
1469 Value(Fd->InterferenceOnS1().LastParameter());
1470 VOnS2 = Fd->InterferenceOnS2().PCurveOnSurf()->
1471 Value(Fd->InterferenceOnS2().LastParameter());
1474 ChFi3d_ComputeArete(CV1, VOnS1,
1476 DStr.Surface(Fd->Surf()).Surface(),
1478 Pardeb,Parfin, tol3d, tol2d, tolreached,0);
1479 Crv = TopOpeBRepDS_Curve(C3d,tolreached);
1480 Icurv = DStr.AddCurve(Crv);
1482 stripe->SetCurve(Icurv, isfirst);
1483 stripe->SetParameters(isfirst, Pardeb,Parfin);
1484 stripe->ChangePCurve(isfirst) = PCurv;
1485 stripe->SetIndexPoint(Ivtx, isfirst, 1);
1486 stripe->SetIndexPoint(Ivtx, isfirst, 2);
1488 if (stripe->Spine()->IsPeriodic()) {
1489 // periodic case : The operation is renewed
1490 // the curve 3d is not shared.
1491 // 2 degenerated edges coinciding in 3d
1492 isfirst = Standard_False;
1493 Fd = stripe->SetOfSurfData()->Sequence().Last();
1494 VOnS1 = Fd->InterferenceOnS1().PCurveOnSurf()->
1495 Value(Fd->InterferenceOnS1().LastParameter());
1496 VOnS2 = Fd->InterferenceOnS2().PCurveOnSurf()->
1497 Value(Fd->InterferenceOnS2().LastParameter());
1499 ChFi3d_ComputeArete(CV1, VOnS1,
1501 DStr.Surface(Fd->Surf()).Surface(),
1503 Pardeb,Parfin, tol3d, tol2d, tolreached,0);
1504 Crv = TopOpeBRepDS_Curve(C3d,tolreached);
1505 Icurv = DStr.AddCurve(Crv);
1507 stripe->SetCurve(Icurv, isfirst);
1508 stripe->SetParameters(isfirst, Pardeb,Parfin);
1509 stripe->ChangePCurve(isfirst) = PCurv;
1510 stripe->SetIndexPoint(Ivtx, isfirst, 1);
1511 stripe->SetIndexPoint(Ivtx, isfirst, 2);
1516 //=======================================================================
1517 //function : ChFi3d_MakeExtremities
1518 //purpose : calculate Curves3d and pcurves of extremities in
1519 // periodic and freeboundary cases.
1520 //=======================================================================
1521 static Standard_Boolean IsFree(const TopoDS_Shape& E,
1522 const ChFiDS_Map& EFMap)
1524 if(!EFMap.Contains(E)) return 0;
1525 TopTools_ListIteratorOfListOfShape It;
1527 for(It.Initialize(EFMap(E)); It.More(); It.Next()){
1528 if(Fref.IsNull()) Fref = It.Value();
1529 else if(!Fref.IsSame(It.Value())) return 0;
1534 static void ChFi3d_MakeExtremities(Handle(ChFiDS_Stripe)& Stripe,
1535 TopOpeBRepDS_DataStructure& DStr,
1536 const ChFiDS_Map& EFMap,
1537 const Standard_Real tol3d,
1538 const Standard_Real tol2d)
1540 Handle(ChFiDS_Spine)& sp = Stripe->ChangeSpine();
1541 Standard_Real Pardeb,Parfin;
1542 Handle(Geom_Curve) C3d;
1543 Standard_Real tolreached;
1544 if(sp->IsPeriodic()){
1546 const Handle(ChFiDS_SurfData)&
1547 SDF = Stripe->SetOfSurfData()->Sequence().First();
1548 const ChFiDS_CommonPoint& CV1 = SDF->VertexFirstOnS1();
1549 const ChFiDS_CommonPoint& CV2 = SDF->VertexFirstOnS2();
1550 if ( !CV1.Point().IsEqual(CV2.Point(), 0) ) {
1551 ChFi3d_ComputeArete(CV1,
1552 SDF->InterferenceOnS1().PCurveOnSurf()->
1553 Value(SDF->InterferenceOnS1().FirstParameter()),
1555 SDF->InterferenceOnS2().PCurveOnSurf()->
1556 Value(SDF->InterferenceOnS2().FirstParameter()),
1557 DStr.Surface(SDF->Surf()).Surface(),C3d,
1558 Stripe->ChangeFirstPCurve(),Pardeb,Parfin,
1559 tol3d,tol2d,tolreached,0);
1560 TopOpeBRepDS_Curve Crv(C3d,tolreached);
1561 Stripe->ChangeFirstCurve(DStr.AddCurve(Crv));
1562 Stripe->ChangeFirstParameters(Pardeb,Parfin);
1563 Stripe->ChangeIndexFirstPointOnS1
1564 (ChFi3d_IndexPointInDS(SDF->VertexFirstOnS1(),DStr));
1565 Stripe->ChangeIndexFirstPointOnS2
1566 (ChFi3d_IndexPointInDS(SDF->VertexFirstOnS2(),DStr));
1567 Standard_Integer ICurv = Stripe->FirstCurve();
1568 Stripe->ChangeLastParameters(Pardeb,Parfin);
1569 Stripe->ChangeLastCurve(ICurv);
1570 Stripe->ChangeIndexLastPointOnS1(Stripe->IndexFirstPointOnS1());
1571 Stripe->ChangeIndexLastPointOnS2(Stripe->IndexFirstPointOnS2());
1573 const Handle(ChFiDS_SurfData)&
1574 SDL = Stripe->SetOfSurfData()->Sequence().Last();
1577 ChFi3d_ComputePCurv(C3d,
1578 SDL->InterferenceOnS1().PCurveOnSurf()->
1579 Value(SDL->InterferenceOnS1().LastParameter()),
1580 SDL->InterferenceOnS2().PCurveOnSurf()->
1581 Value(SDL->InterferenceOnS2().LastParameter()),
1582 Stripe->ChangeLastPCurve(),
1583 DStr.Surface(SDL->Surf()).Surface(),
1584 Pardeb,Parfin,tol3d,tolreached);
1585 Standard_Real oldtol = DStr.ChangeCurve(ICurv).Tolerance();
1586 DStr.ChangeCurve(ICurv).Tolerance(Max(oldtol,tolreached));
1588 ChFi3d_EnlargeBox(CV1.Arc(),EFMap(CV1.Arc()),CV1.ParameterOnArc(),b1);
1592 ChFi3d_EnlargeBox(CV2.Arc(),EFMap(CV2.Arc()),CV2.ParameterOnArc(),b2);
1594 ChFi3d_EnlargeBox(DStr,Stripe,SDF,b1,b2,1);
1595 ChFi3d_EnlargeBox(DStr,Stripe,SDL,b1,b2,0);
1596 if (!CV1.IsVertex())
1597 ChFi3d_SetPointTolerance(DStr,b1,Stripe->IndexFirstPointOnS1());
1598 if (!CV2.IsVertex())
1599 ChFi3d_SetPointTolerance(DStr,b2,Stripe->IndexFirstPointOnS2());
1602 // Case of the single extremity
1603 if (CV1.IsVertex()) {
1604 ChFi3d_SingularExtremity(Stripe, DStr, CV1.Vertex(), tol3d, tol2d);
1607 else { cout << "MakeExtremities : Singularity out of Vertex !!" << endl; }
1613 const Handle(ChFiDS_SurfData)&
1614 SDdeb = Stripe->SetOfSurfData()->Sequence().First();
1616 const ChFiDS_CommonPoint& cpdeb1 = SDdeb->VertexFirstOnS1();
1617 const ChFiDS_CommonPoint& cpdeb2 = SDdeb->VertexFirstOnS2();
1618 Standard_Boolean freedeb = sp->FirstStatus() == ChFiDS_FreeBoundary;
1619 if(!freedeb && cpdeb1.IsOnArc() && cpdeb2.IsOnArc()){
1620 freedeb = (IsFree(cpdeb1.Arc(),EFMap) && IsFree(cpdeb2.Arc(),EFMap));
1623 sp->SetFirstStatus(ChFiDS_FreeBoundary);
1625 if ( !cpdeb1.Point().IsEqual(cpdeb2.Point(), 0) ) {
1626 Standard_Boolean plane;
1628 UV1=SDdeb->InterferenceOnS1().PCurveOnSurf()->
1629 Value(SDdeb->InterferenceOnS1().FirstParameter());
1630 UV2=SDdeb->InterferenceOnS2().PCurveOnSurf()->
1631 Value(SDdeb->InterferenceOnS2().FirstParameter());
1632 // The intersection of the fillet by a plane is attempted
1634 Handle(GeomAdaptor_HSurface) HConge=ChFi3d_BoundSurf(DStr,SDdeb,1,2);
1635 ChFi3d_CoupeParPlan(cpdeb1,cpdeb2,HConge,UV1,UV2,
1636 tol3d,tol2d,C3d,Stripe->ChangeFirstPCurve(),tolreached,
1637 Pardeb,Parfin,plane);
1639 ChFi3d_ComputeArete(cpdeb1,
1640 SDdeb->InterferenceOnS1().PCurveOnSurf()->
1641 Value(SDdeb->InterferenceOnS1().FirstParameter()),
1643 SDdeb->InterferenceOnS2().PCurveOnSurf()->
1644 Value(SDdeb->InterferenceOnS2().FirstParameter()),
1645 DStr.Surface(SDdeb->Surf()).Surface(),C3d,
1646 Stripe->ChangeFirstPCurve(),Pardeb,Parfin,
1647 tol3d,tol2d,tolreached,0);
1648 TopOpeBRepDS_Curve Crv(C3d,tolreached);
1649 Stripe->ChangeFirstCurve(DStr.AddCurve(Crv));
1650 Stripe->ChangeFirstParameters(Pardeb,Parfin);
1651 Stripe->ChangeIndexFirstPointOnS1
1652 (ChFi3d_IndexPointInDS(SDdeb->VertexFirstOnS1(),DStr));
1653 Stripe->ChangeIndexFirstPointOnS2
1654 (ChFi3d_IndexPointInDS(SDdeb->VertexFirstOnS2(),DStr));
1655 if(cpdeb1.IsOnArc()){
1656 ChFi3d_EnlargeBox(cpdeb1.Arc(),EFMap(cpdeb1.Arc()),cpdeb1.ParameterOnArc(),b1);
1658 if(cpdeb2.IsOnArc()){
1659 ChFi3d_EnlargeBox(cpdeb2.Arc(),EFMap(cpdeb2.Arc()),cpdeb2.ParameterOnArc(),b2);
1661 ChFi3d_EnlargeBox(DStr,Stripe,SDdeb,b1,b2,1);
1662 if (!cpdeb1.IsVertex())
1663 ChFi3d_SetPointTolerance(DStr,b1,Stripe->IndexFirstPointOnS1());
1664 if (!cpdeb2.IsVertex())
1665 ChFi3d_SetPointTolerance(DStr,b2,Stripe->IndexFirstPointOnS2());
1667 else { // Case of a singular extremity
1668 if (cpdeb1.IsVertex()) {
1669 ChFi3d_SingularExtremity(Stripe, DStr, cpdeb1.Vertex(), tol3d, tol2d);
1672 else { cout << "MakeExtremities : Singularity out of Vertex !!" << endl; }
1676 const Handle(ChFiDS_SurfData)&
1677 SDfin = Stripe->SetOfSurfData()->Sequence().Last();
1678 const ChFiDS_CommonPoint& cpfin1 = SDfin->VertexLastOnS1();
1679 const ChFiDS_CommonPoint& cpfin2 = SDfin->VertexLastOnS2();
1680 Standard_Boolean freefin = sp->LastStatus() == ChFiDS_FreeBoundary;
1681 if(!freefin && cpfin1.IsOnArc() && cpfin2.IsOnArc()){
1682 freefin = (IsFree(cpfin1.Arc(),EFMap) && IsFree(cpfin2.Arc(),EFMap));
1685 sp->SetLastStatus(ChFiDS_FreeBoundary);
1687 if ( !cpfin1.Point().IsEqual(cpfin2.Point(), 0) ) {
1688 Standard_Boolean plane;
1690 UV1=SDfin->InterferenceOnS1().PCurveOnSurf()->
1691 Value(SDfin->InterferenceOnS1().LastParameter());
1692 UV2=SDfin->InterferenceOnS2().PCurveOnSurf()->
1693 Value(SDfin->InterferenceOnS2().LastParameter());
1694 // Intersection of the fillet by a plane is attempted
1696 Handle(GeomAdaptor_HSurface) HConge=ChFi3d_BoundSurf(DStr,SDfin,1,2);
1697 ChFi3d_CoupeParPlan(cpfin1,cpfin2,HConge,UV1,UV2,
1698 tol3d,tol2d,C3d,Stripe->ChangeLastPCurve(),tolreached,
1699 Pardeb,Parfin,plane);
1701 ChFi3d_ComputeArete(cpfin1,
1702 SDfin->InterferenceOnS1().PCurveOnSurf()->
1703 Value(SDfin->InterferenceOnS1().LastParameter()),
1705 SDfin->InterferenceOnS2().PCurveOnSurf()->
1706 Value(SDfin->InterferenceOnS2().LastParameter()),
1707 DStr.Surface(SDfin->Surf()).Surface(),C3d,
1708 Stripe->ChangeLastPCurve(),Pardeb,Parfin,
1709 tol3d,tol2d,tolreached,0);
1710 TopOpeBRepDS_Curve Crv(C3d,tolreached);
1711 Stripe->ChangeLastCurve(DStr.AddCurve(Crv));
1712 Stripe->ChangeLastParameters(Pardeb,Parfin);
1713 Stripe->ChangeIndexLastPointOnS1
1714 (ChFi3d_IndexPointInDS(SDfin->VertexLastOnS1(),DStr));
1715 Stripe->ChangeIndexLastPointOnS2
1716 (ChFi3d_IndexPointInDS(SDfin->VertexLastOnS2(),DStr));
1717 if(cpfin1.IsOnArc()){
1718 ChFi3d_EnlargeBox(cpfin1.Arc(),EFMap(cpfin1.Arc()),cpfin1.ParameterOnArc(),b1);
1720 if(cpfin2.IsOnArc()){
1721 ChFi3d_EnlargeBox(cpfin2.Arc(),EFMap(cpfin2.Arc()),cpfin2.ParameterOnArc(),b2);
1723 ChFi3d_EnlargeBox(DStr,Stripe,SDfin,b1,b2,0);
1724 if (!cpfin1.IsVertex())
1725 ChFi3d_SetPointTolerance(DStr,b1,Stripe->IndexLastPointOnS1());
1726 if (!cpfin2.IsVertex())
1727 ChFi3d_SetPointTolerance(DStr,b2,Stripe->IndexLastPointOnS2());
1729 else { // Case of the single extremity
1730 if (cpfin1.IsVertex()) {
1731 ChFi3d_SingularExtremity(Stripe, DStr, cpfin1.Vertex(), tol3d, tol2d);
1734 else { cout << "MakeExtremities : Singularity out of Vertex !!" << endl; }
1740 //=======================================================================
1741 //function : ChFi3d_Purge
1743 //=======================================================================
1745 static void ChFi3d_Purge (Handle(ChFiDS_Stripe)& Stripe,
1746 Handle(ChFiDS_SurfData)& SD,
1747 const ChFiDS_CommonPoint& VRef,
1748 const Standard_Boolean isfirst,
1749 const Standard_Integer ons,
1750 Standard_Boolean& intf,
1751 Standard_Boolean& intl)
1753 if (isfirst) intf = 1; else intl = 1; // End.
1754 Standard_Integer opp = 3-ons;
1755 if (!SD->Vertex(isfirst,opp).IsOnArc() ||
1756 SD->TwistOnS1() || SD->TwistOnS2() ) {
1758 cout<<"ChFi3d_Purge : No output on extension."<<endl;
1760 ChFiDS_SequenceOfSurfData& Seq =
1761 Stripe->ChangeSetOfSurfData()->ChangeSequence();
1762 if(isfirst) Seq.Remove(1);
1763 else Seq.Remove(Seq.Length());
1766 if (ons == 1) SD->ChangeIndexOfS1(0);
1767 else SD->ChangeIndexOfS2(0);
1769 SD->ChangeVertex(!isfirst,ons) = VRef;
1770 SD->ChangeVertex(isfirst,ons) = VRef;
1772 ChFiDS_FaceInterference& fi = SD->ChangeInterference(ons);
1773 if(isfirst) fi.SetFirstParameter(fi.LastParameter());
1774 else fi.SetLastParameter(fi.FirstParameter());
1778 //=======================================================================
1779 //function : InsertAfter
1780 //purpose : insert Item after ref in Seq. If ref is null, the item is
1781 // inserted at the beginning.
1782 //=======================================================================
1784 static void InsertAfter (Handle(ChFiDS_Stripe)& Stripe,
1785 Handle(ChFiDS_SurfData)& Ref,
1786 Handle(ChFiDS_SurfData)& Item)
1789 Standard_Failure::Raise("InsertAfter : twice the same surfdata.");
1791 ChFiDS_SequenceOfSurfData& Seq =
1792 Stripe->ChangeSetOfSurfData()->ChangeSequence();
1794 if (Seq.IsEmpty() || Ref.IsNull()) {
1797 for (Standard_Integer i = 1; i <= Seq.Length(); i++) {
1798 if (Seq.Value(i) == Ref) {
1799 Seq.InsertAfter(i,Item);
1805 //=======================================================================
1806 //function : RemoveSD
1808 //=======================================================================
1810 static void RemoveSD (Handle(ChFiDS_Stripe)& Stripe,
1811 Handle(ChFiDS_SurfData)& Prev,
1812 Handle(ChFiDS_SurfData)& Next)
1814 ChFiDS_SequenceOfSurfData& Seq =
1815 Stripe->ChangeSetOfSurfData()->ChangeSequence();
1816 if(Seq.IsEmpty()) return;
1817 Standard_Integer iprev = 0, inext = 0;
1818 for (Standard_Integer i = 1; i <= Seq.Length(); i++) {
1819 if (Seq.Value(i) == Prev) iprev = i + 1;
1820 if (Seq.Value(i) == Next) { inext = i - 1; break; }
1822 if(Prev.IsNull()) iprev = 1;
1823 if(Next.IsNull()) inext = Seq.Length();
1824 if(iprev <= inext) Seq.Remove(iprev,inext);
1827 //=======================================================================
1828 //function : InsertBefore
1829 //purpose : Insert item before ref in Seq. If ref is null, the item is
1830 // inserted in the queue.
1831 //=======================================================================
1833 static void InsertBefore (Handle(ChFiDS_Stripe)& Stripe,
1834 Handle(ChFiDS_SurfData)& Ref,
1835 Handle(ChFiDS_SurfData)& Item)
1838 Standard_Failure::Raise("InsertBefore : twice the same surfdata.");
1840 ChFiDS_SequenceOfSurfData& Seq =
1841 Stripe->ChangeSetOfSurfData()->ChangeSequence();
1843 if (Seq.IsEmpty() || Ref.IsNull()) {
1846 for (Standard_Integer i = 1; i <= Seq.Length(); i++) {
1847 if (Seq.Value(i) == Ref) {
1848 Seq.InsertBefore(i,Item);
1855 //=======================================================================
1856 //function : PerformSetOfSurfOnElSpine
1858 //=======================================================================
1860 void ChFi3d_Builder::PerformSetOfSurfOnElSpine
1861 (const Handle(ChFiDS_HElSpine)& HGuide,
1862 Handle(ChFiDS_Stripe)& Stripe,
1863 Handle(BRepTopAdaptor_TopolTool)& It1,
1864 Handle(BRepTopAdaptor_TopolTool)& It2,
1865 const Standard_Boolean Simul)
1868 OSD_Chronometer ch1;
1871 ChFiDS_ElSpine& Guide = HGuide->ChangeCurve();
1872 Standard_Real wf = Guide.FirstParameter();
1873 Standard_Real wl = Guide.LastParameter();
1874 Standard_Real locfleche = (wl - wf) * fleche;
1875 Standard_Real wfsav = wf, wlsav = wl;
1876 if (!Guide.IsPeriodic())
1878 //Now the ElSpine is artificially extended to help rsnld.
1879 Standard_Real prab = 0.01;
1880 Guide.FirstParameter(wf-prab*(wl-wf));
1881 Guide.LastParameter (wl+prab*(wl-wf));
1883 Handle(ChFiDS_Spine)& Spine = Stripe->ChangeSpine();
1884 Standard_Integer ii, nbed = Spine->NbEdges();
1885 Standard_Real lastedlastp = Spine->LastParameter(nbed);
1887 TopOpeBRepDS_DataStructure& DStr = myDS->ChangeDS();
1889 Handle(ChFiDS_SurfData) ref = Guide.Previous();
1890 Handle(ChFiDS_SurfData) refbis, SD;
1891 Handle(ChFiDS_SurfData) raf = Guide.Next();
1892 RemoveSD(Stripe,ref,raf);
1894 Handle(BRepAdaptor_HSurface) HS1 = new BRepAdaptor_HSurface();
1895 Handle(BRepAdaptor_HSurface) HS2 = new BRepAdaptor_HSurface();
1896 Handle(BRepAdaptor_HSurface) HS3, HS4;
1897 Handle(BRepAdaptor_HSurface) HSref1 = new BRepAdaptor_HSurface();
1898 Handle(BRepAdaptor_HSurface) HSref2 = new BRepAdaptor_HSurface();
1899 Handle(BRepAdaptor_HCurve2d) HC1,HC2;
1900 Handle(BRepAdaptor_HCurve2d) HCref1 = new BRepAdaptor_HCurve2d();
1901 Handle(BRepAdaptor_HCurve2d) HCref2 = new BRepAdaptor_HCurve2d();
1902 Standard_Boolean decroch1 = Standard_False, decroch2 = Standard_False;
1903 Standard_Boolean RecP1 = Standard_False, RecS1 = Standard_False, RecRst1 = Standard_False, obstacleon1 = Standard_False;
1904 Standard_Boolean RecP2 = Standard_False, RecS2 = Standard_False, RecRst2 = Standard_False, obstacleon2 = Standard_False;
1905 gp_Pnt2d pp1,pp2,pp3,pp4;
1906 Standard_Real w1 = 0.,w2 = 0.;
1907 math_Vector Soldep(1,4);
1908 math_Vector SoldepCS(1,3);
1909 math_Vector SoldepCC(1,2);
1911 // Restore a neighboring KPart.
1912 // If no neighbor calculation start point.
1913 Standard_Boolean forward = Standard_True;
1914 Standard_Boolean Inside = Standard_False;
1915 Standard_Real First = wf;
1916 Standard_Real Last = wl;
1917 Standard_Boolean Ok1 = 1,Ok2 = 1;
1918 // Restore the next KPart if it exists
1920 if(ref.IsNull() && raf.IsNull()){
1921 //sinon solution approchee.
1922 Inside = Standard_True;
1925 ChFi3d_InitChron(ch1);// init perf for StartSol
1928 StartSol(Stripe,HGuide,HS1,HS2,It1,It2,pp1,pp2,First);
1931 ChFi3d_ResultChron(ch1,t_startsol); // result perf for StartSol
1935 if(Guide.IsPeriodic()) {
1936 Last = First - Guide.Period();
1937 Guide.SaveFirstParameter();
1938 Guide.FirstParameter(Last);
1939 Guide.SaveLastParameter();
1940 Guide.LastParameter (First * 1.1);//Extension to help rsnld.
1944 if(!Spine->IsPeriodic() && (wl - lastedlastp > -tolesp)){
1945 Vref = Spine->LastVertex();
1948 if(!Spine->IsPeriodic() && (wf < tolesp)){
1949 Vref = Spine->FirstVertex();
1952 forward = Standard_False;
1953 First = wl; Last = Guide.FirstParameter();
1957 ChFi3d_InitChron(ch1);// init perf for startsol
1961 Ok1 = StartSol(Spine,HS1,pp1,HC1,w1,ref,!forward,1,
1962 HSref1,HCref1,RecP1,RecS1,RecRst1,obstacleon1,
1963 HS3,pp3,decroch1,Vref);
1964 Ok2 = StartSol(Spine,HS2,pp2,HC2,w2,ref,!forward,2,
1965 HSref2,HCref2, RecP2,RecS2,RecRst2,obstacleon2,
1966 HS4,pp4,decroch2,Vref);
1971 ChFi3d_ResultChron(ch1,t_startsol); // result perf for startsol
1975 if(Ok1 == 1 && Ok2 == 1) {
1976 if(forward) Guide.FirstParameter(wf);
1977 else Guide.LastParameter(wl);
1980 Standard_Boolean fini = Standard_False;
1981 Standard_Boolean complete = Inside;
1982 if(!Guide.IsPeriodic()){
1983 Standard_Integer indf = Spine->Index(wf);
1984 Standard_Integer indl = Spine->Index(wl,0);
1985 if(Spine->IsPeriodic() && (indl < indf)) indl += nbed;
1988 // No Max at the touch : 20 points by edge at average without
1989 // counting the extensions.
1991 Standard_Real bidf = wf, bidl = wl;
1992 if(!Spine->IsPeriodic()) {
1994 bidl = Min(wl,Spine->LastParameter(Spine->NbEdges()));
1995 // PMN 20/07/98 : Attention in case if there is only extension
1996 if ((bidl-bidf) < 0.01 * Spine->LastParameter(Spine->NbEdges())) {
2001 Standard_Real MaxStep = (bidl-bidf)*0.05/nbed;
2002 Standard_Real Firstsov = 0.;
2003 Standard_Boolean intf = 0, intl = 0;
2005 // are these the ends (no extension on periodic).
2007 if(!Spine->IsPeriodic()){
2008 if(wf < tolesp && (complete == Inside)){
2009 if(Spine->FirstStatus() == ChFiDS_OnSame) intf = 2;
2012 if(Spine->IsTangencyExtremity(Standard_True)){
2014 Guide.FirstParameter(wfsav);
2016 if(wl - lastedlastp > -tolesp){
2017 if(Spine->LastStatus() == ChFiDS_OnSame) intl = 2;
2020 if(Spine->IsTangencyExtremity(Standard_False)){
2022 Guide.LastParameter(wlsav);
2025 if(intf && !forward) Vref = Spine->FirstVertex();
2026 if(intl && forward) Vref = Spine->LastVertex();
2030 ChFi3d_InitChron(ch1);// init perf for StartSol
2033 Ok1 = StartSol(Spine,HS1,pp1,HC1,w1,ref,!forward,1,
2034 HSref1,HCref1, RecP1,RecS1,RecRst1,obstacleon1,
2035 HS3,pp3,decroch1,Vref);
2036 Ok2 = StartSol(Spine,HS2,pp2,HC2,w2,ref,!forward,2,
2037 HSref2,HCref2, RecP2,RecS2,RecRst2,obstacleon2,
2038 HS4,pp4,decroch2,Vref);
2041 ChFi3d_ResultChron(ch1,t_startsol); // result perf for StartSol
2046 // No more connected faces. Construction of the tangent plane to continue the path
2047 // till the output on the other face.
2048 if ((!Ok1 && HC1.IsNull()) || (!Ok2 && HC2.IsNull())) {
2049 if ((intf && !forward) || (intl && forward)) {
2050 if (!Ok1) ChFi3d_BuildPlane (DStr,HS1,pp1,ref,!forward,1);
2051 if (!Ok2) ChFi3d_BuildPlane (DStr,HS2,pp2,ref,!forward,2);
2053 else if(intl) intl = 5;
2054 if(forward) Guide.FirstParameter(wf);
2055 else Guide.LastParameter(wl);
2057 else Standard_Failure::Raise("PerformSetOfSurfOnElSpine : Chaining is impossible.");
2060 // Definition of the domain of patch It1, It2
2061 const Handle(Adaptor3d_HSurface)& HSon1 = HS1; // to avoid ambiguity
2062 const Handle(Adaptor3d_HSurface)& HSon2 = HS2; // to avoid ambiguity
2063 It1->Initialize(HSon1);
2064 It2->Initialize(HSon2);
2066 // Calculate one (several if singularity) SurfaData
2067 SD = new ChFiDS_SurfData();
2068 ChFiDS_SequenceOfSurfData SeqSD;
2071 if(obstacleon1 && obstacleon2){
2072 TopAbs_Orientation Or1 = HSref1->ChangeSurface().Face().Orientation();
2073 TopAbs_Orientation Or2 = HSref2->ChangeSurface().Face().Orientation();
2074 Standard_Integer Choix = ChFi3d::NextSide(Or1,Or2,
2075 Stripe->OrientationOnFace1(),
2076 Stripe->OrientationOnFace2(),
2080 // Calculate the criterion of Choice edge / edge
2081 if (Choix%2 == 0) Choix = 4;
2084 SoldepCC(1) = w1; SoldepCC(2) = w2;
2086 SimulSurf(SD,HGuide,Spine,Choix,
2087 HS1,It1,HC1,HSref1,HCref1,decroch1,Or1,
2088 HS2,It2,HC2,HSref2,HCref2,decroch2,Or2,
2089 locfleche,tolesp,First,Last,Inside,Inside,forward,
2090 RecP1,RecRst1,RecP2,RecRst2,SoldepCC);
2094 ChFi3d_InitChron(ch1); // init perf for PerformSurf
2096 PerformSurf(SeqSD,HGuide,Spine,Choix,
2097 HS1,It1,HC1,HSref1,HCref1,decroch1,Or1,
2098 HS2,It2,HC2,HSref2,HCref2,decroch2,Or2,
2099 MaxStep,locfleche,tolesp,First,Last,Inside,Inside,forward,
2100 RecP1,RecRst1,RecP2,RecRst2,SoldepCC);
2102 ChFi3d_ResultChron(ch1,t_performsurf); //result perf for PerformSurf
2105 SD->ChangeIndexOfS1(DStr.AddShape(HS1->ChangeSurface().Face()));
2106 SD->ChangeIndexOfS2(DStr.AddShape(HS2->ChangeSurface().Face()));
2108 else if (obstacleon1){
2109 TopAbs_Orientation Or1 = HSref1->ChangeSurface().Face().Orientation();
2110 TopAbs_Orientation Or2 = HS2->ChangeSurface().Face().Orientation();
2111 Standard_Integer Choix = ChFi3d::NextSide(Or1,Or2,
2112 Stripe->OrientationOnFace1(),
2113 Stripe->OrientationOnFace2(),
2115 if(Choix%2 == 1) Choix++;
2117 SoldepCS(3) = w1; SoldepCS(1) = pp2.X(); SoldepCS(2) = pp2.Y();
2119 SimulSurf(SD,HGuide,Spine,Choix,HS1,It1,HC1,HSref1,HCref1,decroch1,
2120 HS2,It2,Or2,locfleche,tolesp,First,Last,
2121 Inside,Inside,forward,RecP1,RecS2,RecRst1,SoldepCS);
2125 ChFi3d_InitChron(ch1); // init perf for PerformSurf
2127 PerformSurf(SeqSD,HGuide,Spine,Choix,HS1,It1,HC1,HSref1,HCref1,decroch1,
2128 HS2,It2,Or2,MaxStep,locfleche,tolesp,First,Last,
2129 Inside,Inside,forward,RecP1,RecS2,RecRst1,SoldepCS);
2131 ChFi3d_ResultChron(ch1,t_performsurf);//result perf for PerformSurf
2134 SD->ChangeIndexOfS1(DStr.AddShape(HS1->ChangeSurface().Face()));
2135 SD->ChangeIndexOfS2(DStr.AddShape(HS2->ChangeSurface().Face()));
2138 else if (obstacleon2){
2139 TopAbs_Orientation Or1 = HS1->ChangeSurface().Face().Orientation();
2140 TopAbs_Orientation Or2 = HSref2->ChangeSurface().Face().Orientation();
2141 Standard_Integer Choix = ChFi3d::NextSide(Or1,Or2,
2142 Stripe->OrientationOnFace1(),
2143 Stripe->OrientationOnFace2(),
2145 SoldepCS(3) = w2; SoldepCS(1) = pp1.X(); SoldepCS(2) = pp1.Y();
2147 SimulSurf(SD,HGuide,Spine,Choix,HS1,It1,Or1,
2148 HS2,It2,HC2,HSref2,HCref2,decroch2,locfleche,tolesp,
2149 First,Last,Inside,Inside,forward,RecP2,RecS1,RecRst2,SoldepCS);
2153 ChFi3d_InitChron(ch1); // init perf for PerformSurf
2155 PerformSurf(SeqSD,HGuide,Spine,Choix,HS1,It1,Or1,
2156 HS2,It2,HC2,HSref2,HCref2,decroch2,MaxStep,locfleche,tolesp,
2157 First,Last,Inside,Inside,forward,RecP2,RecS1,RecRst2,SoldepCS);
2159 ChFi3d_ResultChron(ch1,t_performsurf); //result perf for PerformSurf
2162 SD->ChangeIndexOfS1(DStr.AddShape(HS1->ChangeSurface().Face()));
2163 SD->ChangeIndexOfS2(DStr.AddShape(HS2->ChangeSurface().Face()));
2167 const Handle(Adaptor3d_TopolTool)& aTT1 = It1; // to avoid ambiguity
2168 const Handle(Adaptor3d_TopolTool)& aTT2 = It2; // to avoid ambiguity
2169 CallPerformSurf(Stripe, Simul, SeqSD, SD,
2171 HS1, HS3, pp1, pp3, aTT1,
2172 HS2, HS4, pp2, pp4, aTT2,
2173 MaxStep,locfleche,tolesp,
2174 First,Last,Inside,Inside,forward,
2175 RecS1,RecS2,Soldep,intf,intl,
2177 decroch1 = decroch2 = 0;
2180 if(!done) { // Case of fail
2181 if ((!Ok1 && !obstacleon1) || (!Ok2 && !obstacleon2)) {
2182 //Fail in a part of extension is not serious
2184 done = Standard_True;
2185 Inside = Standard_False;
2186 if (forward) intl = 1;
2189 else { // Otherwise invalidation of the stripe.
2190 Spine->SetErrorStatus(ChFiDS_WalkingFailure);
2191 Standard_Failure::Raise("CallPerformSurf : Path failed!");
2198 for (ii=1; ii<=SeqSD.Length(); ii++) {
2200 SD->ChangeIndexOfS1(DStr.AddShape(HS1->ChangeSurface().Face()));
2201 if(obstacleon1) SD->SetIndexOfC1(DStr.AddShape(HC1->ChangeCurve2d().Edge()));
2202 SD->ChangeIndexOfS2(DStr.AddShape(HS2->ChangeSurface().Face()));
2203 if(obstacleon2) SD->SetIndexOfC2(DStr.AddShape(HC2->ChangeCurve2d().Edge()));
2204 InsertAfter (Stripe, refbis, SD);
2209 for (ii=SeqSD.Length(); ii>=1; ii--) {
2211 SD->ChangeIndexOfS1(DStr.AddShape(HS1->ChangeSurface().Face()));
2212 if(obstacleon1) SD->SetIndexOfC1(DStr.AddShape(HC1->ChangeCurve2d().Edge()));
2213 SD->ChangeIndexOfS2(DStr.AddShape(HS2->ChangeSurface().Face()));
2214 if(obstacleon2) SD->SetIndexOfC2(DStr.AddShape(HC2->ChangeCurve2d().Edge()));
2215 InsertBefore(Stripe,refbis,SD);
2220 if (!Ok1 && !obstacleon1)
2221 // clean infos on the plane of extension.
2222 ChFi3d_Purge (Stripe,SD,ref->Vertex(!forward,1),!forward,1,intf,intl);
2224 if (!Ok2 && !obstacleon2)
2225 // clean infos on the plane of extension.
2226 ChFi3d_Purge (Stripe,SD,ref->Vertex(!forward,2),!forward,2,intf,intl);
2228 // The end. The reference is changed.
2232 if(Inside){// There are starting solutions for the next.
2233 Inside = Standard_False;
2235 if(Guide.IsPeriodic()) {
2236 complete = Standard_False;
2237 wf = Guide.FirstParameter();
2238 wl = Guide.LastParameter();
2242 fini = ((wl - Last) <= 10.*tolesp ||
2243 (intl && !(obstacleon1 || obstacleon2))); //General case
2245 if (!fini && Guide.IsPeriodic() &&
2246 ((wl - Last)< Guide.Period()*1.e-3)) {
2247 // It is tested if reframing of extremes is done at the same edge
2249 Handle(ChFiDS_SurfData) thefirst, thelast;
2250 thefirst = Stripe->SetOfSurfData()->Sequence().First();
2251 thelast = Stripe->SetOfSurfData()->Sequence().Last();
2253 if (thefirst->VertexFirstOnS1().IsOnArc() &&
2254 thelast->VertexLastOnS1().IsOnArc())
2255 fini = thefirst->VertexFirstOnS1().Arc().IsSame
2256 (thelast->VertexLastOnS1().Arc());
2258 thefirst->VertexFirstOnS2().IsOnArc() &&
2259 thelast->VertexLastOnS2().IsOnArc())
2260 fini = thefirst->VertexFirstOnS2().Arc().IsSame
2261 (thelast->VertexLastOnS2().Arc());
2264 return; //It is ended!
2267 if(fini && complete) {
2268 // restart in the opposite direction.
2269 ref = Stripe->SetOfSurfData()->Sequence().First();
2270 forward = Standard_False;
2271 fini = Standard_False;
2280 fini = ((First - wf) <= 10.*tolesp ||
2281 (intf && !(obstacleon1 || obstacleon2)));
2282 complete = Standard_False;
2286 // The initial state is restored
2287 if(!Guide.IsPeriodic()){
2288 Guide.FirstParameter(wfsav);
2289 Guide.LastParameter (wlsav);
2294 //=======================================================================
2295 //function : PerformSetOfKPart
2297 //=======================================================================
2299 void ChFi3d_Builder::PerformSetOfKPart(Handle(ChFiDS_Stripe)& Stripe,
2300 const Standard_Boolean Simul)
2302 TopOpeBRepDS_DataStructure& DStr = myDS->ChangeDS();
2303 Handle(ChFiDS_Spine)& Spine = Stripe->ChangeSpine();
2304 Handle(BRepAdaptor_HSurface) HS1,HS2;
2305 TopAbs_Orientation Or1,Or2,RefOr1,RefOr2;
2306 Standard_Integer RefChoix;
2308 // initialization of the stripe.
2310 Handle(ChFiDS_HData)& HData = Stripe->ChangeSetOfSurfData();
2311 HData = new ChFiDS_HData();
2312 ChFiDS_SequenceOfSurfData& SeqSurf = HData->ChangeSequence();
2314 StripeOrientations(Spine,RefOr1,RefOr2,RefChoix);
2315 Stripe->OrientationOnFace1(RefOr1);
2316 Stripe->OrientationOnFace2(RefOr2);
2317 Stripe->Choix(RefChoix);
2319 Handle(BRepTopAdaptor_TopolTool) It1 = new BRepTopAdaptor_TopolTool();
2320 Handle(BRepTopAdaptor_TopolTool) It2 = new BRepTopAdaptor_TopolTool();
2322 Standard_Real WFirst,WLast = 0.;
2323 gp_Vec TFirst,TLast,TEndPeriodic;
2324 gp_Pnt PFirst,PLast,PEndPeriodic;
2325 Standard_Boolean intf = 0, intl = 0;
2327 Handle(ChFiDS_HElSpine) CurrentHE = new ChFiDS_HElSpine();
2328 Spine->D1(Spine->FirstParameter(),PFirst,TFirst);
2329 CurrentHE->ChangeCurve().FirstParameter(Spine->FirstParameter());
2330 CurrentHE->ChangeCurve().SetFirstPointAndTgt(PFirst,TFirst);
2332 Standard_Boolean YaKPart = Standard_False;
2333 Standard_Integer iedgelastkpart = 0;
2335 Standard_Real WStartPeriodic = 0.;
2336 Standard_Real WEndPeriodic = Spine->LastParameter(Spine->NbEdges());
2337 Spine->D1(WEndPeriodic,PEndPeriodic,TEndPeriodic);
2339 // Construction of particular cases.
2341 for (Standard_Integer iedge = 1; iedge <= Spine->NbEdges(); iedge++){
2343 ConexFaces(Spine,iedge,RefChoix,HS1,HS2);
2345 if (ChFi3d_KParticular(Spine,iedge,HS1->ChangeSurface(),HS2->ChangeSurface())) {
2346 intf = ((iedge == 1) && !Spine->IsPeriodic());
2347 intl = ((iedge == Spine->NbEdges()) && !Spine->IsPeriodic());
2348 Or1 = HS1->ChangeSurface().Face().Orientation();
2349 Or2 = HS2->ChangeSurface().Face().Orientation();
2350 ChFi3d::NextSide(Or1,Or2,RefOr1,RefOr2,RefChoix);
2351 const Handle(Adaptor3d_HSurface)& HSon1 = HS1; // to avoid ambiguity
2352 const Handle(Adaptor3d_HSurface)& HSon2 = HS2; // to avoid ambiguity
2353 It1->Initialize(HSon1);
2354 It2->Initialize(HSon2);
2356 Handle(ChFiDS_SurfData) SD = new ChFiDS_SurfData();
2357 ChFiDS_SequenceOfSurfData LSD;
2359 if(!ChFiKPart_ComputeData::Compute(DStr,SD,HS1,HS2,Or1,Or2,Spine,iedge)){
2361 cout<<"failed calculation KPart"<<endl;
2364 else if(!SplitKPart(SD,LSD,Spine,iedge,HS1,It1,HS2,It2,intf,intl)){
2366 cout<<"failed calculation KPart"<<endl;
2370 else iedgelastkpart = iedge;
2371 if(Spine->IsPeriodic()){//debug provisory for SD that arrive in desorder.
2372 Standard_Integer nbsd = LSD.Length();
2373 Standard_Real period = Spine->Period();
2374 Standard_Real wfp = WStartPeriodic, wlp = WEndPeriodic;
2375 // modified by NIZHNY-EAP Thu Nov 25 12:57:53 1999 ___BEGIN___
2376 if(!YaKPart && nbsd>0){
2378 // modified by NIZHNY-EAP Thu Nov 25 12:57:57 1999 ___END___
2379 Handle(ChFiDS_SurfData) firstSD = LSD.ChangeValue(1);
2380 Standard_Real wwf = firstSD->FirstSpineParam();
2381 Standard_Real wwl = firstSD->LastSpineParam();
2382 wwf = ChFi3d_InPeriod(wwf,wfp,wlp,tolesp);
2383 wwl = ChFi3d_InPeriod(wwl,wfp,wlp,tolesp);
2384 if (wwl <= wwf + tolesp) wwl += period;
2388 for(Standard_Integer j = 1; j < nbsd; j++){
2389 Handle(ChFiDS_SurfData) jSD = LSD.Value(j);
2390 for(Standard_Integer k = j+1; k <= nbsd; k++){
2391 Handle(ChFiDS_SurfData) kSD = LSD.Value(k);
2392 Standard_Real jwf = jSD->FirstSpineParam();
2393 jwf = ChFi3d_InPeriod(jwf,wfp,wlp,tolesp);
2394 Standard_Real kwf = kSD->FirstSpineParam();
2395 kwf = ChFi3d_InPeriod(kwf,wfp,wlp,tolesp);
2397 LSD.SetValue(j,kSD);
2398 LSD.SetValue(k,jSD);
2403 TColStd_ListOfInteger li;
2404 for(Standard_Integer j = 1; j <= LSD.Length(); j++){
2405 Handle(ChFiDS_SurfData)& curSD = LSD.ChangeValue(j);
2406 if(Simul) SimulKPart(curSD);
2407 SeqSurf.Append(curSD);
2408 if(!Simul) li.Append(curSD->Surf());
2409 WFirst = LSD.Value(j)->FirstSpineParam();
2410 WLast = LSD.Value(j)->LastSpineParam();
2411 if(Spine->IsPeriodic()){
2412 WFirst = ChFi3d_InPeriod(WFirst,WStartPeriodic,WEndPeriodic,tolesp);
2413 WLast = ChFi3d_InPeriod(WLast ,WStartPeriodic,WEndPeriodic,tolesp);
2414 if (WLast <= WFirst + tolesp) WLast+= Spine->Period();
2416 TgtKP(LSD.Value(j),Spine,iedge,1,PFirst,TFirst);
2417 TgtKP(LSD.Value(j),Spine,iedge,0,PLast,TLast);
2419 // Determine the sections to approximate
2421 if(Spine->IsPeriodic()){
2422 WStartPeriodic = WFirst;
2423 WEndPeriodic = WStartPeriodic + Spine->Period();
2424 WLast = ElCLib::InPeriod(WLast,WStartPeriodic,WEndPeriodic);
2425 if (WLast <= WFirst + tolesp) WLast+= Spine->Period();
2426 PEndPeriodic = PFirst;
2427 TEndPeriodic = TFirst;
2428 Spine->SetFirstParameter(WStartPeriodic);
2429 Spine->SetLastParameter(WEndPeriodic);
2431 else if(!intf || (iedge > 1)){
2432 // start section -> first KPart
2433 // update of extension.
2434 Spine->SetFirstTgt(Min(0.,WFirst));
2435 CurrentHE->ChangeCurve().LastParameter (WFirst);
2436 CurrentHE->ChangeCurve().SetLastPointAndTgt(PFirst,TFirst);
2437 Spine->AppendElSpine(CurrentHE);
2438 CurrentHE->ChangeCurve().ChangeNext() = LSD.Value(j);
2439 CurrentHE = new ChFiDS_HElSpine();
2441 CurrentHE->ChangeCurve().FirstParameter(WLast);
2442 CurrentHE->ChangeCurve().SetFirstPointAndTgt(PLast,TLast);
2443 CurrentHE->ChangeCurve().ChangePrevious() = LSD.Value(j);
2444 YaKPart = Standard_True;
2447 if (WFirst - CurrentHE->FirstParameter() > tolesp) {
2448 // section between two KPart
2449 CurrentHE->ChangeCurve().LastParameter(WFirst);
2450 CurrentHE->ChangeCurve().SetLastPointAndTgt(PFirst,TFirst);
2451 Spine->AppendElSpine(CurrentHE);
2452 CurrentHE->ChangeCurve().ChangeNext() = LSD.Value(j);
2453 CurrentHE = new ChFiDS_HElSpine();
2455 CurrentHE->ChangeCurve().FirstParameter(WLast);
2456 CurrentHE->ChangeCurve().SetFirstPointAndTgt(PLast,TLast);
2457 CurrentHE->ChangeCurve().ChangePrevious() = LSD.Value(j);
2460 if(!li.IsEmpty()) myEVIMap.Bind(Spine->Edges(iedge),li);
2464 if (!intl || (iedgelastkpart < Spine->NbEdges())) {
2465 // section last KPart(or start of the spine) -> End of the spine.
2466 // update of the extension.
2468 if(Spine->IsPeriodic()){
2469 if(WEndPeriodic - WLast > tolesp){
2470 CurrentHE->ChangeCurve().LastParameter(WEndPeriodic);
2471 CurrentHE->ChangeCurve().SetLastPointAndTgt(PEndPeriodic,TEndPeriodic);
2472 if(!YaKPart) CurrentHE->ChangeCurve().SetPeriodic(Standard_True);
2473 Spine->AppendElSpine(CurrentHE);
2477 Spine->D1(Spine->LastParameter(),PLast,TLast);
2478 Spine->SetLastTgt(Max(Spine->LastParameter(Spine->NbEdges()),
2480 if (Spine->LastParameter() - WLast > tolesp) {
2481 CurrentHE->ChangeCurve().LastParameter(Spine->LastParameter());
2482 CurrentHE->ChangeCurve().SetLastPointAndTgt(PLast,TLast);
2483 Spine->AppendElSpine(CurrentHE);
2488 ChFiDS_ListOfHElSpine& ll = Spine->ChangeElSpines();
2489 ChFiDS_ListIteratorOfListOfHElSpine ILES(ll);
2490 for ( ; ILES.More(); ILES.Next()) {
2492 if(ChFi3d_GettraceCHRON()) elspine.Start();
2494 ChFi3d_PerformElSpine(ILES.Value(),Spine,myConti,tolesp);
2496 if(ChFi3d_GettraceCHRON()) { elspine.Stop(); }
2499 Spine->SplitDone(Standard_True);
2502 static Standard_Real ChFi3d_BoxDiag(const Bnd_Box& box)
2504 Standard_Real a,b,c,d,e,f;
2505 box.Get(a,b,c,d,e,f);
2508 Standard_Real diag = sqrt(d + e + f);
2512 //=======================================================================
2513 //function : PerformSetOfKGen
2515 //=======================================================================
2517 void ChFi3d_Builder::PerformSetOfKGen(Handle(ChFiDS_Stripe)& Stripe,
2518 const Standard_Boolean Simul)
2520 Handle(BRepTopAdaptor_TopolTool) It1 = new BRepTopAdaptor_TopolTool();
2521 Handle(BRepTopAdaptor_TopolTool) It2 = new BRepTopAdaptor_TopolTool();
2522 Handle(ChFiDS_Spine)& Spine = Stripe->ChangeSpine();
2523 ChFiDS_ListOfHElSpine& ll = Spine->ChangeElSpines();
2524 ChFiDS_ListIteratorOfListOfHElSpine ILES(ll);
2525 for ( ; ILES.More(); ILES.Next()) {
2527 if(ChFi3d_GettraceCHRON()) { chemine.Start(); }
2529 PerformSetOfSurfOnElSpine(ILES.Value(),Stripe,It1,It2,Simul);
2531 if(ChFi3d_GettraceCHRON()) chemine.Stop();
2535 TopOpeBRepDS_DataStructure& DStr = myDS->ChangeDS();
2536 Handle(ChFiDS_HData)& HData = Stripe->ChangeSetOfSurfData();
2537 ChFiDS_SequenceOfSurfData& SeqSurf = HData->ChangeSequence();
2538 Standard_Integer len = SeqSurf.Length();
2539 Standard_Integer last = len, i;
2540 Standard_Boolean periodic = Spine->IsPeriodic();
2541 if(periodic) last++;
2542 // It is attempted to reprocess the squares that bore.
2543 for(i = 1; i <= len; i++){
2544 Handle(ChFiDS_SurfData)& cursd = SeqSurf.ChangeValue(i);
2545 Standard_Boolean tw1 = cursd->TwistOnS1();
2546 Standard_Boolean tw2 = cursd->TwistOnS2();
2547 Handle(ChFiDS_SurfData) prevsd, nextsd;
2548 Standard_Integer iprev = i-1;
2550 if(periodic) iprev = len;
2552 Standard_Integer inext = i + 1;
2554 if(periodic) inext = 1;
2558 // For the moment only the surfaces where the twist is
2559 // detected at the path are corrected, it is necessary to control
2560 // more subtly the ugly traces (size, curvature, inflexion... )
2561 if(!tw1 && !tw2) continue;
2563 // It is decided (fairly at random) if the extended surface is ready for the filling.
2564 ChFiDS_FaceInterference& intf1 = cursd->ChangeInterferenceOnS1();
2565 ChFiDS_FaceInterference& intf2 = cursd->ChangeInterferenceOnS2();
2566 Standard_Integer cursurf1 = cursd->IndexOfS1();
2567 Standard_Integer cursurf2 = cursd->IndexOfS2();
2568 ChFiDS_CommonPoint& cpd1 = cursd->ChangeVertexFirstOnS1();
2569 ChFiDS_CommonPoint& cpd2 = cursd->ChangeVertexFirstOnS2();
2570 ChFiDS_CommonPoint& cpf1 = cursd->ChangeVertexLastOnS1();
2571 ChFiDS_CommonPoint& cpf2 = cursd->ChangeVertexLastOnS2();
2572 const gp_Pnt& pd1 = cpd1.Point();
2573 const gp_Pnt& pd2 = cpd2.Point();
2574 const gp_Pnt& pf1 = cpf1.Point();
2575 const gp_Pnt& pf2 = cpf2.Point();
2576 Standard_Real ddeb = pd1.Distance(pd2);
2577 Standard_Real dfin = pf1.Distance(pf2);
2578 Standard_Real don1 = pd1.Distance(pf1);
2579 Standard_Real don2 = pd2.Distance(pf2);
2580 Standard_Boolean possibleon1 = (don1 < 2*(ddeb + dfin));
2581 Standard_Boolean possibleon2 = (don2 < 2*(ddeb + dfin));
2582 if((tw1 && !possibleon1) || (tw2 && !possibleon2)) {
2583 Spine->SetErrorStatus(ChFiDS_TwistedSurface);
2584 Standard_Failure::Raise("adjustment by reprocessing the non-written points");
2587 // It is checked if there are presentable neighbors
2588 Standard_Boolean yaprevon1 = 0, yaprevon2 = 0;
2589 Standard_Boolean samesurfon1 = 0, samesurfon2 = 0;
2591 prevsd = SeqSurf.ChangeValue(iprev);
2592 yaprevon1 = !prevsd->TwistOnS1();
2593 samesurfon1 = (prevsd->IndexOfS1() == cursurf1);
2594 yaprevon2 = !prevsd->TwistOnS2();
2595 samesurfon2 = (prevsd->IndexOfS2() == cursurf2);
2597 Standard_Boolean yanexton1 = 0, yanexton2 = 0;
2599 nextsd = SeqSurf.ChangeValue(inext);
2600 yanexton1 = !nextsd->TwistOnS1();
2601 if(samesurfon1) samesurfon1 = (nextsd->IndexOfS1() == cursurf1);
2602 yanexton2 = !nextsd->TwistOnS2();
2603 if(samesurfon2) samesurfon2 = (nextsd->IndexOfS2() == cursurf2);
2605 // A contour of filling is constructed
2606 Handle(Geom2d_Curve) PC1 = intf1.PCurveOnFace();
2607 Handle(Geom2d_Curve) PC2 = intf2.PCurveOnFace();
2608 Handle(BRepAdaptor_HSurface) S1 = new BRepAdaptor_HSurface();
2609 TopoDS_Face F1 = TopoDS::Face(DStr.Shape(cursurf1));
2610 S1->ChangeSurface().Initialize(F1);
2611 Handle(BRepAdaptor_HSurface) S2 = new BRepAdaptor_HSurface();
2612 TopoDS_Face F2 = TopoDS::Face(DStr.Shape(cursurf2));
2613 S2->ChangeSurface().Initialize(F2);
2614 Handle(GeomFill_Boundary) Bdeb,Bfin,Bon1,Bon2;
2615 Standard_Boolean pointuon1 = 0, pointuon2 = 0;
2617 if(!yaprevon1 || !yanexton1){
2618 Spine->SetErrorStatus(ChFiDS_TwistedSurface);
2619 Standard_Failure::Raise
2620 ("adjustment by reprocessing the non-written points: no neighbor");
2622 ChFiDS_FaceInterference& previntf1 = prevsd->ChangeInterferenceOnS1();
2623 ChFiDS_FaceInterference& nextintf1 = nextsd->ChangeInterferenceOnS1();
2624 Standard_Real prevpar1 = previntf1.LastParameter();
2625 Standard_Real nextpar1 = nextintf1.FirstParameter();
2627 // It is checked if it is possible to intersect traces of neighbors
2628 // to create a sharp end.
2629 Handle(Geom2d_Curve) pcprev1 = previntf1.PCurveOnFace();
2630 Handle(Geom2d_Curve) pcnext1 = nextintf1.PCurveOnFace();
2631 Standard_Real nprevpar1,nnextpar1;
2633 // Modified by Sergey KHROMOV - Wed Feb 5 12:03:17 2003 Begin
2634 // if(ChFi3d_IntTraces(prevsd,prevpar1,nprevpar1,1,1,
2635 // nextsd,nextpar1,nnextpar1,1,-1,p2d)){
2636 if(ChFi3d_IntTraces(prevsd,prevpar1,nprevpar1,1,1,
2637 nextsd,nextpar1,nnextpar1,1,-1,p2d,
2638 Standard_False, Standard_True)){
2639 // Modified by Sergey KHROMOV - Wed Feb 5 12:03:17 2003 End
2640 previntf1.SetLastParameter(nprevpar1);
2641 nextintf1.SetFirstParameter(nnextpar1);
2646 gp_Pnt2d pdeb1,pfin1;
2647 gp_Vec2d vdeb1,vfin1;
2648 pcprev1->D1(prevpar1,pdeb1,vdeb1);
2649 pcnext1->D1(nextpar1,pfin1,vfin1);
2650 Bon1 = ChFi3d_mkbound(S1,PC1,-1,pdeb1,vdeb1,1,
2651 pfin1,vfin1,tolesp,2.e-4);
2655 //here the base is on 3D tangents of neighbors.
2656 const Handle(Geom_Curve)& c3dprev1 =
2657 DStr.Curve(previntf1.LineIndex()).Curve();
2658 const Handle(Geom_Curve)& c3dnext1 =
2659 DStr.Curve(nextintf1.LineIndex()).Curve();
2660 gp_Pnt Pdeb1, Pfin1;
2661 gp_Vec Vdeb1, Vfin1;
2662 c3dprev1->D1(prevpar1,Pdeb1,Vdeb1);
2663 c3dnext1->D1(nextpar1,Pfin1,Vfin1);
2664 gp_Pnt2d pdeb1,pfin1;
2665 Standard_Real pardeb1 = intf1.FirstParameter();
2666 Standard_Real parfin1 = intf1.LastParameter();
2667 pdeb1 = PC1->Value(pardeb1);
2668 pfin1 = PC1->Value(parfin1);
2669 Bon1 = ChFi3d_mkbound(S1,PC1,-1,pdeb1,Vdeb1,1,
2670 pfin1,Vfin1,tolesp,2.e-4);
2674 Bon1 = ChFi3d_mkbound(S1,PC1,tolesp,2.e-4);
2677 if(!yaprevon2 || !yanexton2){
2678 Standard_Failure::Raise
2679 ("adjustment by reprocessing the non-written points: no neighbor");
2681 ChFiDS_FaceInterference& previntf2 = prevsd->ChangeInterferenceOnS2();
2682 ChFiDS_FaceInterference& nextintf2 = nextsd->ChangeInterferenceOnS2();
2683 Standard_Real prevpar2 = previntf2.LastParameter();
2684 Standard_Real nextpar2 = nextintf2.FirstParameter();
2686 // It is checked if it is possible to intersect traces of neighbors
2687 // to create a sharp end.
2688 Handle(Geom2d_Curve) pcprev2 = previntf2.PCurveOnFace();
2689 Handle(Geom2d_Curve) pcnext2 = nextintf2.PCurveOnFace();
2690 Standard_Real nprevpar2,nnextpar2;
2692 // Modified by Sergey KHROMOV - Wed Feb 5 12:03:17 2003 Begin
2693 // if(ChFi3d_IntTraces(prevsd,prevpar2,nprevpar2,2,1,
2694 // nextsd,nextpar2,nnextpar2,2,-1,p2d)){
2695 if(ChFi3d_IntTraces(prevsd,prevpar2,nprevpar2,2,1,
2696 nextsd,nextpar2,nnextpar2,2,-1,p2d,
2697 Standard_False, Standard_True)){
2698 // Modified by Sergey KHROMOV - Wed Feb 5 12:03:17 2003 End
2699 previntf2.SetLastParameter(nprevpar2);
2700 nextintf2.SetFirstParameter(nnextpar2);
2705 gp_Pnt2d pdeb2,pfin2;
2706 gp_Vec2d vdeb2,vfin2;
2707 pcprev2->D1(prevpar2,pdeb2,vdeb2);
2708 pcnext2->D1(nextpar2,pfin2,vfin2);
2709 Bon2 = ChFi3d_mkbound(S2,PC2,-1,pdeb2,vdeb2,1,
2710 pfin2,vfin2,tolesp,2.e-4);
2714 //here the base is on 3D tangents of neighbors.
2715 const Handle(Geom_Curve)& c3dprev2 =
2716 DStr.Curve(previntf2.LineIndex()).Curve();
2717 const Handle(Geom_Curve)& c3dnext2 =
2718 DStr.Curve(nextintf2.LineIndex()).Curve();
2719 gp_Pnt Pdeb2, Pfin2;
2720 gp_Vec Vdeb2, Vfin2;
2721 c3dprev2->D1(prevpar2,Pdeb2,Vdeb2);
2722 c3dnext2->D1(nextpar2,Pfin2,Vfin2);
2723 gp_Pnt2d pdeb2,pfin2;
2724 Standard_Real pardeb2 = intf2.FirstParameter();
2725 Standard_Real parfin2 = intf2.LastParameter();
2726 pdeb2 = PC2->Value(pardeb2);
2727 pfin2 = PC2->Value(parfin2);
2728 Bon2 = ChFi3d_mkbound(S2,PC2,-1,pdeb2,Vdeb2,1,
2729 pfin2,Vfin2,tolesp,2.e-4);
2733 Bon2 = ChFi3d_mkbound(S2,PC2,tolesp,2.e-4);
2735 // The parameters of neighbor traces are updated, so
2736 // straight lines uv are pulled.
2737 const Handle(Geom_Surface)&
2738 sprev = DStr.Surface(prevsd->Surf()).Surface();
2739 const Handle(Geom_Surface)&
2740 snext = DStr.Surface(nextsd->Surf()).Surface();
2741 ChFiDS_FaceInterference& previntf1 = prevsd->ChangeInterferenceOnS1();
2742 ChFiDS_FaceInterference& nextintf1 = nextsd->ChangeInterferenceOnS1();
2743 ChFiDS_FaceInterference& previntf2 = prevsd->ChangeInterferenceOnS2();
2744 ChFiDS_FaceInterference& nextintf2 = nextsd->ChangeInterferenceOnS2();
2745 Handle(Geom2d_Curve) pcsprev1 = previntf1.PCurveOnSurf();
2746 Handle(Geom2d_Curve) pcsnext1 = nextintf1.PCurveOnSurf();
2747 Standard_Real prevpar1 = previntf1.LastParameter();
2748 Standard_Real nextpar1 = nextintf1.FirstParameter();
2749 Handle(Geom2d_Curve) pcsprev2 = previntf2.PCurveOnSurf();
2750 Handle(Geom2d_Curve) pcsnext2 = nextintf2.PCurveOnSurf();
2751 Standard_Real prevpar2 = previntf2.LastParameter();
2752 Standard_Real nextpar2 = nextintf2.FirstParameter();
2753 gp_Pnt2d pdebs1 = pcsprev1->Value(prevpar1);
2754 gp_Pnt2d pdebs2 = pcsprev2->Value(prevpar2);
2755 gp_Pnt2d pfins1 = pcsnext1->Value(nextpar1);
2756 gp_Pnt2d pfins2 = pcsnext2->Value(nextpar2);
2757 Bdeb = ChFi3d_mkbound(sprev,pdebs1,pdebs2,tolesp,2.e-4);
2758 Bfin = ChFi3d_mkbound(snext,pfins1,pfins2,tolesp,2.e-4);
2760 GeomFill_ConstrainedFilling fil(11,20);
2761 if(pointuon1) fil.Init(Bon2,Bfin,Bdeb,1);
2762 else if(pointuon2) fil.Init(Bon1,Bfin,Bdeb,1);
2763 else fil.Init(Bon1,Bfin,Bon2,Bdeb,1);
2765 ChFi3d_ReparamPcurv(0.,1.,PC1);
2766 ChFi3d_ReparamPcurv(0.,1.,PC2);
2767 Handle(Geom_Surface) newsurf = fil.Surface();
2771 char* pops = "newsurf";
2772 DrawTrSurf::Set(pops,newsurf);
2776 newsurf->VReverse(); // we return to direction 1 from 2;
2777 done = CompleteData(cursd,newsurf,S1,PC1,S2,PC2,
2778 F2.Orientation(),0,0,0,0,0);
2779 cursd->ChangeIndexOfS1(0);
2782 done = CompleteData(cursd,newsurf,S1,PC1,S2,PC2,
2783 F1.Orientation(),1,0,0,0,0);
2784 if(pointuon2) cursd->ChangeIndexOfS2(0);
2787 prevsd->ChangeVertexLastOnS1().SetPoint(cpd1.Point());
2788 nextsd->ChangeVertexFirstOnS1().SetPoint(cpf1.Point());
2791 prevsd->ChangeVertexLastOnS2().SetPoint(cpd2.Point());
2792 nextsd->ChangeVertexFirstOnS2().SetPoint(cpf2.Point());
2795 // The tolerance of points is updated.
2796 for(i = 1; i < last; i++){
2797 Standard_Integer j = i%len + 1;
2798 Standard_Integer curs1, curs2;
2799 Standard_Integer nexts1, nexts2;
2800 Handle(ChFiDS_SurfData)& cursd = SeqSurf.ChangeValue(i);
2801 Handle(ChFiDS_SurfData)& nextsd = SeqSurf.ChangeValue(j);
2802 ChFiDS_CommonPoint& curp1 = cursd->ChangeVertexLastOnS1();
2803 ChFiDS_CommonPoint& nextp1 = nextsd->ChangeVertexFirstOnS1();
2804 if (cursd->IsOnCurve1()) curs1 = cursd->IndexOfC1();
2805 else curs1 = cursd->IndexOfS1();
2806 if (cursd->IsOnCurve2()) curs2 = cursd->IndexOfC2();
2807 else curs2 = cursd->IndexOfS2();
2808 Standard_Real tol1 = Max(curp1.Tolerance(),nextp1.Tolerance());
2809 ChFiDS_CommonPoint& curp2 = cursd->ChangeVertexLastOnS2();
2810 ChFiDS_CommonPoint& nextp2 = nextsd->ChangeVertexFirstOnS2();
2811 Standard_Real tol2 = Max(curp2.Tolerance(),nextp2.Tolerance());
2812 if (nextsd->IsOnCurve1()) nexts1 = nextsd->IndexOfC1();
2813 else nexts1 = nextsd->IndexOfS1();
2814 if (nextsd->IsOnCurve2()) nexts2 = nextsd->IndexOfC2();
2815 else nexts2 = nextsd->IndexOfS2();
2817 if(!curp1.IsOnArc() && nextp1.IsOnArc()){
2819 if ( (curs1 == nexts1) && !nextsd->IsOnCurve1())
2820 // Case when it is not possible to pass along the border without leaving
2821 ChangeTransition(nextp1, curp1, nexts1, myDS);
2823 else if(curp1.IsOnArc() && !nextp1.IsOnArc()) {
2825 if ( (curs1 == nexts1) && !cursd->IsOnCurve1())
2826 ChangeTransition(curp1, nextp1, curs1, myDS);
2829 if(!curp2.IsOnArc() && nextp2.IsOnArc()) {
2831 if ( (curs2 == nexts2) && !nextsd->IsOnCurve2())
2832 ChangeTransition(nextp2, curp2, curs2, myDS);
2834 else if(curp2.IsOnArc() && !nextp2.IsOnArc()){
2836 if ( (curs2 == nexts2) && !cursd->IsOnCurve2())
2837 ChangeTransition(curp2, nextp2, curs2, myDS);
2840 curp1.SetTolerance(tol1); nextp1.SetTolerance(tol1);
2841 curp2.SetTolerance(tol2); nextp2.SetTolerance(tol2);
2844 if(curp1.IsOnArc()){
2845 ChFi3d_EnlargeBox(curp1.Arc(),myEFMap(curp1.Arc()),curp1.ParameterOnArc(),b1);
2847 if(curp2.IsOnArc()){
2848 ChFi3d_EnlargeBox(curp2.Arc(),myEFMap(curp2.Arc()),curp2.ParameterOnArc(),b2);
2850 Handle(ChFiDS_Stripe) bidst;
2851 ChFi3d_EnlargeBox(DStr,bidst,cursd,b1,b2,0);
2852 ChFi3d_EnlargeBox(DStr,bidst,nextsd,b1,b2,1);
2853 tol1 = ChFi3d_BoxDiag(b1);
2854 tol2 = ChFi3d_BoxDiag(b2);
2855 curp1.SetTolerance(tol1); nextp1.SetTolerance(tol1);
2856 curp2.SetTolerance(tol2); nextp2.SetTolerance(tol2);
2858 // The connections edge/new faces are updated.
2859 for (ILES.Initialize(ll) ; ILES.More(); ILES.Next()) {
2860 const Handle(ChFiDS_HElSpine)& curhels = ILES.Value();
2861 const ChFiDS_ElSpine& curels = curhels->ChangeCurve();
2862 Standard_Real WF = curels.FirstParameter();
2863 Standard_Real WL = curels.LastParameter();
2864 Standard_Integer IF,IL;
2865 Standard_Real nwf = WF, nwl = WL;
2866 Standard_Real period = 0.;
2867 Standard_Integer nbed = Spine->NbEdges();
2869 period = Spine->Period();
2870 nwf = ElCLib::InPeriod(WF,-tolesp,period-tolesp);
2871 IF = Spine->Index(nwf,1);
2872 nwl = ElCLib::InPeriod(WL,tolesp,period+tolesp);
2873 IL = Spine->Index(nwl,0);
2874 if(nwl<nwf+tolesp) IL += nbed;
2877 IF = Spine->Index(WF,1);
2878 IL = Spine->Index(WL,0);
2882 Standard_Integer IFloc = IF;
2883 if(periodic) IFloc = (IF - 1)%nbed + 1;
2884 const TopoDS_Edge& Ej = Spine->Edges(IFloc);
2885 for(i = 1; i <= len; i++){
2886 Handle(ChFiDS_SurfData)& cursd = SeqSurf.ChangeValue(i);
2887 Standard_Real fp = cursd->FirstSpineParam();
2888 Standard_Real lp = cursd->LastSpineParam();
2889 if(lp < WF+tolesp || fp > WL-tolesp) continue;
2890 if(!myEVIMap.IsBound(Ej)) {
2891 TColStd_ListOfInteger li;
2892 myEVIMap.Bind(Ej,li);
2894 myEVIMap.ChangeFind(Ej).Append(cursd->Surf());
2898 TColStd_Array1OfReal wv(IF,IL - 1);
2900 cout<<"length of the trajectory : "<<(WL-WF)<<endl;
2902 for(i = IF; i < IL; i++){
2903 Standard_Integer iloc = i;
2904 if(periodic) iloc = (i - 1)%nbed + 1;
2905 Standard_Real wi = Spine->LastParameter(iloc);
2906 if(periodic) wi = ElCLib::InPeriod(wi,WF,WF+period);
2907 gp_Pnt pv = Spine->Value(wi);
2909 gp_Pnt pelsapp = curels.Value(wi);
2910 Standard_Real distinit = pv.Distance(pelsapp);
2911 cout<<"distance psp/papp : "<<distinit<<endl;
2913 Extrema_LocateExtPC ext(pv,curels,wi,1.e-8);
2916 wv(i) = ext.Point().Parameter();
2920 cout<<"fail of projection vertex ElSpine!!!"<<endl;
2924 for(i = 1; i <= len; i++){
2925 Handle(ChFiDS_SurfData)& cursd = SeqSurf.ChangeValue(i);
2926 Standard_Real fp = cursd->FirstSpineParam();
2927 Standard_Real lp = cursd->LastSpineParam();
2929 Standard_Integer jf = 0, jl = 0;
2930 if(lp < WF+tolesp || fp > WL-tolesp) continue;
2931 for(j = IF; j < IL; j++){
2933 if(fp < wv(j) - tolesp) break;
2935 for(j = IF; j < IL; j++){
2937 if(lp < wv(j) + tolesp) break;
2939 for(j = jf; j <= jl; j++){
2940 Standard_Integer jloc = j;
2941 if(periodic) jloc = (j - 1)%nbed + 1;
2942 const TopoDS_Edge& Ej = Spine->Edges(jloc);
2943 if(!myEVIMap.IsBound(Ej)) {
2944 TColStd_ListOfInteger li;
2945 myEVIMap.Bind(Ej,li);
2947 myEVIMap.ChangeFind(Ej).Append(cursd->Surf());
2955 //=======================================================================
2956 //function : PerformSetOfSurf
2958 //=======================================================================
2960 void ChFi3d_Builder::PerformSetOfSurf(Handle(ChFiDS_Stripe)& Stripe,
2961 const Standard_Boolean Simul)
2963 TopOpeBRepDS_DataStructure& DStr = myDS->ChangeDS();
2967 ChFi3d_InitChron(ch);// init perf for PerformSetOfKPart
2970 const Handle(ChFiDS_Spine)& sp = Stripe->Spine();
2971 Standard_Integer SI = ChFi3d_SolidIndex(sp,DStr,myESoMap,myEShMap);
2972 Stripe->SetSolidIndex(SI);
2973 if(!sp->SplitDone()) PerformSetOfKPart(Stripe,Simul);
2976 ChFi3d_ResultChron(ch ,t_perfsetofkpart); // result perf PerformSetOfKPart(
2977 ChFi3d_InitChron(ch); // init perf for PerformSetOfKGen
2980 PerformSetOfKGen(Stripe,Simul);
2983 ChFi3d_ResultChron(ch, t_perfsetofkgen);//result perf PerformSetOfKGen
2984 ChFi3d_InitChron(ch); // init perf for ChFi3d_MakeExtremities
2987 if(!Simul) ChFi3d_MakeExtremities(Stripe,DStr,myEFMap,tolesp,tol2d);
2990 ChFi3d_ResultChron(ch, t_makextremities); // result perf t_makextremities