projects / occt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
0026173: Wrong result of ChFi3d_ChBuilder algorithm: incorrect processing of G1 junct...
[occt.git] / src / ChFi3d / ChFi3d_Builder_2.cxx
CommitLineData
b311480e 1// Created on: 1993-12-15
2// Created by: Isabelle GRIGNON
3// Copyright (c) 1993-1999 Matra Datavision
973c2be1 4// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e 5//
973c2be1 6// This file is part of Open CASCADE Technology software library.
b311480e 7//
d5f74e42 8// This library is free software; you can redistribute it and/or modify it under
9// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1 10// by the Free Software Foundation, with special exception defined in the file
11// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12// distribution for complete text of the license and disclaimer of any warranty.
b311480e 13//
973c2be1 14// Alternatively, this file may be used under the terms of Open CASCADE
15// commercial license or contractual agreement.
7fd59977 16
7fd59977 17
42cf5bc1 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>
7fd59977 30#include <BRepAdaptor_Curve.hxx>
31#include <BRepAdaptor_HCurve.hxx>
42cf5bc1 32#include <BRepAdaptor_HCurve2d.hxx>
7fd59977 33#include <BRepAdaptor_HSurface.hxx>
42cf5bc1 34#include <BRepAdaptor_Surface.hxx>
35#include <BRepBlend_Line.hxx>
36#include <BRepLib_MakeFace.hxx>
7fd59977 37#include <BRepLProp_SLProps.hxx>
7fd59977 38#include <BRepTools.hxx>
39#include <BRepTools_WireExplorer.hxx>
42cf5bc1 40#include <BRepTopAdaptor_TopolTool.hxx>
41#include <ChFi3d.hxx>
42#include <ChFi3d_Builder.hxx>
43#include <ChFi3d_Builder_0.hxx>
44#include <ChFiDS_ChamfSpine.hxx>
7fd59977 45#include <ChFiDS_CommonPoint.hxx>
42cf5bc1 46#include <ChFiDS_ElSpine.hxx>
47#include <ChFiDS_ErrorStatus.hxx>
7fd59977 48#include <ChFiDS_FaceInterference.hxx>
7fd59977 49#include <ChFiDS_FilSpine.hxx>
7fd59977 50#include <ChFiDS_HData.hxx>
42cf5bc1 51#include <ChFiDS_HElSpine.hxx>
7fd59977 52#include <ChFiDS_ListIteratorOfListOfHElSpine.hxx>
42cf5bc1 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>
7fd59977 59#include <ChFiKPart_ComputeData.hxx>
42cf5bc1 60#include <ElCLib.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>
75#include <gp_Pln.hxx>
76#include <gp_Pnt.hxx>
77#include <gp_Pnt2d.hxx>
78#include <gp_Vec.hxx>
79#include <gp_XYZ.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>
91#include <TopAbs.hxx>
92#include <TopAbs_Orientation.hxx>
93#include <TopAbs_ShapeEnum.hxx>
94#include <TopExp.hxx>
95#include <TopExp_Explorer.hxx>
96#include <TopoDS.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>
7fd59977 105
0797d9d3 106#ifdef OCCT_DEBUG
7fd59977 107#ifdef DRAW
108#include <DrawTrSurf.hxx>
109#endif
110#include <OSD_Chronometer.hxx>
1d0a9d4d 111extern Standard_Real t_perfsetofkpart,t_perfsetofkgen,t_makextremities,t_performsurf,t_startsol;
112extern Standard_Boolean ChFi3d_GettraceCHRON();
113extern void ChFi3d_InitChron(OSD_Chronometer& ch);
114extern void ChFi3d_ResultChron(OSD_Chronometer & ch, Standard_Real& time);
7fd59977 115#endif
116
7fd59977 117
118//===================================================================
81bba717 119// Definition by a plane
7fd59977 120//
81bba717 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
7fd59977 124// par les points P1 et P2, T1 la tangente de E1 en P1 et T2 la tangente de
81bba717 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.
7fd59977 128//
129//====================================================================
130static 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() ) {
145 gp_Pnt P1,P2;
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();
151 gp_Vec t1,t2;
152 BCurv1.D1(parE1,P1,t1);
153 BCurv2.D1(parE2,P2,t2);
154 gp_Dir tgt1(t1);
155 gp_Dir tgt2(t2);
156 gp_Vec v12(P2.X()-P1.X(),P2.Y()-P1.Y(),P2.Z()-P1.Z());
157 gp_Dir d12(v12);
158 gp_Dir nor =tgt1.Crossed(d12);
159 Handle (Geom_Plane) Plan=new Geom_Plane(P1,nor);
160 Standard_Real scal;
161 scal=Abs(nor.Dot(tgt2));
162 if (scal<0.01) {
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);
169 Standard_Real u1,v1;
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();
180 }
181 else plane=Standard_False;
182 }
183 else plane=Standard_False;
184 }
185 else plane=Standard_False;
186}
187//=======================================================================
188//function : SortieTangente
189//purpose :
190//=======================================================================
191
192static 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)
197{
198 if(!CP.HasVector()) return Standard_False;
199 gp_Pnt P;
200 gp_Vec Darc, Dsurf;
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);
205 Dsurf = CP.Vector();
206 return Dsurf.IsParallel(Darc, TolAngular);
207}
208
209//=======================================================================
210//function : BonVoisin
211//purpose :
212//=======================================================================
213
214static Standard_Boolean BonVoisin(const gp_Pnt& Point,
215 Handle(BRepAdaptor_HSurface)& HS,
216 TopoDS_Face& F,
217 Handle(GeomAdaptor_HSurface)& plane,
218 const TopoDS_Edge& cured,
219 Standard_Real& XDep,
220 Standard_Real& YDep,
221 const ChFiDS_Map& EFMap,
222 const Standard_Real tolesp)
223{
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;
231
232 TopExp_Explorer Ex;
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);
241 if(ndist<dist){
242 TopTools_ListIteratorOfListOfShape It;
243 TopoDS_Face ff;
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;
7d92212e 253 Standard_Boolean istg = ChFi3d_isTangentFaces(ecur,ff,F);
7fd59977 254// Modified by Sergey KHROMOV - Fri Dec 21 17:12:51 2001 End
255 if((!issame || (issame && isreallyclosed)) && istg) {
256 found = 1;
257 TopoDS_Edge newe = ecur;
258 newe.Orientation(TopAbs_FORWARD);
259 dist = ndist;
260 HS->ChangeSurface().Initialize(ff);
261 if(isclosed && !isreallyclosed){
262 TopoDS_Face fff = ff;
263 fff.Orientation(TopAbs_FORWARD);
264 TopExp_Explorer Ex2;
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);
270 break;
271 }
272 }
273 }
274 else PC = BRep_Tool::CurveOnSurface(newe,ff,Uf,Ul);
275 PC->Value(winter).Coord(XDep,YDep);
276 if(issame){
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);
287 }
288 PC = BRep_Tool::CurveOnSurface(newe,fff,Uf,Ul);
289 PC->Value(winter).Coord(XDep, YDep);
290 }
291 break;
292 }
293 }
294 }
295 }
296 }
297 }
298 if(!found) bonvoisin = 0;
299 return bonvoisin;
300}
301
302//=======================================================================
303//function : Projection
81bba717 304//purpose : Projects a point on a curve
7fd59977 305//=======================================================================
306
307static Standard_Boolean Projection(Extrema_ExtPC& PExt,
308 const gp_Pnt& P,
309 const Adaptor3d_Curve& C,
310 Standard_Real& W,
311 Standard_Real Tol)
312{
313 Standard_Real Dist2, daux2;
314 Dist2 = C.Value(W).SquareDistance(P);
315
81bba717 316 // It is checked if it is not already a solution
7fd59977 317 if (Dist2 < Tol * Tol)
318 return Standard_True;
319
320 Standard_Boolean Ok = Standard_False;
321
322 // On essai une resolution initialise
323 Extrema_LocateExtPC ext(P,C,W,Tol/10);
324 if(ext.IsDone()) {
325 daux2 = C.Value(ext.Point().Parameter()).SquareDistance(P);
326 if (daux2 <Dist2 ) {
327 W = ext.Point().Parameter();
328 Dist2 = daux2;
329 Ok = Standard_True;
330 if (Dist2 < Tol * Tol)
331 return Standard_True;
332 }
333 }
334
81bba717 335 // Global resolution
7fd59977 336 PExt.Perform(P);
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();
342 Ok = Standard_True;
343 }
344 }
345 }
346 return Ok;
347}
348
349//=======================================================================
350//function : TgtKP
351//purpose :
352//=======================================================================
353
354static void TgtKP(const Handle(ChFiDS_SurfData)& CD,
355 const Handle(ChFiDS_Spine)& Spine,
356 const Standard_Integer iedge,
357 const Standard_Boolean isfirst,
358 gp_Pnt& ped,
359 gp_Vec& ded)
360{
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);
365 else{
366 bc.D1(-wtg+bc.LastParameter(),ped,ded);
367 ded.Reverse();
368 }
369 ded.Normalize();
370}
371
372//=======================================================================
373//function : IsInput
81bba717 374//purpose : Checks if a vector belongs to a Face
7fd59977 375//=======================================================================
376
377Standard_Boolean IsInput(const gp_Vec& Vec,
378 const TopoDS_Vertex& Ve,
379 const TopoDS_Face& Fa)
380{
381 TopExp_Explorer FaceExp(Fa, TopAbs_WIRE);
382 BRepTools_WireExplorer WireExp;
383 Standard_Integer Trouve = 0;
384 TopoDS_Wire W;
385 TopoDS_Edge E;
386 TopoDS_Vertex Vf, Vl;
387 gp_Vec Vec3d[2];
388 gp_Pnt Point;
389
81bba717 390 // Find edges and compute 3D vectors
7fd59977 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);
397 if (Vf.IsSame(Ve)) {
398 BRepAdaptor_Curve Cb(E);
399 Cb.D1(BRep_Tool::Parameter(Ve, E), Point, Vec3d[Trouve]);
400 Trouve++;
401 }
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();
406 Trouve++;
407 }
408 }
409 }
410 if (Trouve < 2) return Standard_False;
81bba717 411 // Calculate the normal and the angles in the asssociated vector plane
7fd59977 412 gp_Vec Normal;
413 Normal = Vec3d[0] ^ Vec3d[1];
81bba717 414 if (Normal.SquareMagnitude() < Precision::Confusion()) {//Colinear case
7fd59977 415 return (Vec.IsParallel(Vec3d[0],Precision::Confusion()));
416 }
417
418 Standard_Real amin, amax;
419 amax = Vec3d[1].AngleWithRef(Vec3d[0], Normal);
420 if (amax <0) {
421 amin = amax;
422 amax = 0;
423 }
424 else amin = 0;
425
81bba717 426 // Projection of the vector
7fd59977 427 gp_Ax3 Axe(Point, Normal, Vec3d[0]);
428 gp_Trsf Transf;
429 Transf.SetTransformation (Axe);
430 gp_XYZ coord = Vec.XYZ();
431 Transf.Transforms(coord);
432 coord.SetZ(0);
433 Transf.Invert();
434 Transf.Transforms(coord);
435 gp_Vec theProj(coord);
436
81bba717 437 // and finally...
7fd59977 438 Standard_Real Angle = theProj.AngleWithRef(Vec3d[0], Normal);
439 return ( (Angle >= amin) && (Angle<=amax));
440}
441
442//=======================================================================
443//function : IsG1
81bba717 444//purpose : Find a neighbor G1 by an edge
7fd59977 445//=======================================================================
446
447Standard_Boolean IsG1(const ChFiDS_Map& TheMap,
448 const TopoDS_Edge& E,
449 const TopoDS_Face& FRef,
450 TopoDS_Face& FVoi)
451{
452 TopTools_ListIteratorOfListOfShape It;
81bba717 453 // Find a neighbor of E different from FRef (general case).
7fd59977 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) {
7d92212e 459 if (ChFi3d_isTangentFaces(E,FRef,FVoi)) {
7fd59977 460// Modified by Sergey KHROMOV - Fri Dec 21 17:09:33 2001 End
461 return Standard_True;
462 }
463 }
464 }
81bba717 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).
7fd59977 467 TopExp_Explorer Ex;
468 Standard_Boolean orset = Standard_False;
7fd59977 469 TopAbs_Orientation orient = TopAbs_FORWARD ;
7fd59977 470 TopoDS_Edge ed;
471 for(Ex.Init(FRef,TopAbs_EDGE); Ex.More(); Ex.Next()){
472 ed = TopoDS::Edge(Ex.Current());
473 if(ed.IsSame(E)){
474 if(!orset){ orient = ed.Orientation(); orset = Standard_True; }
475 else if(ed.Orientation() == TopAbs::Reverse(orient)){
476 FVoi = FRef;
477// Modified by Sergey KHROMOV - Fri Dec 21 17:15:12 2001 Begin
478// if (BRep_Tool::Continuity(E,FRef,FRef) >= GeomAbs_G1) {
7d92212e 479 if (ChFi3d_isTangentFaces(E,FRef,FRef)) {
7fd59977 480// Modified by Sergey KHROMOV - Fri Dec 21 17:15:16 2001 End
481 return Standard_True;
482 }
483 return Standard_False;
484 }
485 }
486 }
487 return Standard_False;
488}
489
490//=======================================================================
491//function : SearchFaceOnV
81bba717 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
7fd59977 497//========================================================================
498static Standard_Integer SearchFaceOnV(const ChFiDS_CommonPoint& Pc,
499 const TopoDS_Face& FRef,
500 const ChFiDS_Map& VEMap,
501 const ChFiDS_Map& EFMap,
502 TopoDS_Face& F1,
503 TopoDS_Face& F2)
504{
81bba717 505 // it is checked that it leaves the current face.
7fd59977 506 Standard_Boolean FindFace = IsInput(Pc.Vector(), Pc.Vertex(), FRef);
507 if (FindFace) {
508 FindFace = IsInput(Pc.Vector().Reversed(), Pc.Vertex(), FRef);
509 }
81bba717 510 // If it does not leave, it is finished
7fd59977 511 if (FindFace) {
512 F1 = FRef;
513 return 1;
514 }
515 Standard_Integer Num = 0;
516 Standard_Boolean Trouve;
517 TopTools_ListIteratorOfListOfShape ItE, ItF;
518 TopoDS_Edge E;
519 TopoDS_Face FVoi;
520
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;
528 }
529 }
530 if (Trouve) Trouve = IsG1(EFMap, E, FRef, FVoi);
531 if (Trouve) Trouve = IsInput(Pc.Vector(), Pc.Vertex(), FVoi);
532 if (Trouve) {
533 if (Num == 0) F1 = FVoi;
534 else F2 = FVoi;
535 Num++;
536 }
537 }
538 return Num;
539}
540
541//=======================================================================
542//function : ChangeTransition
81bba717 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.
7fd59977 547//========================================================================
548static void ChangeTransition(const ChFiDS_CommonPoint& Precedant,
549 ChFiDS_CommonPoint& Courant,
550 Standard_Integer FaceIndex,
551 const Handle(TopOpeBRepDS_HDataStructure)& DS)
552{
553 Standard_Boolean tochange = Standard_True;
554 Standard_Real f,l;
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) {
81bba717 563 // This is a cutting edge, it is necessary to make a small Geometric test
7fd59977 564 gp_Vec tgarc;
565 gp_Pnt P;
566 BRepAdaptor_Curve AC(Arc);
567 AC.D1(Precedant.ParameterOnArc(), P, tgarc);
568 tochange = tgarc.IsParallel(Precedant.Vector(), Precision::Confusion());
569 }
570
571 if (tochange)
572 Courant.SetArc(Precision::Confusion(),
573 Arc,
574 Precedant.ParameterOnArc(),
575 TopAbs::Reverse(Precedant.TransitionOnArc()));
576
577}
578
579//=======================================================================
580//function : CallPerformSurf
81bba717 581//purpose : Encapsulates call to PerformSurf/SimulSurf
7fd59977 582//========================================================================
583
584void ChFi3d_Builder::
585CallPerformSurf(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,
593 const gp_Pnt2d& pp1,
594 const gp_Pnt2d& pp3,
543a9964 595 const Handle(Adaptor3d_TopolTool)& It1,
7fd59977 596 const Handle(BRepAdaptor_HSurface)& HS2,
597 const Handle(BRepAdaptor_HSurface)& HS4,
598 const gp_Pnt2d& pp2,
599 const gp_Pnt2d& pp4,
543a9964 600 const Handle(Adaptor3d_TopolTool)& It2,
7fd59977 601 const Standard_Real MaxStep,
602 const Standard_Real Fleche,
603 const Standard_Real /*TolGuide*/,
604 Standard_Real& First,
605 Standard_Real& Last,
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,
611 math_Vector& Soldep,
612 Standard_Boolean& intf,
613 Standard_Boolean& intl,
614 Handle(BRepAdaptor_HSurface)& Surf1,
615 Handle(BRepAdaptor_HSurface)& Surf2)
616{
0797d9d3 617#ifdef OCCT_DEBUG
7fd59977 618 OSD_Chronometer ch1;
619#endif
620 Handle(BRepAdaptor_HSurface) HSon1, HSon2;
621 HSon1 = HS1;
622 HSon2 = HS2;
81bba717 623 // Definition of the domain of path It1, It2
543a9964 624 It1->Initialize((const Handle(Adaptor3d_HSurface)&)HSon1);
625 It2->Initialize((const Handle(Adaptor3d_HSurface)&)HSon2);
7fd59977 626
627
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(),
634 Stripe->Choix());
635 Soldep(1) = pp1.X(); Soldep(2) = pp1.Y();
636 Soldep(3) = pp2.X(); Soldep(4) = pp2.Y();
637
638 Standard_Real thef = First, thel = Last;
639 Standard_Boolean isdone;
640
641 if(Simul){
642 isdone = SimulSurf(SD,HGuide,Spine,Choix,HS1,It1,HS2,It2,tolesp,First,Last,
643 Inside,Inside,forward,RecOnS1,RecOnS2,Soldep,intf,intl);
644 }
645 else{
646
0797d9d3 647#ifdef OCCT_DEBUG
81bba717 648 ChFi3d_InitChron(ch1);//initial perform for PerformSurf
7fd59977 649#endif
650
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);
0797d9d3 655#ifdef OCCT_DEBUG
81bba717 656 ChFi3d_ResultChron(ch1,t_performsurf);// result perf for PerformSurf
7fd59977 657#endif
658 }
659
81bba717 660 // Case of error
7fd59977 661 if (!isdone) {
662 First = thef;
663 Last = thel;
664 Standard_Boolean reprise = Standard_False;
665 if (! HS3.IsNull()) {
666 HSon1 = HS3;
543a9964 667 It1->Initialize((const Handle(Adaptor3d_HSurface)&)HS3);
7fd59977 668 Or1 = HS3->ChangeSurface().Face().Orientation();
669 Soldep(1) = pp3.X(); Soldep(2) = pp3.Y();
670 reprise = Standard_True;
671 }
672 else if (! HS4.IsNull()) {
673 HSon2 = HS4;
543a9964 674 It2->Initialize((const Handle(Adaptor3d_HSurface)&)HS4);
7fd59977 675 Or2 = HS4->ChangeSurface().Face().Orientation();
676 Soldep(3) = pp4.X(); Soldep(4) = pp4.Y();
677 reprise = Standard_True;
678 }
679
680 if (reprise) {
681 Choix = ChFi3d::NextSide(Or1,Or2,
682 Stripe->OrientationOnFace1(),
683 Stripe->OrientationOnFace2(),
684 Stripe->Choix());
685 if(Simul){
686 isdone = SimulSurf(SD,HGuide,Spine,Choix,HSon1,It1,HSon2,It2,
687 tolesp,First,Last,
688 Inside,Inside,forward,RecOnS1,RecOnS2,
689 Soldep,intf,intl);
690 }
691 else{
692
0797d9d3 693#ifdef OCCT_DEBUG
81bba717 694 ChFi3d_InitChron(ch1);//init perf for PerformSurf
7fd59977 695#endif
696
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);
0797d9d3 701#ifdef OCCT_DEBUG
81bba717 702 ChFi3d_ResultChron(ch1,t_performsurf);// result perf for PerformSurf
7fd59977 703#endif
704 }
705 }
706 }
707 Surf1 = HSon1;
708 Surf2 = HSon2;
709}
710
711//=======================================================================
712//function : StripeOrientation
81bba717 713//purpose : Calculates the reference orientation determining the
714// concave face for construction of the fillet.
7fd59977 715//=======================================================================
716
717Standard_Boolean ChFi3d_Builder::StripeOrientations
718(const Handle(ChFiDS_Spine)& Spine,
719 TopAbs_Orientation& Or1,
720 TopAbs_Orientation& Or2,
721 Standard_Integer& ChoixConge) const
722{
723 //TopTools_ListIteratorOfListOfShape It;
724 BRepAdaptor_Surface Sb1,Sb2;
725 TopAbs_Orientation Of1,Of2;
726 TopoDS_Face ff1,ff2;
727 ChFi3d_conexfaces(Spine->Edges(1),ff1,ff2,myEFMap);
728 Of1 = ff1.Orientation();
729 ff1.Orientation(TopAbs_FORWARD);
730 Sb1.Initialize(ff1);
731 Of2 = ff2.Orientation();
732 ff2.Orientation(TopAbs_FORWARD);
733 Sb2.Initialize(ff2);
734
735 ChoixConge = ChFi3d::ConcaveSide(Sb1,Sb2,Spine->Edges(1),
736 Or1,Or2);
737 Or1 = TopAbs::Compose(Or1,Of1);
738 Or2 = TopAbs::Compose(Or2,Of2);
739 return Standard_True;
740}
741
742
743//=======================================================================
744//function : ConexFaces
745//purpose :
746//=======================================================================
747
748void 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
753{
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();
758
759 TopoDS_Face ff1,ff2;
760 ChFi3d_conexfaces(Spine->Edges(IEdge),ff1,ff2,myEFMap);
761
762 Sb1.Initialize(ff1);
763 Sb2.Initialize(ff2);
764
765 TopAbs_Orientation Or1,Or2;
766 Standard_Integer Choix = ChFi3d::ConcaveSide(Sb1,Sb2,Spine->Edges(IEdge),
767 Or1,Or2);
768 if (RC%2 != Choix%2) {
769 Sb1.Initialize(ff2);
770 Sb2.Initialize(ff1);
771 }
772}
773
774//=======================================================================
775//function : StartSol
81bba717 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.
7fd59977 781//=======================================================================
782
783void 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,
789 gp_Pnt2d& P1,
790 gp_Pnt2d& P2,
791 Standard_Real& First) const
792{
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;
7fd59977 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);
803
7fd59977 804 Standard_Real TolE = 1.0e-7;
7fd59977 805 BRepAdaptor_Surface AS;
806
807 Standard_Integer nbessai;
808 Standard_Integer iedge = 0;
809 Standard_Integer RC = Stripe->Choix();
810 gp_Vec2d derive;
811 gp_Pnt2d P2d;
812 TopoDS_Edge cured;
813 TopoDS_Face f1,f2;
814 TopAbs_Orientation Or1,Or2;
7fd59977 815 Standard_Integer Choix = 0;
7fd59977 816 math_Vector SolDep(1,4);
817 Handle(Geom2d_Curve) PC;
818 Extrema_ExtPC PExt;
819 PExt.Initialize(els,
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);
828 if(iedge != ie){
829 iedge = ie;
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(),
840 RC);
841 }
842
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);
543a9964 850 I1->Initialize((const Handle(Adaptor3d_HSurface)&)HS1);
7fd59977 851 PC->D1(woned, P1, derive);
81bba717 852 // There are ponts on the border, and internal points are found
7fd59977 853 if (derive.Magnitude() > Precision::PConfusion()) {
854 derive.Normalized();
c6541a0c 855 derive.Rotate(M_PI/2);
7fd59977 856 AS.Initialize(f1);
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) {
862 P1 = P2d;
863 }
864 else {
865 P2d = P1.Translated(-derive);
866 if (I1->Classify(P2d, Min(ResU, ResV), 0)== TopAbs_IN) {
867 P1 = P2d;
868 }
869 }
870 }
871 if(f1.IsSame(f2)) cured.Orientation(TopAbs_REVERSED);
872 PC = BRep_Tool::CurveOnSurface(cured,f2forward,Uf,Ul);
873 P2 = PC->Value(woned);
543a9964 874 const Handle(Adaptor3d_HSurface)& HSon2 = HS2; // to avoid ambiguity
875 I2->Initialize(HSon2);
7fd59977 876
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);
881
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));
887 First = w;
888 return;
889 }
890 }
81bba717 891 // No solution was found for the faces adjacent to the trajectory.
892 // Now one tries the neighbor faces.
7fd59977 893 iedge = 0;
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(),
907 RC);
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);
543a9964 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);
7fd59977 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);
926// if(ext.IsDone()){
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);
931 gp_Pnt P;
932 gp_Vec V;
933 HGuide->D1(w,P,V);
934 Handle(Geom_Plane) pl = new Geom_Plane(P,V);
935 Handle(GeomAdaptor_HSurface) plane = new GeomAdaptor_HSurface(pl);
936
937 Standard_Boolean bonvoisin = 1, found = 0;
938 Standard_Integer NbChangement;
939 for (NbChangement = 1; bonvoisin && (!found) && (NbChangement < 5);
940 NbChangement++) {
941 if(Pos1 != TopAbs_IN){
942 bonvoisin = BonVoisin(P, HS1, f1, plane, cured,
943 SolDep(1),SolDep(2), myEFMap, tolesp);
944 }
945 if(Pos2 != TopAbs_IN && bonvoisin){
946 bonvoisin = BonVoisin(P, HS2, f2, plane, cured,
947 SolDep(3),SolDep(4), myEFMap, tolesp);
948 }
949 if(bonvoisin){
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(),
957 RC);
543a9964 958 const Handle(Adaptor3d_HSurface)& HSon1 = HS1; // to avoid ambiguity
959 const Handle(Adaptor3d_HSurface)& HSon2 = HS2; // to avoid ambiguity
960 I1->Initialize(HSon1);
961 I2->Initialize(HSon2);
7fd59977 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));
966 First = w;
967 found = Standard_True;
968 }
969 }
970 }
971 if (found) return;
972 }
973 }
974 Spine->SetErrorStatus(ChFiDS_StartsolFailure);
975 Standard_Failure::Raise("StartSol echec");
976}
977
978//=======================================================================
979//function : ChFi3d_BuildPlane
980//purpose :
981//=======================================================================
982
983static void ChFi3d_BuildPlane (TopOpeBRepDS_DataStructure& DStr,
984 Handle(BRepAdaptor_HSurface)& HS,
985 gp_Pnt2d& pons,
986 const Handle(ChFiDS_SurfData)& SD,
987 const Standard_Boolean isfirst,
988 const Standard_Integer ons)
989{
990 Handle(Geom2d_Curve) Hc;
991 TopoDS_Face F = TopoDS::Face(DStr.Shape(SD->Index(ons)));
992 Standard_Real u,v;
993 gp_Pnt P;
994 //gp_Vec V1,V2;
995
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());
1c72dff6 1004 TopoDS_Face NewF = BRepLib_MakeFace(Pln, Precision::Confusion());
7fd59977 1005 NewF.Orientation(F.Orientation());
1006 pons.SetCoord(0.,0.);
1007 HS->ChangeSurface().Initialize(NewF);
81bba717 1008 return; // everything is good !
7fd59977 1009 }
1010 }
1011 Standard_Failure::Raise("ChFi3d_BuildPlane : echec .");
1012}
1013
1014//=======================================================================
1015//function : StartSol
81bba717 1016//purpose : If the commonpoint is not OnArc the input face
1017// is returned and 2D point is updated,
1018// if it is OnArc
1019// if it is detached the input face
1020// is returned and 2D point is updated,
1021// otherwise
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.
7fd59977 1028//=======================================================================
1029
1030Standard_Boolean
1031ChFi3d_Builder::StartSol(const Handle(ChFiDS_Spine)& Spine,
81bba717 1032 Handle(BRepAdaptor_HSurface)& HS, // New face
1033 gp_Pnt2d& pons,// " Localization
1034 Handle(BRepAdaptor_HCurve2d)& HC, // Representation of the obstacle
7fd59977 1035 Standard_Real& W,
1036 const Handle(ChFiDS_SurfData)& SD,
1037 const Standard_Boolean isfirst,
1038 const Standard_Integer ons,
81bba717 1039 Handle(BRepAdaptor_HSurface)& HSref, // The other representation
1040 Handle(BRepAdaptor_HCurve2d)& HCref, // of the obstacle
7fd59977 1041 Standard_Boolean& RecP,
1042 Standard_Boolean& RecS,
1043 Standard_Boolean& RecRst,
1044 Standard_Boolean& c1obstacle,
81bba717 1045 Handle(BRepAdaptor_HSurface)& HSBis, // Face of support
1046 gp_Pnt2d& PBis, // and its point
7fd59977 1047 const Standard_Boolean decroch,
1048 const TopoDS_Vertex& Vref) const
1049{
1050 RecRst = RecS = RecP = c1obstacle = 0;
1051 TopOpeBRepDS_DataStructure& DStr = myDS->ChangeDS();
1052 TopoDS_Face Fv,Fref;
1053 //gp_Pnt2d pp1,pp2;
1054 Handle(Geom2d_Curve) pc;
1055 Standard_Real Uf,Ul;
1056
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);
1060 HSBis.Nullify();
1061
1062 if (CP.IsOnArc()) {
1063 Standard_Integer notons;
1064 if (ons == 1) notons = 2;
1065 else notons = 1;
1066 const ChFiDS_CommonPoint& CPbis = SD->Vertex(isfirst,notons);
81bba717 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.
7fd59977 1071 Standard_Real ts=SD->Interference(ons).Parameter(isfirst), tns=SD->Interference(notons).Parameter(isfirst);
1072 Standard_Boolean isExtend;
81bba717 1073 // Arbitrary test (to precise)
7fd59977 1074 if (isfirst) isExtend = (ts-tns > 100*tolesp);
1075 else isExtend = (tns-ts > 100*tolesp);
1076 if (isExtend && !CP.Point().IsEqual(CPbis.Point(), 0) ) {
81bba717 1077 // the state is preserved and False is returned (extension by the expected plane).
7fd59977 1078 HS->ChangeSurface().Initialize(F);
1079 pc = SD->Interference(ons).PCurveOnFace();
81bba717 1080 // The 2nd point is given by its trace on the support surface
7fd59977 1081 RecS = Standard_False;
1082 pons = pc->Value(tns);
1083 return Standard_False;
1084 }
1085 }
1086 }
1087
1088 if (CP.IsVertex() && !HC.IsNull() && !decroch){
81bba717 1089 //The edge is changed, the parameter is updated and
1090 //eventually the support face and(or) the reference face.
7fd59977 1091 TopoDS_Vertex VCP = CP.Vertex();
1092 TopoDS_Edge EHC = HC->ChangeCurve2d().Edge();
81bba717 1093 //One starts by searching in Fref another edge referencing VCP.
7fd59977 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)){
1105 edgereg = cured;
1106 facereg = Fv;
1107 }
1108 else found = 1;
1109 }
1110 }
1111 }
1112 if(found) {
1113 newedge = cured;
1114 break;
1115 }
1116 }
1117 if(newedge.IsNull()){
81bba717 1118 //It is checked if EHC is not a closed edge.
7fd59977 1119 TopoDS_Vertex V1,V2;
1120 TopExp::Vertices(EHC,V1,V2);
1121 if(V1.IsSame(V2)){
1122 newedge = EHC;
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);
1128
1129 gp_Pnt2d pww;
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);
1134
1135 if(p1.Distance(pww) > p2.Distance(pww)){
1136 W = w1;
1137 pons = p1;
1138 }
1139 else {
1140 W = w2;
1141 pons = p2;
1142 }
1143 RecP = c1obstacle = 1;
1144 return 1;
1145 }
1146 else if(!edgereg.IsNull()){
81bba717 1147 // the reference edge and face are changed.
7fd59977 1148 Fref = facereg;
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)){
1156 newedge = cured;
1157 }
1158 }
1159 }
1160 }
1161 }
1162 }
1163 }
81bba717 1164 // it is necessary to find the new support face of the fillet :
1165 // connected to FRef along the newedge.
7fd59977 1166 if(newedge.IsNull()) {
1167 Standard_Failure::Raise
81bba717 1168 ("StartSol : chain is not possible, new obstacle not found");
7fd59977 1169 }
1170 if(IsG1(myEFMap,newedge,Fref,Fv)){
1171 Standard_Failure::Raise
81bba717 1172 ("StartSol : chain is not possible, config non processed");
7fd59977 1173 }
1174 else if(Fv.IsNull()){
1175 Standard_Failure::Raise
81bba717 1176 ("StartSol : chain is not possible, new obstacle not found");
7fd59977 1177 }
1178 else{
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);
1184 TopExp_Explorer ex;
1185 for(ex.Init(newface,TopAbs_EDGE); ex.More(); ex.Next()){
1186 if(ex.Current().IsSame(newedge)){
1187 newedge = TopoDS::Edge(ex.Current());
1188 break;
1189 }
1190 }
1191 HC->ChangeCurve2d().Initialize(newedge,Fv);
1192 pons = HC->Value(W);
1193 }
1194 RecP = c1obstacle = 1;
1195 return 1;
81bba717 1196 } // End of Case Vertex && Obstacle
7fd59977 1197
1198 else if (CP.IsOnArc() && !HC.IsNull() && !decroch){
81bba717 1199 //Nothing is changed, the parameter is only updated.
7fd59977 1200 W = CP.ParameterOnArc();
1201 c1obstacle = 1;
1202 return 1;
1203 }
1204
1205 HC.Nullify();
1206
1207 if (CP.IsOnArc()){
1208 const TopoDS_Edge& E = CP.Arc();
1209 if(decroch){
1210 HS->ChangeSurface().Initialize(Fref);
1211 W = CP.ParameterOnArc();
1212 pc = BRep_Tool::CurveOnSurface(E,Fref,Uf,Ul);
1213 pons = pc->Value(W);
1214 RecS = 1;
1215 return 1;
1216 }
1217 if (SearchFace(Spine,CP,F,Fv)){
1218 HS->ChangeSurface().Initialize(Fv);
1219 RecS = 1;
1220 if (CP.IsVertex()) {
81bba717 1221 // One goes directly by the Vertex
7fd59977 1222 Standard_Integer Nb;
1223 TopoDS_Face aux;
81bba717 1224 // And it is checked that there are no other candidates
7fd59977 1225 Nb = SearchFaceOnV(CP, F, myVEMap, myEFMap, Fv, aux);
1226
1227 pons = BRep_Tool::Parameters(CP.Vertex(), Fv);
1228 HS->ChangeSurface().Initialize(Fv);
1229 if (Nb >=2) {
1230 HSBis = new (BRepAdaptor_HSurface)(aux);
1231 PBis = BRep_Tool::Parameters(CP.Vertex(), aux);
1232 }
1233 return 1;
1234 }
81bba717 1235 // otherwise one passes by the arc...
7fd59977 1236 if(!Fv.IsSame(F)){
1237 Fv.Orientation(TopAbs_FORWARD);
1238 TopoDS_Edge newedge;
1239 TopExp_Explorer ex;
1240 for(ex.Init(Fv,TopAbs_EDGE); ex.More(); ex.Next()){
1241 if(ex.Current().IsSame(E)){
1242 newedge = TopoDS::Edge(ex.Current());
1243 break;
1244 }
1245 }
1246 //gp_Vec Varc, VSurf;
81bba717 1247 // In cas of Tangent output, the current face becomes the support face
7fd59977 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());
1252 }
1253
1254
1255 pc = BRep_Tool::CurveOnSurface(newedge,Fv,Uf,Ul);
1256 }
1257 else{
1258 TopoDS_Edge newedge = E;
1259 newedge.Reverse();
1260 Fv.Orientation(TopAbs_FORWARD);
1261 pc = BRep_Tool::CurveOnSurface(newedge,Fv,Uf,Ul);
1262 }
1263 pons = pc->Value(CP.ParameterOnArc());
1264 return 1;
1265 }
1266 else if(!Fv.IsNull()){
1267 c1obstacle = 1;
1268 if(!Vref.IsNull()){
1269 TopExp_Explorer ex;
1270 for(ex.Init(E,TopAbs_VERTEX); ex.More(); ex.Next()){
1271 if(ex.Current().IsSame(Vref)){
1272 c1obstacle = 0;
1273 break;
1274 }
1275 }
1276 }
1277 if(c1obstacle){
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);
1285 TopExp_Explorer ex;
1286 for(ex.Init(newface,TopAbs_EDGE); ex.More(); ex.Next()){
1287 if(ex.Current().IsSame(E)){
1288 newedge = TopoDS::Edge(ex.Current());
1289 break;
1290 }
1291 }
1292 HC->ChangeCurve2d().Initialize(newedge,Fv);
1293 pons = HC->Value(W);
1294 HCref->ChangeCurve2d().Initialize(E,F);
1295 if(CP.IsVertex()) RecP = 1;
1296 else RecRst = 1;
1297 return 1;
1298 }
1299 else{
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;
1305 }
1306 }
81bba717 1307 else{ // there is no neighbor face, the state is preserved and False is returned.
7fd59977 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;
1313 }
1314 }
1315 else{
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));
1320 }
1321 return Standard_True;
1322}
1323
1324//=======================================================================
1325//function : SearchFace
1326//purpose :
1327//=======================================================================
1328
1329Standard_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
1334{
1335 Standard_Boolean Trouve = Standard_False;
1336 if (! Pc.IsOnArc()) return Standard_False;
1337 FVoi.Nullify();
1338 TopoDS_Edge E;
1339 if (Pc.IsVertex()){
81bba717 1340 // attention it is necessary to analyze all faces that turn around of the vertex
0797d9d3 1341#ifdef OCCT_DEBUG
81bba717 1342 cout<<"Commonpoint on vertex, the process hangs up"<<endl;
7fd59977 1343#endif
81bba717 1344 if (Pc.HasVector()) { //General processing
7fd59977 1345 TopoDS_Face Fbis;
1346 Standard_Integer nb_faces;
1347 nb_faces = SearchFaceOnV(Pc, FRef, myVEMap, myEFMap, FVoi, Fbis);
1348 return ( nb_faces > 0);
1349 }
81bba717 1350 else { // Processing using the spine
7fd59977 1351 Standard_Boolean FindFace=Standard_False;
1352 gp_Pnt Point;
1353 gp_Vec VecSpine;
1354 Spine->D1(Pc.Parameter(), Point, VecSpine);
1355
81bba717 1356 // It is checked if one leaves from the current face.
7fd59977 1357 FindFace = IsInput(VecSpine, Pc.Vertex(), FRef);
1358 if (FindFace) {
1359 VecSpine.Reverse();
1360 FindFace = IsInput(VecSpine, Pc.Vertex(), FRef);
1361 }
81bba717 1362 // If one does not leave, it is ended
7fd59977 1363 if (FindFace) {
1364 FVoi = FRef;
1365 return Standard_True;
1366 }
1367
81bba717 1368 // Otherwise one finds the next among shared Faces
1369 // by a common edge G1
7fd59977 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;
1379 }
1380 }
1381 if (Trouve) FindFace = IsG1(myEFMap, E, FRef, FVoi);
1382 if (FindFace) {
1383 FindFace = Standard_False;
1384 if (Spine.IsNull()) {
1385 //La Spine peut etre nulle (ThreeCorner)
0797d9d3 1386#ifdef OCCT_DEBUG
7fd59977 1387 cout << "FindFace sur vertex avec spine nulle! QUEZAKO ?" << endl;
1388#endif
1389 return Standard_False;
1390 }
1391
81bba717 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
7fd59977 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;
1406 }
1407 }
1408 }
1409 }
1410 FindFace = Trouve;
1411 }
1412 }
1413 }
1414 }
1415 else {
1416 return IsG1(myEFMap, Pc.Arc(), FRef, FVoi);
1417 }
1418 return Standard_False;
1419}
1420
1421
1422//=======================================================================
1423//function : ChFi3d_SingularExtremity
81bba717 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.
7fd59977 1427//=======================================================================
1428static 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)
1433{
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;
81bba717 1441 // SurfData and its CommonPoints,
7fd59977 1442 Standard_Integer Ivtx, Icurv;
1443 Standard_Boolean isfirst;
1444
1445 if (stripe->Spine()->IsPeriodic()) {
1446 isfirst = Standard_True;
1447 Fd = stripe->SetOfSurfData()->Sequence().First();
1448 }
1449 else {
1450 Standard_Integer sens;
1451 Standard_Integer num = ChFi3d_IndexOfSurfData(Vtx,stripe,sens);
1452 Fd = stripe->SetOfSurfData()->Sequence().Value(num);
1453 isfirst = (sens == 1);
1454 }
1455
1456 const ChFiDS_CommonPoint& CV1 = Fd->Vertex(isfirst,1);
1457 const ChFiDS_CommonPoint& CV2 = Fd->Vertex(isfirst,2);
81bba717 1458 // Is it always degenerated ?
7fd59977 1459 if ( CV1.Point().IsEqual( CV2.Point(), 0) ) {
1460 Ivtx = ChFi3d_IndexPointInDS(CV1, DStr);
1461 if (isfirst) {
1462 VOnS1 = Fd->InterferenceOnS1().PCurveOnSurf()->
1463 Value(Fd->InterferenceOnS1().FirstParameter());
1464 VOnS2 = Fd->InterferenceOnS2().PCurveOnSurf()->
1465 Value(Fd->InterferenceOnS2().FirstParameter());
1466 }
1467 else {
1468 VOnS1 = Fd->InterferenceOnS1().PCurveOnSurf()->
1469 Value(Fd->InterferenceOnS1().LastParameter());
1470 VOnS2 = Fd->InterferenceOnS2().PCurveOnSurf()->
1471 Value(Fd->InterferenceOnS2().LastParameter());
1472 }
1473
1474 ChFi3d_ComputeArete(CV1, VOnS1,
1475 CV2, VOnS2,
1476 DStr.Surface(Fd->Surf()).Surface(),
1477 C3d, PCurv,
1478 Pardeb,Parfin, tol3d, tol2d, tolreached,0);
1479 Crv = TopOpeBRepDS_Curve(C3d,tolreached);
1480 Icurv = DStr.AddCurve(Crv);
1481
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);
1487
1488 if (stripe->Spine()->IsPeriodic()) {
81bba717 1489 // periodic case : The operation is renewed
1490 // the curve 3d is not shared.
1491 // 2 degenerated edges coinciding in 3d
7fd59977 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());
1498
1499 ChFi3d_ComputeArete(CV1, VOnS1,
1500 CV2, VOnS2,
1501 DStr.Surface(Fd->Surf()).Surface(),
1502 C3d, PCurv,
1503 Pardeb,Parfin, tol3d, tol2d, tolreached,0);
1504 Crv = TopOpeBRepDS_Curve(C3d,tolreached);
1505 Icurv = DStr.AddCurve(Crv);
1506
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);
1512 }
1513 }
1514}
1515
1516//=======================================================================
1517//function : ChFi3d_MakeExtremities
81bba717 1518//purpose : calculate Curves3d and pcurves of extremities in
1519// periodic and freeboundary cases.
7fd59977 1520//=======================================================================
1521static Standard_Boolean IsFree(const TopoDS_Shape& E,
1522 const ChFiDS_Map& EFMap)
1523{
1524 if(!EFMap.Contains(E)) return 0;
1525 TopTools_ListIteratorOfListOfShape It;
1526 TopoDS_Shape Fref;
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;
1530 }
1531 return 1;
1532}
1533
1534static 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)
1539{
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()){
1545 Bnd_Box b1,b2;
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()),
1554 CV2,
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());
1572
1573 const Handle(ChFiDS_SurfData)&
1574 SDL = Stripe->SetOfSurfData()->Sequence().Last();
1575
1576
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));
1587 if(CV1.IsOnArc()){
1588 ChFi3d_EnlargeBox(CV1.Arc(),EFMap(CV1.Arc()),CV1.ParameterOnArc(),b1);
1589 }
1590
1591 if(CV2.IsOnArc()){
1592 ChFi3d_EnlargeBox(CV2.Arc(),EFMap(CV2.Arc()),CV2.ParameterOnArc(),b2);
1593 }
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());
1600 }
1601 else {
81bba717 1602 // Case of the single extremity
7fd59977 1603 if (CV1.IsVertex()) {
1604 ChFi3d_SingularExtremity(Stripe, DStr, CV1.Vertex(), tol3d, tol2d);
1605 }
63c629aa 1606# if CHFI3D_DEB
81bba717 1607 else { cout << "MakeExtremities : Singularity out of Vertex !!" << endl; }
7fd59977 1608# endif
1609 }
1610 return;
1611 }
1612
1613 const Handle(ChFiDS_SurfData)&
1614 SDdeb = Stripe->SetOfSurfData()->Sequence().First();
1615
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));
1621 }
1622 if(freedeb){
1623 sp->SetFirstStatus(ChFiDS_FreeBoundary);
1624 Bnd_Box b1,b2;
1625 if ( !cpdeb1.Point().IsEqual(cpdeb2.Point(), 0) ) {
1626 Standard_Boolean plane;
1627 gp_Pnt2d UV1,UV2;
1628 UV1=SDdeb->InterferenceOnS1().PCurveOnSurf()->
1629 Value(SDdeb->InterferenceOnS1().FirstParameter());
1630 UV2=SDdeb->InterferenceOnS2().PCurveOnSurf()->
1631 Value(SDdeb->InterferenceOnS2().FirstParameter());
81bba717 1632// The intersection of the fillet by a plane is attempted
7fd59977 1633
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);
1638 if (!plane)
1639 ChFi3d_ComputeArete(cpdeb1,
1640 SDdeb->InterferenceOnS1().PCurveOnSurf()->
1641 Value(SDdeb->InterferenceOnS1().FirstParameter()),
1642 cpdeb2,
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);
1657 }
1658 if(cpdeb2.IsOnArc()){
1659 ChFi3d_EnlargeBox(cpdeb2.Arc(),EFMap(cpdeb2.Arc()),cpdeb2.ParameterOnArc(),b2);
1660 }
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());
1666 }
81bba717 1667 else { // Case of a singular extremity
7fd59977 1668 if (cpdeb1.IsVertex()) {
1669 ChFi3d_SingularExtremity(Stripe, DStr, cpdeb1.Vertex(), tol3d, tol2d);
1670 }
63c629aa 1671# if CHFI3D_DEB
81bba717 1672 else { cout << "MakeExtremities : Singularity out of Vertex !!" << endl; }
7fd59977 1673# endif
1674 }
1675 }
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));
1683 }
1684 if(freefin){
1685 sp->SetLastStatus(ChFiDS_FreeBoundary);
1686 Bnd_Box b1,b2;
1687 if ( !cpfin1.Point().IsEqual(cpfin2.Point(), 0) ) {
1688 Standard_Boolean plane;
1689 gp_Pnt2d UV1,UV2;
1690 UV1=SDfin->InterferenceOnS1().PCurveOnSurf()->
1691 Value(SDfin->InterferenceOnS1().LastParameter());
1692 UV2=SDfin->InterferenceOnS2().PCurveOnSurf()->
1693 Value(SDfin->InterferenceOnS2().LastParameter());
81bba717 1694// Intersection of the fillet by a plane is attempted
7fd59977 1695
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);
1700 if (!plane)
1701 ChFi3d_ComputeArete(cpfin1,
1702 SDfin->InterferenceOnS1().PCurveOnSurf()->
1703 Value(SDfin->InterferenceOnS1().LastParameter()),
1704 cpfin2,
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);
1719 }
1720 if(cpfin2.IsOnArc()){
1721 ChFi3d_EnlargeBox(cpfin2.Arc(),EFMap(cpfin2.Arc()),cpfin2.ParameterOnArc(),b2);
1722 }
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());
1728 }
81bba717 1729 else { // Case of the single extremity
7fd59977 1730 if (cpfin1.IsVertex()) {
1731 ChFi3d_SingularExtremity(Stripe, DStr, cpfin1.Vertex(), tol3d, tol2d);
1732 }
63c629aa 1733# if CHFI3D_DEB
81bba717 1734 else { cout << "MakeExtremities : Singularity out of Vertex !!" << endl; }
7fd59977 1735# endif
1736 }
1737 }
1738}
1739
1740//=======================================================================
1741//function : ChFi3d_Purge
1742//purpose :
1743//=======================================================================
1744
1745static 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)
1752{
81bba717 1753 if (isfirst) intf = 1; else intl = 1; // End.
7fd59977 1754 Standard_Integer opp = 3-ons;
1755 if (!SD->Vertex(isfirst,opp).IsOnArc() ||
1756 SD->TwistOnS1() || SD->TwistOnS2() ) {
0797d9d3 1757#ifdef OCCT_DEBUG
81bba717 1758 cout<<"ChFi3d_Purge : No output on extension."<<endl;
7fd59977 1759#endif
1760 ChFiDS_SequenceOfSurfData& Seq =
1761 Stripe->ChangeSetOfSurfData()->ChangeSequence();
1762 if(isfirst) Seq.Remove(1);
1763 else Seq.Remove(Seq.Length());
1764 return;
1765 }
1766 if (ons == 1) SD->ChangeIndexOfS1(0);
1767 else SD->ChangeIndexOfS2(0);
1768
1769 SD->ChangeVertex(!isfirst,ons) = VRef;
1770 SD->ChangeVertex(isfirst,ons) = VRef;
1771
1772 ChFiDS_FaceInterference& fi = SD->ChangeInterference(ons);
1773 if(isfirst) fi.SetFirstParameter(fi.LastParameter());
1774 else fi.SetLastParameter(fi.FirstParameter());
1775 fi.SetLineIndex(0);
1776}
1777
1778//=======================================================================
1779//function : InsertAfter
81bba717 1780//purpose : insert Item after ref in Seq. If ref is null, the item is
1781// inserted at the beginning.
7fd59977 1782//=======================================================================
1783
1784static void InsertAfter (Handle(ChFiDS_Stripe)& Stripe,
1785 Handle(ChFiDS_SurfData)& Ref,
1786 Handle(ChFiDS_SurfData)& Item)
1787{
1788 if (Ref == Item)
81bba717 1789 Standard_Failure::Raise("InsertAfter : twice the same surfdata.");
7fd59977 1790
1791 ChFiDS_SequenceOfSurfData& Seq =
1792 Stripe->ChangeSetOfSurfData()->ChangeSequence();
1793
1794 if (Seq.IsEmpty() || Ref.IsNull()) {
1795 Seq.Prepend(Item);
1796 }
1797 for (Standard_Integer i = 1; i <= Seq.Length(); i++) {
1798 if (Seq.Value(i) == Ref) {
1799 Seq.InsertAfter(i,Item);
1800 break;
1801 }
1802 }
1803}
1804
1805//=======================================================================
1806//function : RemoveSD
1807//purpose :
1808//=======================================================================
1809
1810static void RemoveSD (Handle(ChFiDS_Stripe)& Stripe,
1811 Handle(ChFiDS_SurfData)& Prev,
1812 Handle(ChFiDS_SurfData)& Next)
1813{
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; }
1821 }
1822 if(Prev.IsNull()) iprev = 1;
1823 if(Next.IsNull()) inext = Seq.Length();
1824 if(iprev <= inext) Seq.Remove(iprev,inext);
1825}
1826
1827//=======================================================================
1828//function : InsertBefore
81bba717 1829//purpose : Insert item before ref in Seq. If ref is null, the item is
1830// inserted in the queue.
7fd59977 1831//=======================================================================
1832
1833static void InsertBefore (Handle(ChFiDS_Stripe)& Stripe,
1834 Handle(ChFiDS_SurfData)& Ref,
1835 Handle(ChFiDS_SurfData)& Item)
1836{
1837 if (Ref == Item)
81bba717 1838 Standard_Failure::Raise("InsertBefore : twice the same surfdata.");
7fd59977 1839
1840 ChFiDS_SequenceOfSurfData& Seq =
1841 Stripe->ChangeSetOfSurfData()->ChangeSequence();
1842
1843 if (Seq.IsEmpty() || Ref.IsNull()) {
1844 Seq.Append(Item);
1845 }
1846 for (Standard_Integer i = 1; i <= Seq.Length(); i++) {
1847 if (Seq.Value(i) == Ref) {
1848 Seq.InsertBefore(i,Item);
1849 break;
1850 }
1851 }
1852}
1853
1854
1855//=======================================================================
1856//function : PerformSetOfSurfOnElSpine
1857//purpose :
1858//=======================================================================
1859
1860void 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)
1866{
0797d9d3 1867#ifdef OCCT_DEBUG
7fd59977 1868 OSD_Chronometer ch1;
1869#endif
1870
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;
73d0a668 1876 if (!Guide.IsPeriodic())
1877 {
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));
1882 }
7fd59977 1883 Handle(ChFiDS_Spine)& Spine = Stripe->ChangeSpine();
1884 Standard_Integer ii, nbed = Spine->NbEdges();
1885 Standard_Real lastedlastp = Spine->LastParameter(nbed);
1886
1887 TopOpeBRepDS_DataStructure& DStr = myDS->ChangeDS();
1888
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);
1893
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();
1d47d8d0 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;
7fd59977 1905 gp_Pnt2d pp1,pp2,pp3,pp4;
1d47d8d0 1906 Standard_Real w1 = 0.,w2 = 0.;
7fd59977 1907 math_Vector Soldep(1,4);
1908 math_Vector SoldepCS(1,3);
1909 math_Vector SoldepCC(1,2);
1910
81bba717 1911 // Restore a neighboring KPart.
1912 // If no neighbor calculation start point.
7fd59977 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;
81bba717 1918 // Restore the next KPart if it exists
7fd59977 1919 TopoDS_Vertex Vref;
1920 if(ref.IsNull() && raf.IsNull()){
1921 //sinon solution approchee.
1922 Inside = Standard_True;
1923
0797d9d3 1924#ifdef OCCT_DEBUG
81bba717 1925 ChFi3d_InitChron(ch1);// init perf for StartSol
7fd59977 1926#endif
1927
1928 StartSol(Stripe,HGuide,HS1,HS2,It1,It2,pp1,pp2,First);
1929
0797d9d3 1930#ifdef OCCT_DEBUG
81bba717 1931 ChFi3d_ResultChron(ch1,t_startsol); // result perf for StartSol
7fd59977 1932#endif
1933
1934 Last = wf;
1935 if(Guide.IsPeriodic()) {
1936 Last = First - Guide.Period();
73d0a668 1937 Guide.SaveFirstParameter();
7fd59977 1938 Guide.FirstParameter(Last);
73d0a668 1939 Guide.SaveLastParameter();
81bba717 1940 Guide.LastParameter (First * 1.1);//Extension to help rsnld.
7fd59977 1941 }
1942 }
1943 else{
1944 if(!Spine->IsPeriodic() && (wl - lastedlastp > -tolesp)){
1945 Vref = Spine->LastVertex();
1946 }
1947 if (ref.IsNull()) {
1948 if(!Spine->IsPeriodic() && (wf < tolesp)){
1949 Vref = Spine->FirstVertex();
1950 }
1951 ref = raf;
1952 forward = Standard_False;
1953 First = wl; Last = Guide.FirstParameter();
1954 }
1955
0797d9d3 1956#ifdef OCCT_DEBUG
81bba717 1957 ChFi3d_InitChron(ch1);// init perf for startsol
7fd59977 1958#endif
1959
1960
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);
1967 HC1.Nullify();
1968 HC2.Nullify();
1969
0797d9d3 1970#ifdef OCCT_DEBUG
81bba717 1971 ChFi3d_ResultChron(ch1,t_startsol); // result perf for startsol
7fd59977 1972#endif
1973
1974
1975 if(Ok1 == 1 && Ok2 == 1) {
1976 if(forward) Guide.FirstParameter(wf);
1977 else Guide.LastParameter(wl);
1978 }
1979 }
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;
1986 nbed = indl-indf+1;
1987 }
81bba717 1988 // No Max at the touch : 20 points by edge at average without
1989 // counting the extensions.
7fd59977 1990
1991 Standard_Real bidf = wf, bidl = wl;
1992 if(!Spine->IsPeriodic()) {
1993 bidf = Max(0.,wf);
1994 bidl = Min(wl,Spine->LastParameter(Spine->NbEdges()));
81bba717 1995 // PMN 20/07/98 : Attention in case if there is only extension
7fd59977 1996 if ((bidl-bidf) < 0.01 * Spine->LastParameter(Spine->NbEdges())) {
1997 bidf = wf;
1998 bidl = wl;
1999 }
2000 }
2001 Standard_Real MaxStep = (bidl-bidf)*0.05/nbed;
7fd59977 2002 Standard_Real Firstsov = 0.;
7fd59977 2003 Standard_Boolean intf = 0, intl = 0;
2004 while(!fini){
81bba717 2005 // are these the ends (no extension on periodic).
7fd59977 2006 Ok1 = 1,Ok2 = 1;
2007 if(!Spine->IsPeriodic()){
2008 if(wf < tolesp && (complete == Inside)){
2009 if(Spine->FirstStatus() == ChFiDS_OnSame) intf = 2;
2010 else intf = 1;
2011 }
2012 if(Spine->IsTangencyExtremity(Standard_True)){
2013 intf = 4;
2014 Guide.FirstParameter(wfsav);
2015 }
2016 if(wl - lastedlastp > -tolesp){
2017 if(Spine->LastStatus() == ChFiDS_OnSame) intl = 2;
2018 else intl = 1;
2019 }
2020 if(Spine->IsTangencyExtremity(Standard_False)){
2021 intl = 4;
2022 Guide.LastParameter(wlsav);
2023 }
2024 }
2025 if(intf && !forward) Vref = Spine->FirstVertex();
2026 if(intl && forward) Vref = Spine->LastVertex();
2027 if(!ref.IsNull()){
2028
0797d9d3 2029#ifdef OCCT_DEBUG
81bba717 2030 ChFi3d_InitChron(ch1);// init perf for StartSol
7fd59977 2031#endif
2032
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);
2039
0797d9d3 2040#ifdef OCCT_DEBUG
81bba717 2041 ChFi3d_ResultChron(ch1,t_startsol); // result perf for StartSol
7fd59977 2042#endif
2043
2044 }
2045
81bba717 2046 // No more connected faces. Construction of the tangent plane to continue the path
2047 // till the output on the other face.
7fd59977 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);
2052 if(intf) intf = 5;
2053 else if(intl) intl = 5;
2054 if(forward) Guide.FirstParameter(wf);
2055 else Guide.LastParameter(wl);
2056 }
81bba717 2057 else Standard_Failure::Raise("PerformSetOfSurfOnElSpine : Chaining is impossible.");
7fd59977 2058 }
2059
543a9964 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);
7fd59977 2065
81bba717 2066 // Calculate one (several if singularity) SurfaData
7fd59977 2067 SD = new ChFiDS_SurfData();
2068 ChFiDS_SequenceOfSurfData SeqSD;
2069 SeqSD.Append(SD);
2070
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(),
2077 Stripe->Choix());
2078
2079
81bba717 2080 // Calculate the criterion of Choice edge / edge
7fd59977 2081 if (Choix%2 == 0) Choix = 4;
2082 else Choix = 1;
2083
2084 SoldepCC(1) = w1; SoldepCC(2) = w2;
2085 if(Simul){
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);
2091 }
2092 else{
0797d9d3 2093#ifdef OCCT_DEBUG
81bba717 2094 ChFi3d_InitChron(ch1); // init perf for PerformSurf
7fd59977 2095#endif
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);
0797d9d3 2101#ifdef OCCT_DEBUG
81bba717 2102 ChFi3d_ResultChron(ch1,t_performsurf); //result perf for PerformSurf
7fd59977 2103#endif
2104 }
2105 SD->ChangeIndexOfS1(DStr.AddShape(HS1->ChangeSurface().Face()));
2106 SD->ChangeIndexOfS2(DStr.AddShape(HS2->ChangeSurface().Face()));
2107 }
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(),
2114 -Stripe->Choix());
2115 if(Choix%2 == 1) Choix++;
2116 else Choix--;
2117 SoldepCS(3) = w1; SoldepCS(1) = pp2.X(); SoldepCS(2) = pp2.Y();
2118 if(Simul){
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);
2122 }
2123 else{
0797d9d3 2124#ifdef OCCT_DEBUG
81bba717 2125 ChFi3d_InitChron(ch1); // init perf for PerformSurf
7fd59977 2126#endif
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);
0797d9d3 2130#ifdef OCCT_DEBUG
81bba717 2131 ChFi3d_ResultChron(ch1,t_performsurf);//result perf for PerformSurf
7fd59977 2132#endif
2133 }
2134 SD->ChangeIndexOfS1(DStr.AddShape(HS1->ChangeSurface().Face()));
2135 SD->ChangeIndexOfS2(DStr.AddShape(HS2->ChangeSurface().Face()));
2136 decroch2 = 0;
2137 }
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(),
2144 Stripe->Choix());
2145 SoldepCS(3) = w2; SoldepCS(1) = pp1.X(); SoldepCS(2) = pp1.Y();
2146 if(Simul){
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);
2150 }
2151 else{
0797d9d3 2152#ifdef OCCT_DEBUG
81bba717 2153 ChFi3d_InitChron(ch1); // init perf for PerformSurf
7fd59977 2154#endif
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);
0797d9d3 2158#ifdef OCCT_DEBUG
81bba717 2159 ChFi3d_ResultChron(ch1,t_performsurf); //result perf for PerformSurf
7fd59977 2160#endif
2161 }
2162 SD->ChangeIndexOfS1(DStr.AddShape(HS1->ChangeSurface().Face()));
2163 SD->ChangeIndexOfS2(DStr.AddShape(HS2->ChangeSurface().Face()));
2164 decroch1 = 0;
2165 }
543a9964 2166 else{
2167 const Handle(Adaptor3d_TopolTool)& aTT1 = It1; // to avoid ambiguity
2168 const Handle(Adaptor3d_TopolTool)& aTT2 = It2; // to avoid ambiguity
7fd59977 2169 CallPerformSurf(Stripe, Simul, SeqSD, SD,
2170 HGuide,Spine,
543a9964 2171 HS1, HS3, pp1, pp3, aTT1,
2172 HS2, HS4, pp2, pp4, aTT2,
7fd59977 2173 MaxStep,locfleche,tolesp,
2174 First,Last,Inside,Inside,forward,
2175 RecS1,RecS2,Soldep,intf,intl,
2176 HS1, HS2);
2177 decroch1 = decroch2 = 0;
2178 }
2179
81bba717 2180 if(!done) { // Case of fail
7fd59977 2181 if ((!Ok1 && !obstacleon1) || (!Ok2 && !obstacleon2)) {
81bba717 2182 //Fail in a part of extension is not serious
2183 //Here one stops.
7fd59977 2184 done = Standard_True;
2185 Inside = Standard_False;
2186 if (forward) intl = 1;
2187 else intf = 1;
2188 }
81bba717 2189 else { // Otherwise invalidation of the stripe.
7fd59977 2190 Spine->SetErrorStatus(ChFiDS_WalkingFailure);
81bba717 2191 Standard_Failure::Raise("CallPerformSurf : Path failed!");
7fd59977 2192 }
2193 }
2194
2195 else {
2196 refbis = ref;
2197 if(forward) {
2198 for (ii=1; ii<=SeqSD.Length(); ii++) {
2199 SD = SeqSD(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);
2205 refbis = SD;
2206 }
2207 }
2208 else {
2209 for (ii=SeqSD.Length(); ii>=1; ii--) {
2210 SD = SeqSD(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);
2216 refbis = SD;
2217 }
2218 }
2219
2220 if (!Ok1 && !obstacleon1)
81bba717 2221 // clean infos on the plane of extension.
7fd59977 2222 ChFi3d_Purge (Stripe,SD,ref->Vertex(!forward,1),!forward,1,intf,intl);
2223
2224 if (!Ok2 && !obstacleon2)
81bba717 2225 // clean infos on the plane of extension.
7fd59977 2226 ChFi3d_Purge (Stripe,SD,ref->Vertex(!forward,2),!forward,2,intf,intl);
2227
81bba717 2228 // The end. The reference is changed.
7fd59977 2229 ref = refbis;
2230 }
2231
81bba717 2232 if(Inside){// There are starting solutions for the next.
7fd59977 2233 Inside = Standard_False;
2234 Firstsov = First;
2235 if(Guide.IsPeriodic()) {
2236 complete = Standard_False;
2237 wf = Guide.FirstParameter();
2238 wl = Guide.LastParameter();
2239 }
2240 }
2241 if(forward){
2242 fini = ((wl - Last) <= 10.*tolesp ||
81bba717 2243 (intl && !(obstacleon1 || obstacleon2))); //General case
7fd59977 2244
2245 if (!fini && Guide.IsPeriodic() &&
2246 ((wl - Last)< Guide.Period()*1.e-3)) {
81bba717 2247 // It is tested if reframing of extremes is done at the same edge
2248 // Loop Condition
7fd59977 2249 Handle(ChFiDS_SurfData) thefirst, thelast;
2250 thefirst = Stripe->SetOfSurfData()->Sequence().First();
2251 thelast = Stripe->SetOfSurfData()->Sequence().Last();
2252
2253 if (thefirst->VertexFirstOnS1().IsOnArc() &&
2254 thelast->VertexLastOnS1().IsOnArc())
2255 fini = thefirst->VertexFirstOnS1().Arc().IsSame
2256 (thelast->VertexLastOnS1().Arc());
2257 if (!fini &&
2258 thefirst->VertexFirstOnS2().IsOnArc() &&
2259 thelast->VertexLastOnS2().IsOnArc())
2260 fini = thefirst->VertexFirstOnS2().Arc().IsSame
2261 (thelast->VertexLastOnS2().Arc());
2262
2263 if (fini)
81bba717 2264 return; //It is ended!
7fd59977 2265 }
2266
2267 if(fini && complete) {
81bba717 2268 // restart in the opposite direction.
7fd59977 2269 ref = Stripe->SetOfSurfData()->Sequence().First();
2270 forward = Standard_False;
2271 fini = Standard_False;
2272 First = Firstsov;
2273 }
2274 else {
2275 First = Last;
2276 Last = wl;
2277 }
2278 }
2279 if(!forward){
2280 fini = ((First - wf) <= 10.*tolesp ||
2281 (intf && !(obstacleon1 || obstacleon2)));
2282 complete = Standard_False;
2283 Last = wf;
2284 }
2285 }
81bba717 2286 // The initial state is restored
7fd59977 2287 if(!Guide.IsPeriodic()){
2288 Guide.FirstParameter(wfsav);
2289 Guide.LastParameter (wlsav);
2290 }
2291
2292}
2293
2294//=======================================================================
2295//function : PerformSetOfKPart
2296//purpose :
2297//=======================================================================
2298
2299void ChFi3d_Builder::PerformSetOfKPart(Handle(ChFiDS_Stripe)& Stripe,
2300 const Standard_Boolean Simul)
2301{
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;
96a95605 2306 Standard_Integer RefChoix;
7fd59977 2307
81bba717 2308 // initialization of the stripe.
7fd59977 2309 Stripe->Reset();
2310 Handle(ChFiDS_HData)& HData = Stripe->ChangeSetOfSurfData();
2311 HData = new ChFiDS_HData();
2312 ChFiDS_SequenceOfSurfData& SeqSurf = HData->ChangeSequence();
2313
2314 StripeOrientations(Spine,RefOr1,RefOr2,RefChoix);
2315 Stripe->OrientationOnFace1(RefOr1);
2316 Stripe->OrientationOnFace2(RefOr2);
2317 Stripe->Choix(RefChoix);
2318
2319 Handle(BRepTopAdaptor_TopolTool) It1 = new BRepTopAdaptor_TopolTool();
2320 Handle(BRepTopAdaptor_TopolTool) It2 = new BRepTopAdaptor_TopolTool();
2321
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;
2326
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);
2331
2332 Standard_Boolean YaKPart = Standard_False;
2333 Standard_Integer iedgelastkpart = 0;
2334
2335 Standard_Real WStartPeriodic = 0.;
2336 Standard_Real WEndPeriodic = Spine->LastParameter(Spine->NbEdges());
2337 Spine->D1(WEndPeriodic,PEndPeriodic,TEndPeriodic);
2338
81bba717 2339 // Construction of particular cases.
7fd59977 2340
2341 for (Standard_Integer iedge = 1; iedge <= Spine->NbEdges(); iedge++){
2342
2343 ConexFaces(Spine,iedge,RefChoix,HS1,HS2);
2344
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();
96a95605 2350 ChFi3d::NextSide(Or1,Or2,RefOr1,RefOr2,RefChoix);
543a9964 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);
7fd59977 2355
2356 Handle(ChFiDS_SurfData) SD = new ChFiDS_SurfData();
2357 ChFiDS_SequenceOfSurfData LSD;
2358
2359 if(!ChFiKPart_ComputeData::Compute(DStr,SD,HS1,HS2,Or1,Or2,Spine,iedge)){
0797d9d3 2360#ifdef OCCT_DEBUG
81bba717 2361 cout<<"failed calculation KPart"<<endl;
7fd59977 2362#endif
2363 }
2364 else if(!SplitKPart(SD,LSD,Spine,iedge,HS1,It1,HS2,It2,intf,intl)){
0797d9d3 2365#ifdef OCCT_DEBUG
81bba717 2366 cout<<"failed calculation KPart"<<endl;
7fd59977 2367#endif
2368 LSD.Clear();
2369 }
2370 else iedgelastkpart = iedge;
81bba717 2371 if(Spine->IsPeriodic()){//debug provisory for SD that arrive in desorder.
7fd59977 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){
2377// if(!YaKPart){
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;
2385 wfp = wwf;
2386 wlp = wfp + period;
2387 }
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);
2396 if(kwf < jwf){
2397 LSD.SetValue(j,kSD);
2398 LSD.SetValue(k,jSD);
2399 }
2400 }
2401 }
2402 }
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();
2415 }
2416 TgtKP(LSD.Value(j),Spine,iedge,1,PFirst,TFirst);
2417 TgtKP(LSD.Value(j),Spine,iedge,0,PLast,TLast);
2418
81bba717 2419 // Determine the sections to approximate
7fd59977 2420 if(!YaKPart){
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);
2430 }
2431 else if(!intf || (iedge > 1)){
81bba717 2432 // start section -> first KPart
2433 // update of extension.
7fd59977 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();
2440 }
2441 CurrentHE->ChangeCurve().FirstParameter(WLast);
2442 CurrentHE->ChangeCurve().SetFirstPointAndTgt(PLast,TLast);
2443 CurrentHE->ChangeCurve().ChangePrevious() = LSD.Value(j);
2444 YaKPart = Standard_True;
2445 }
2446 else {
2447 if (WFirst - CurrentHE->FirstParameter() > tolesp) {
81bba717 2448 // section between two KPart
7fd59977 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();
2454 }
2455 CurrentHE->ChangeCurve().FirstParameter(WLast);
2456 CurrentHE->ChangeCurve().SetFirstPointAndTgt(PLast,TLast);
2457 CurrentHE->ChangeCurve().ChangePrevious() = LSD.Value(j);
2458 }
2459 }
2460 if(!li.IsEmpty()) myEVIMap.Bind(Spine->Edges(iedge),li);
2461 }
2462 }
2463
2464 if (!intl || (iedgelastkpart < Spine->NbEdges())) {
81bba717 2465 // section last KPart(or start of the spine) -> End of the spine.
2466 // update of the extension.
7fd59977 2467
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);
2474 }
2475 }
2476 else{
2477 Spine->D1(Spine->LastParameter(),PLast,TLast);
2478 Spine->SetLastTgt(Max(Spine->LastParameter(Spine->NbEdges()),
2479 WLast));
2480 if (Spine->LastParameter() - WLast > tolesp) {
2481 CurrentHE->ChangeCurve().LastParameter(Spine->LastParameter());
2482 CurrentHE->ChangeCurve().SetLastPointAndTgt(PLast,TLast);
2483 Spine->AppendElSpine(CurrentHE);
2484 }
2485 }
2486 }
2487
2488 ChFiDS_ListOfHElSpine& ll = Spine->ChangeElSpines();
2489 ChFiDS_ListIteratorOfListOfHElSpine ILES(ll);
2490 for ( ; ILES.More(); ILES.Next()) {
0797d9d3 2491#ifdef OCCT_DEBUG
7fd59977 2492 if(ChFi3d_GettraceCHRON()) elspine.Start();
2493#endif
2494 ChFi3d_PerformElSpine(ILES.Value(),Spine,myConti,tolesp);
0797d9d3 2495#ifdef OCCT_DEBUG
7fd59977 2496 if(ChFi3d_GettraceCHRON()) { elspine.Stop(); }
2497#endif
2498 }
2499 Spine->SplitDone(Standard_True);
2500}
2501
2502static Standard_Real ChFi3d_BoxDiag(const Bnd_Box& box)
2503{
2504 Standard_Real a,b,c,d,e,f;
2505 box.Get(a,b,c,d,e,f);
2506 d-=a; e-=b; f-=c;
2507 d*=d; e*=e; f*=f;
2508 Standard_Real diag = sqrt(d + e + f);
2509 return diag;
2510}
2511
2512//=======================================================================
2513//function : PerformSetOfKGen
2514//purpose :
2515//=======================================================================
2516
2517void ChFi3d_Builder::PerformSetOfKGen(Handle(ChFiDS_Stripe)& Stripe,
2518 const Standard_Boolean Simul)
2519{
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()) {
0797d9d3 2526#ifdef OCCT_DEBUG
7fd59977 2527 if(ChFi3d_GettraceCHRON()) { chemine.Start(); }
2528#endif
2529 PerformSetOfSurfOnElSpine(ILES.Value(),Stripe,It1,It2,Simul);
0797d9d3 2530#ifdef OCCT_DEBUG
7fd59977 2531 if(ChFi3d_GettraceCHRON()) chemine.Stop();
2532#endif
2533 }
2534 if(!Simul){
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++;
81bba717 2542 // It is attempted to reprocess the squares that bore.
7fd59977 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;
2549 if(iprev == 0) {
2550 if(periodic) iprev = len;
2551 }
2552 Standard_Integer inext = i + 1;
2553 if(inext > len) {
2554 if(periodic) inext = 1;
2555 else inext = 0;
2556 }
2557
81bba717 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... )
7fd59977 2561 if(!tw1 && !tw2) continue;
2562
81bba717 2563 // It is decided (fairly at random) if the extended surface is ready for the filling.
7fd59977 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);
81bba717 2584 Standard_Failure::Raise("adjustment by reprocessing the non-written points");
7fd59977 2585 }
2586
81bba717 2587 // It is checked if there are presentable neighbors
7fd59977 2588 Standard_Boolean yaprevon1 = 0, yaprevon2 = 0;
2589 Standard_Boolean samesurfon1 = 0, samesurfon2 = 0;
2590 if(iprev){
2591 prevsd = SeqSurf.ChangeValue(iprev);
2592 yaprevon1 = !prevsd->TwistOnS1();
2593 samesurfon1 = (prevsd->IndexOfS1() == cursurf1);
2594 yaprevon2 = !prevsd->TwistOnS2();
2595 samesurfon2 = (prevsd->IndexOfS2() == cursurf2);
2596 }
2597 Standard_Boolean yanexton1 = 0, yanexton2 = 0;
2598 if(inext){
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);
2604 }
81bba717 2605 // A contour of filling is constructed
7fd59977 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;
2616 if(tw1){
2617 if(!yaprevon1 || !yanexton1){
2618 Spine->SetErrorStatus(ChFiDS_TwistedSurface);
2619 Standard_Failure::Raise
81bba717 2620 ("adjustment by reprocessing the non-written points: no neighbor");
7fd59977 2621 }
2622 ChFiDS_FaceInterference& previntf1 = prevsd->ChangeInterferenceOnS1();
2623 ChFiDS_FaceInterference& nextintf1 = nextsd->ChangeInterferenceOnS1();
2624 Standard_Real prevpar1 = previntf1.LastParameter();
2625 Standard_Real nextpar1 = nextintf1.FirstParameter();
2626 if(samesurfon1){
81bba717 2627 // It is checked if it is possible to intersect traces of neighbors
2628 // to create a sharp end.
7fd59977 2629 Handle(Geom2d_Curve) pcprev1 = previntf1.PCurveOnFace();
2630 Handle(Geom2d_Curve) pcnext1 = nextintf1.PCurveOnFace();
2631 Standard_Real nprevpar1,nnextpar1;
2632 gp_Pnt2d p2d;
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);
2642 pointuon1 = 1;
2643 PC1.Nullify();
2644 }
2645 else{
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);
2652 }
2653 }
2654 else{
81bba717 2655 //here the base is on 3D tangents of neighbors.
7fd59977 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);
2671 }
2672 }
2673 else{
2674 Bon1 = ChFi3d_mkbound(S1,PC1,tolesp,2.e-4);
2675 }
2676 if(tw2){
2677 if(!yaprevon2 || !yanexton2){
2678 Standard_Failure::Raise
81bba717 2679 ("adjustment by reprocessing the non-written points: no neighbor");
7fd59977 2680 }
2681 ChFiDS_FaceInterference& previntf2 = prevsd->ChangeInterferenceOnS2();
2682 ChFiDS_FaceInterference& nextintf2 = nextsd->ChangeInterferenceOnS2();
2683 Standard_Real prevpar2 = previntf2.LastParameter();
2684 Standard_Real nextpar2 = nextintf2.FirstParameter();
2685 if(samesurfon2){
81bba717 2686 // It is checked if it is possible to intersect traces of neighbors
2687 // to create a sharp end.
7fd59977 2688 Handle(Geom2d_Curve) pcprev2 = previntf2.PCurveOnFace();
2689 Handle(Geom2d_Curve) pcnext2 = nextintf2.PCurveOnFace();
2690 Standard_Real nprevpar2,nnextpar2;
2691 gp_Pnt2d p2d;
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);
2701 pointuon2 = 1;
2702 PC2.Nullify();
2703 }
2704 else{
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);
2711 }
2712 }
2713 else{
81bba717 2714 //here the base is on 3D tangents of neighbors.
7fd59977 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);
2730 }
2731 }
2732 else{
2733 Bon2 = ChFi3d_mkbound(S2,PC2,tolesp,2.e-4);
2734 }
81bba717 2735 // The parameters of neighbor traces are updated, so
2736 // straight lines uv are pulled.
7fd59977 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);
2759
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);
2764
2765 ChFi3d_ReparamPcurv(0.,1.,PC1);
2766 ChFi3d_ReparamPcurv(0.,1.,PC2);
2767 Handle(Geom_Surface) newsurf = fil.Surface();
0797d9d3 2768#ifdef OCCT_DEBUG
7fd59977 2769#ifdef DRAW
81bba717 2770 //POP for NT
7fd59977 2771 char* pops = "newsurf";
2772 DrawTrSurf::Set(pops,newsurf);
2773#endif
2774#endif
2775 if(pointuon1) {
81bba717 2776 newsurf->VReverse(); // we return to direction 1 from 2;
7fd59977 2777 done = CompleteData(cursd,newsurf,S1,PC1,S2,PC2,
2778 F2.Orientation(),0,0,0,0,0);
2779 cursd->ChangeIndexOfS1(0);
2780 }
2781 else{
2782 done = CompleteData(cursd,newsurf,S1,PC1,S2,PC2,
2783 F1.Orientation(),1,0,0,0,0);
2784 if(pointuon2) cursd->ChangeIndexOfS2(0);
2785 }
2786 if(tw1){
2787 prevsd->ChangeVertexLastOnS1().SetPoint(cpd1.Point());
2788 nextsd->ChangeVertexFirstOnS1().SetPoint(cpf1.Point());
2789 }
2790 if(tw2){
2791 prevsd->ChangeVertexLastOnS2().SetPoint(cpd2.Point());
2792 nextsd->ChangeVertexFirstOnS2().SetPoint(cpf2.Point());
2793 }
2794 }
81bba717 2795 // The tolerance of points is updated.
7fd59977 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();
2816
2817 if(!curp1.IsOnArc() && nextp1.IsOnArc()){
2818 curp1 = nextp1;
2819 if ( (curs1 == nexts1) && !nextsd->IsOnCurve1())
81bba717 2820 // Case when it is not possible to pass along the border without leaving
7fd59977 2821 ChangeTransition(nextp1, curp1, nexts1, myDS);
2822 }
2823 else if(curp1.IsOnArc() && !nextp1.IsOnArc()) {
2824 nextp1 = curp1;
2825 if ( (curs1 == nexts1) && !cursd->IsOnCurve1())
2826 ChangeTransition(curp1, nextp1, curs1, myDS);
2827 }
2828
2829 if(!curp2.IsOnArc() && nextp2.IsOnArc()) {
2830 curp2 = nextp2;
2831 if ( (curs2 == nexts2) && !nextsd->IsOnCurve2())
2832 ChangeTransition(nextp2, curp2, curs2, myDS);
2833 }
2834 else if(curp2.IsOnArc() && !nextp2.IsOnArc()){
2835 nextp2 = curp2;
2836 if ( (curs2 == nexts2) && !cursd->IsOnCurve2())
2837 ChangeTransition(curp2, nextp2, curs2, myDS);
2838 }
2839
2840 curp1.SetTolerance(tol1); nextp1.SetTolerance(tol1);
2841 curp2.SetTolerance(tol2); nextp2.SetTolerance(tol2);
2842
2843 Bnd_Box b1,b2;
2844 if(curp1.IsOnArc()){
2845 ChFi3d_EnlargeBox(curp1.Arc(),myEFMap(curp1.Arc()),curp1.ParameterOnArc(),b1);
2846 }
2847 if(curp2.IsOnArc()){
2848 ChFi3d_EnlargeBox(curp2.Arc(),myEFMap(curp2.Arc()),curp2.ParameterOnArc(),b2);
2849 }
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);
2857 }
81bba717 2858 // The connections edge/new faces are updated.
7fd59977 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();
2868 if(periodic){
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;
2875 }
2876 else{
2877 IF = Spine->Index(WF,1);
2878 IL = Spine->Index(WL,0);
2879 }
2880 if(IF == IL) {
81bba717 2881 //fast processing
7fd59977 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);
2893 }
2894 myEVIMap.ChangeFind(Ej).Append(cursd->Surf());
2895 }
2896 }
2897 else if(IF < IL){
2898 TColStd_Array1OfReal wv(IF,IL - 1);
0797d9d3 2899#ifdef OCCT_DEBUG
81bba717 2900 cout<<"length of the trajectory : "<<(WL-WF)<<endl;
7fd59977 2901#endif
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);
0797d9d3 2908#ifdef OCCT_DEBUG
7fd59977 2909 gp_Pnt pelsapp = curels.Value(wi);
2910 Standard_Real distinit = pv.Distance(pelsapp);
2911 cout<<"distance psp/papp : "<<distinit<<endl;
2912#endif
2913 Extrema_LocateExtPC ext(pv,curels,wi,1.e-8);
2914 wv(i) = wi;
2915 if(ext.IsDone()){
2916 wv(i) = ext.Point().Parameter();
2917 }
2918 else {
0797d9d3 2919#ifdef OCCT_DEBUG
81bba717 2920 cout<<"fail of projection vertex ElSpine!!!"<<endl;
7fd59977 2921#endif
2922 }
2923 }
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();
2928 Standard_Integer j;
7fd59977 2929 Standard_Integer jf = 0, jl = 0;
7fd59977 2930 if(lp < WF+tolesp || fp > WL-tolesp) continue;
2931 for(j = IF; j < IL; j++){
2932 jf = j;
2933 if(fp < wv(j) - tolesp) break;
2934 }
2935 for(j = IF; j < IL; j++){
2936 jl = j;
2937 if(lp < wv(j) + tolesp) break;
2938 }
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);
2946 }
2947 myEVIMap.ChangeFind(Ej).Append(cursd->Surf());
2948 }
2949 }
2950 }
2951 }
2952 }
2953}
2954
2955//=======================================================================
2956//function : PerformSetOfSurf
2957//purpose :
2958//=======================================================================
2959
2960void ChFi3d_Builder::PerformSetOfSurf(Handle(ChFiDS_Stripe)& Stripe,
2961 const Standard_Boolean Simul)
2962{
2963 TopOpeBRepDS_DataStructure& DStr = myDS->ChangeDS();
2964
0797d9d3 2965#ifdef OCCT_DEBUG
7fd59977 2966 OSD_Chronometer ch;
81bba717 2967 ChFi3d_InitChron(ch);// init perf for PerformSetOfKPart
7fd59977 2968#endif
2969
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);
2974
0797d9d3 2975#ifdef OCCT_DEBUG
7fd59977 2976 ChFi3d_ResultChron(ch ,t_perfsetofkpart); // result perf PerformSetOfKPart(
81bba717 2977 ChFi3d_InitChron(ch); // init perf for PerformSetOfKGen
7fd59977 2978#endif
2979
2980 PerformSetOfKGen(Stripe,Simul);
2981
0797d9d3 2982#ifdef OCCT_DEBUG
7fd59977 2983 ChFi3d_ResultChron(ch, t_perfsetofkgen);//result perf PerformSetOfKGen
81bba717 2984 ChFi3d_InitChron(ch); // init perf for ChFi3d_MakeExtremities
7fd59977 2985#endif
2986
2987 if(!Simul) ChFi3d_MakeExtremities(Stripe,DStr,myEFMap,tolesp,tol2d);
2988
0797d9d3 2989#ifdef OCCT_DEBUG
7fd59977 2990 ChFi3d_ResultChron(ch, t_makextremities); // result perf t_makextremities
2991#endif
2992}
Open CASCADE Technology repository