0024428: Implementation of LGPL license
[occt.git] / src / BRepFeat / BRepFeat_MakeRevolutionForm.cxx
CommitLineData
b311480e 1// Created on: 1997-10-14
2// Created by: Olga KOULECHOVA
3// Copyright (c) 1997-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//
973c2be1 8// This library is free software; you can redistribute it and / or modify it
9// under the terms of the GNU Lesser General Public version 2.1 as published
10// by the Free Software Foundation, with special exception defined in the file
11// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12// distribution for complete text of the license and disclaimer of any warranty.
b311480e 13//
973c2be1 14// Alternatively, this file may be used under the terms of Open CASCADE
15// commercial license or contractual agreement.
7fd59977 16
17#include <BRepFeat_MakeRevolutionForm.ixx>
18
19#include <BRepFeat.hxx>
20
21#include <LocOpe.hxx>
7fd59977 22#include <LocOpe_RevolutionForm.hxx>
23#include <LocOpe_CSIntersector.hxx>
24#include <LocOpe_PntFace.hxx>
25#include <LocOpe_Gluer.hxx>
26#include <LocOpe_FindEdges.hxx>
27
28#include <gp_Vec.hxx>
29#include <gp_Ax1.hxx>
30#include <gp_Pln.hxx>
31#include <gp_Lin.hxx>
32#include <gp_Pnt.hxx>
33
34#include <gp_Vec2d.hxx>
35#include <gp_Pnt2d.hxx>
36
37#include <Geom_Curve.hxx>
38
39#include <Geom2d_Curve.hxx>
40#include <Geom2d_Line.hxx>
41
42#include <Geom_Line.hxx>
43#include <Geom_Circle.hxx>
44#include <Geom_Plane.hxx>
45#include <Geom_Surface.hxx>
46#include <Geom_CylindricalSurface.hxx>
47#include <Geom_ConicalSurface.hxx>
48#include <Geom_ToroidalSurface.hxx>
49#include <Geom_RectangularTrimmedSurface.hxx>
50
51#include <Geom_TrimmedCurve.hxx>
52#include <GeomProjLib.hxx>
53
54#include <Geom2dAPI_InterCurveCurve.hxx>
55#include <Geom2dAPI_ExtremaCurveCurve.hxx>
56#include <Geom2d_Curve.hxx>
57#include <Geom2d_Curve.hxx>
58
59
60#include <GeomAPI.hxx>
61#include <GeomAPI_ProjectPointOnCurve.hxx>
62
63#include <TColgp_SequenceOfPnt.hxx>
64
65#include <TColGeom_SequenceOfCurve.hxx>
66
67#include <TColStd_Array1OfReal.hxx>
68#include <IntRes2d_IntersectionPoint.hxx>
69
70#include <BRepTools_WireExplorer.hxx>
71
72#include <BRep_Tool.hxx>
73#include <BRep_Builder.hxx>
74
75#include <TopExp_Explorer.hxx>
76#include <TopExp.hxx>
77
78#include <TopTools_MapOfShape.hxx>
79#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
80#include <TopTools_ListOfShape.hxx>
81#include <TopTools_ListIteratorOfListOfShape.hxx>
82#include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
83#include <TopTools_MapIteratorOfMapOfShape.hxx>
84#include <TopOpeBRepBuild_HBuilder.hxx>
85#include <TopTools_DataMapIteratorOfDataMapOfShapeShape.hxx>
86
87#include <TColgp_Array1OfPnt.hxx>
88
89#include <TColGeom_Array1OfCurve.hxx>
90
91#include <TopoDS.hxx>
92#include <TopoDS_Shape.hxx>
93#include <TopoDS_Face.hxx>
94
95#include <BRepLib_MakeVertex.hxx>
96#include <BRepLib_MakeEdge.hxx>
97#include <BRepLib_MakeFace.hxx>
98
99#include <BRepTools.hxx>
100
101#include <BRepPrimAPI_MakeBox.hxx>
102#include <BRepBuilderAPI_MakeFace.hxx>
103
104#include <BRepAlgo.hxx>
105
106//modified by NIZNHY-PKV Fri Mar 22 16:56:15 2002
107//#include <BRepAlgo_Cut.hxx>
108//#include <BRepAlgo_Section.hxx>
109//#include <BRepAlgo_Common.hxx>
110#include <BRepAlgoAPI_Cut.hxx>
111#include <BRepAlgoAPI_Section.hxx>
112#include <BRepAlgoAPI_Common.hxx>
113//modified by NIZNHY-PKV Fri Mar 22 16:56:17 2002 t
114
115#include <BRepBuilderAPI_Transform.hxx>
116#include <BRepExtrema_ExtPC.hxx>
117#include <BRepExtrema_ExtCF.hxx>
118
119#include <BRepTools_Modifier.hxx>
120#include <BRepTools_TrsfModification.hxx>
121
122#include <BRepTopAdaptor_FClass2d.hxx>
123
124#include <Standard_ConstructionError.hxx>
125
126#include <Precision.hxx>
127
128
129#include <ElCLib.hxx>
130#include <ElSLib.hxx>
131#include <CSLib.hxx>
132
133#include <GeomLProp_CLProps.hxx>
134
135#ifdef DEB
1d0a9d4d 136extern Standard_Boolean BRepFeat_GettraceFEAT();
137extern Standard_Boolean BRepFeat_GettraceFEATRIB();
7fd59977 138#endif
139
140static void MajMap(const TopoDS_Shape&, // base
141 const LocOpe_RevolutionForm&,
142 TopTools_DataMapOfShapeListOfShape&, // myMap
143 TopoDS_Shape&, // myFShape
144 TopoDS_Shape&); // myLShape
145
146static void SetGluedFaces(const TopTools_DataMapOfShapeListOfShape& theSlmap,
147 LocOpe_RevolutionForm&,
148 const TopTools_DataMapOfShapeListOfShape& SlidingMap,
149 TopTools_DataMapOfShapeShape&);
150
151//=======================================================================
152//function : Init
153//purpose :
154//=======================================================================
155
156void BRepFeat_MakeRevolutionForm::Init(const TopoDS_Shape& Sbase,
157 const TopoDS_Wire& W,
158 const Handle(Geom_Plane)& Plane,
159 const gp_Ax1& Axis,
160 const Standard_Real H1,
161 const Standard_Real H2,
162 const Standard_Integer Mode,
163 Standard_Boolean& Modify)
164{
165#ifdef DEB
166 Standard_Boolean trc = BRepFeat_GettraceFEAT();
167 if (trc) cout << "BRepFeat_MakeRevolutionForm::Init" << endl;
168#endif
169 Standard_Boolean RevolRib = Standard_True;
170 Done();
171
0d969553
Y
172// modify = 0 if it is not required to make sliding
173// = 1 if it is intended to try to make sliding
7fd59977 174 Standard_Boolean Sliding = Modify;
175
176 myAxe = Axis;
177 Handle(Geom_Line) Line = new Geom_Line(Axis);
178 Standard_Real LineFirst, LineLast;
179
180 LocOpe_CSIntersector ASI(Sbase);
181 TColGeom_SequenceOfCurve scur;
182 scur.Clear();
183 scur.Append(Line);
184 ASI.Perform(scur);
185 if(ASI.IsDone() && ASI.NbPoints(1) >= 2) {
186 LineLast = ASI.Point(1, ASI.NbPoints(1)).Parameter();
187 LineFirst = ASI.Point(1, 1).Parameter();
188 }
189 else {
190 LineFirst = RealFirst();
191 LineLast = RealLast();
192 }
193
194 Handle(Geom2d_Curve) ln2d = GeomAPI::To2d(Line, Plane->Pln());
195
196 TopExp_Explorer exx;
197 Standard_Real Rad = RealLast();
198
199 exx.Init(W, TopAbs_EDGE);
200 for(; exx.More(); exx.Next()) {
201 const TopoDS_Edge& e = TopoDS::Edge(exx.Current());
202 Standard_Real f, l;
203 Handle(Geom_Curve) c = BRep_Tool::Curve(e, f, l);
204 Handle(Geom2d_Curve) c2d = GeomAPI::To2d(c, Plane->Pln());
205 Geom2dAPI_ExtremaCurveCurve extr(ln2d, c2d, LineFirst, LineLast,f,l);
206 Quantity_Length L = RealLast();
207 if(extr.NbExtrema() >= 1) {
208 L = extr.LowerDistance();
209 }
210 gp_Pnt p1 = c->Value(f);
211 gp_Pnt p2 = c->Value(l);
212 GeomAPI_ProjectPointOnCurve proj1(p1, Line);
213 GeomAPI_ProjectPointOnCurve proj2(p2, Line);
214 if(proj1.NbPoints() < 1 || proj2.NbPoints() < 1) {
215#ifdef DEB
216 if (trc) cout << " No projection points" << endl;
217#endif
218 myStatusError = BRepFeat_NoProjPt;
219 NotDone();
220 return;
221 }
222 Standard_Real par1 = proj1.Distance(1);
223 Standard_Real par2 = proj2.Distance(1);
224 Standard_Real Par = Min(par1, par2);
225 if(Par<L) L = Par;
226 if(L<Rad && L > 0.) Rad = L;
227 }
228
229 Standard_Real height = Min(H1, H2);
230
231 if(Rad <= height) Rad = height + 0.01*height;
232
c6541a0c
D
233 myAngle1 = asin(H1/Rad) + M_PI/10.;
234 myAngle2 = asin(H2/Rad) + M_PI/10.;
7fd59977 235
c6541a0c
D
236 if((myAngle1 - M_PI/2) > Precision::Confusion())
237 myAngle1 = M_PI/2;
238 if((myAngle2 - M_PI/2) > Precision::Confusion())
239 myAngle2 = M_PI/2;
7fd59977 240
241 mySkface.Nullify();
242 myPbase.Nullify();
243
244 if(Mode == 0)
245 myFuse = Standard_False;
246 else // if(Mode == 1)
247 myFuse = Standard_True;
248#ifdef DEB
249 if (trc) {
250 if (myFuse) cout << " Fuse" << endl;
251 if (!myFuse) cout << " Cut" << endl;
252 }
253#endif
254
0d969553 255// ---Determination Tolerance : tolerance max on parameters
7fd59977 256 myTol = Precision::Confusion();
257
258 exx.Init(W, TopAbs_VERTEX);
259 for(; exx.More(); exx.Next()) {
260 const Standard_Real& tol = BRep_Tool::
261 Tolerance(TopoDS::Vertex(exx.Current()));
262 if(tol > myTol) myTol = tol;
263 }
264
265 exx.Init(Sbase, TopAbs_VERTEX);
266 for(; exx.More(); exx.Next()) {
267 const Standard_Real& tol = BRep_Tool::
268 Tolerance(TopoDS::Vertex(exx.Current()));
269 if(tol > myTol) myTol = tol;
270 }
271
272 TopoDS_Shape aLocalShape = W.Oriented(TopAbs_FORWARD);
273 myWire = TopoDS::Wire(aLocalShape);
274// myWire = TopoDS::Wire(W.Oriented(TopAbs_FORWARD));
275 myPln = Plane;
276 myHeight1 = H1;
277 myHeight2 = H2;
278
279 mySbase = Sbase;
280 mySlface.Clear();
281 myShape.Nullify();
282 myMap.Clear();
283 myFShape.Nullify();
284 myLShape.Nullify();
285
0d969553 286// ---Calculate bounding box
7fd59977 287 BRep_Builder BB;
288
289 TopTools_ListOfShape theList;
290
291 TopoDS_Shape U;
292 U.Nullify();
293 gp_Pnt FirstCorner, LastCorner;
294 Standard_Real bnd = HeightMax(mySbase, U, FirstCorner, LastCorner);
295 myBnd = bnd;
296
297 BRepPrimAPI_MakeBox Bndbox(FirstCorner, LastCorner);
298 TopoDS_Solid BndBox = Bndbox.Solid();
299
300
0d969553 301// ---Construction of the working plane face (section bounding box)
7fd59977 302 BRepLib_MakeFace PlaneF(myPln->Pln(), -6.*myBnd,
303 6.*myBnd, -6.*myBnd, 6.*myBnd);
304 TopoDS_Face PlaneFace = TopoDS::Face(PlaneF.Shape());
305
306 //modified by NIZNHY-PKV Fri Mar 22 16:52:26 2002 f
307 //BRepAlgo_Common PlaneS(BndBox, PlaneFace);
308 BRepAlgoAPI_Common PlaneS(BndBox, PlaneFace);
309 //modified by NIZNHY-PKV Fri Mar 22 16:52:31 2002 t
310 TopExp_Explorer EXP;
311 TopoDS_Shape PlaneSect = PlaneS.Shape();
312 EXP.Init(PlaneSect, TopAbs_WIRE);
313 TopoDS_Wire www = TopoDS::Wire(EXP.Current());
314 BRepLib_MakeFace Bndface(myPln->Pln(), www, Standard_True);
315 TopoDS_Face BndFace = TopoDS::Face(Bndface.Shape());
316
317
0d969553 318// ---Find base faces of the rib
7fd59977 319 TopoDS_Edge FirstEdge, LastEdge;
320 TopoDS_Face FirstFace, LastFace;
321 TopoDS_Vertex FirstVertex, LastVertex;
322
323 Standard_Boolean OnFirstFace = Standard_False;
324 Standard_Boolean OnLastFace = Standard_False;
325 Standard_Boolean PtOnFirstEdge = Standard_False;
326 Standard_Boolean PtOnLastEdge = Standard_False;
327 TopoDS_Edge OnFirstEdge, OnLastEdge;
328 OnFirstEdge.Nullify();
329 OnLastEdge.Nullify();
330
331 Standard_Boolean Data = ExtremeFaces(RevolRib, myBnd, myPln, FirstEdge, LastEdge,
332 FirstFace, LastFace, FirstVertex,
333 LastVertex, OnFirstFace, OnLastFace,
334 PtOnFirstEdge, PtOnLastEdge,
335 OnFirstEdge, OnLastEdge);
336
337 if(!Data) {
338#ifdef DEB
339 if (trc) cout << " No Extreme faces" << endl;
340#endif
341 myStatusError = BRepFeat_NoExtFace;
342 NotDone();
343 return;
344 }
345
346
0d969553 347// ---Proofing Point for the side of the wire to be filled - material side
7fd59977 348 gp_Pnt CheckPnt = CheckPoint(FirstEdge, bnd/10., myPln);
349
350// Standard_Real f, l;
351
0d969553
Y
352// ---Control sliding valid
353// Many cases when the sliding is abandoned
354 Standard_Integer Concavite = 3; // a priori the profile is not concave
7fd59977 355
356 myFirstPnt = BRep_Tool::Pnt(FirstVertex);
357 myLastPnt = BRep_Tool::Pnt(LastVertex);
358
0d969553 359// SliList : list of faces concerned by the rib
7fd59977 360 TopTools_ListOfShape SliList;
361 SliList.Append(FirstFace);
362
0d969553 363 if(Sliding) { // sliding
7fd59977 364#ifdef DEB
365 if (trc) cout << " Sliding" << endl;
366#endif
367 Handle(Geom_Surface) s = BRep_Tool::Surface(FirstFace);
368 if (s->DynamicType() ==
369 STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
370 s = Handle(Geom_RectangularTrimmedSurface)::
371 DownCast(s)->BasisSurface();
372 }
373 if(s->DynamicType() != STANDARD_TYPE(Geom_Plane) &&
374 s->DynamicType() != STANDARD_TYPE(Geom_CylindricalSurface) &&
375 s->DynamicType() != STANDARD_TYPE(Geom_ConicalSurface) &&
376 s->DynamicType() != STANDARD_TYPE(Geom_ToroidalSurface))
377 Sliding = Standard_False;
378 }
379
0d969553 380 if(Sliding) { // sliding
7fd59977 381 Handle(Geom_Surface) ss = BRep_Tool::Surface(LastFace);
382 if (ss->DynamicType() ==
383 STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
384 ss = Handle(Geom_RectangularTrimmedSurface)::
385 DownCast(ss)->BasisSurface();
386 }
387 if(ss->DynamicType() != STANDARD_TYPE(Geom_Plane) &&
388 ss->DynamicType() != STANDARD_TYPE(Geom_CylindricalSurface) &&
389 ss->DynamicType() != STANDARD_TYPE(Geom_ConicalSurface) &&
390 ss->DynamicType() != STANDARD_TYPE(Geom_ToroidalSurface))
391 Sliding = Standard_False;
392 }
393
0d969553
Y
394// Control only start and end points no control at the middle to improve
395// If make a control between Surface and segment 2 points limited
396// -> too expensive - to improve
7fd59977 397 //gp_Pnt FirstCenter, LastCenter;
398 gp_Circ FirstCircle, LastCircle;
399 Handle(Geom_Curve) FirstCrv, LastCrv;
400
0d969553 401 if(Sliding) { // sliding
7fd59977 402 GeomAPI_ProjectPointOnCurve proj(myFirstPnt, Line);
403 if(proj.NbPoints() < 1) {
404#ifdef DEB
405 if (trc) cout << " No First Point projection" << endl;
406#endif
407 myStatusError = BRepFeat_NoProjPt;
408 NotDone();
409 return;
410 }
411 Standard_Real FirstRayon = proj.Distance(1);
412 gp_Pnt FirstCenter = proj.Point(1);
413
414 GeomAPI_ProjectPointOnCurve proj1(myLastPnt, Line);
415 if(proj.NbPoints() < 1) {
416#ifdef DEB
417 if (trc) cout << " No Last Point projection" << endl;
418#endif
419 myStatusError = BRepFeat_NoProjPt;
420 NotDone();
421 return;
422 }
423 Standard_Real LastRayon = proj1.Distance(1);
424 gp_Pnt LastCenter = proj1.Point(1);
425
426 gp_Vec axv(myAxe.Direction());
427 gp_Ax2 ax2(FirstCenter, axv);
428 gp_Ax2 ax2p(LastCenter, axv);
429 gp_Circ theFC(ax2, FirstRayon);
430 gp_Circ theLC(ax2p, LastRayon);
431
432 gp_Pnt RFirstPnt1 = myFirstPnt.Rotated(myAxe, myAngle1);
433 gp_Pnt RLastPnt1 = myLastPnt.Rotated(myAxe, myAngle1);
434 gp_Pnt RFirstPnt2 = myFirstPnt.Rotated(myAxe, -myAngle2);
435 gp_Pnt RLastPnt2 = myLastPnt.Rotated(myAxe, -myAngle2);
436
437 BRep_Builder Bu;
438 TopoDS_Vertex v1, v2, v3, v4;
439 Bu.MakeVertex(v1, RFirstPnt2, Precision::Confusion());
440 Bu.MakeVertex(v2, RFirstPnt1, Precision::Confusion());
441 Bu.MakeVertex(v3, RLastPnt2, Precision::Confusion());
442 Bu.MakeVertex(v4, RLastPnt1, Precision::Confusion());
443
444 BRepLib_MakeEdge ee1(theFC, v1, v2);
445 BRepLib_MakeEdge ee2(theLC, v3, v4);
446
447 if(Sliding && !PtOnFirstEdge) {
448 BRepExtrema_ExtCF ext1(TopoDS::Edge(ee1.Shape()), FirstFace);
08cd2f6b 449 if(ext1.NbExt() < 1 || ext1.SquareDistance(1) > Precision::SquareConfusion())
7fd59977 450 Sliding = Standard_False;
451 }
452 if(Sliding && !PtOnLastEdge) {
0d969553 453 BRepExtrema_ExtCF ext2(ee2, LastFace); // ExtCF : curves and surfaces
08cd2f6b 454 if(ext2.NbExt() < 1 || ext2.SquareDistance(1) > Precision::SquareConfusion())
7fd59977 455 Sliding = Standard_False;
456 }
457 if(Sliding && PtOnFirstEdge) {
458 Standard_Real f, l;
459 FirstCrv = BRep_Tool::Curve(OnFirstEdge, f, l);
460 if(FirstCrv->DynamicType() != STANDARD_TYPE(Geom_Circle))
461 Sliding = Standard_False;
462 else {
463 Handle(Geom_Circle) C1 = Handle(Geom_Circle)::DownCast(FirstCrv);
464 gp_Circ Circ = C1->Circ();
465 FirstCircle = Circ;
466 gp_Ax1 circax = FirstCircle.Axis();
467 if(!circax.IsCoaxial(myAxe, Precision::Confusion(),
468 Precision::Confusion()))
469 Sliding = Standard_False;
470 else {
471//#ifndef DEB
472 if(fabs(FirstCircle.Radius()-FirstRayon) >=
473//#else
474// if(abs(FirstCircle.Radius()-FirstRayon) >=
475//#endif
476 Precision::Confusion())
477 Sliding = Standard_False;
478 }
479 }
480 }
481
482 if(Sliding && PtOnLastEdge) {
483 Standard_Real f, l;
484 LastCrv = BRep_Tool::Curve(OnLastEdge, f, l);
485 if(LastCrv->DynamicType() != STANDARD_TYPE(Geom_Circle))
486 Sliding = Standard_False;
487 else {
488 Handle(Geom_Circle) C1 = Handle(Geom_Circle)::DownCast(LastCrv);
489 gp_Circ Circ = C1->Circ();
490 LastCircle = Circ;
491 gp_Ax1 circax = LastCircle.Axis();
492 if(!circax.IsCoaxial(myAxe, Precision::Confusion(),
493 Precision::Confusion()))
494 Sliding = Standard_False;
495 else {
496 Standard_Real rad = LastCircle.Radius();
497//#ifndef DEB
498 if(fabs(rad - LastRayon) >= Precision::Confusion()) {
499//#else
500// if(abs(rad - LastRayon) >= Precision::Confusion()) {
501//#endif
502 Sliding = Standard_False;
503 }
504 }
505 }
506 }
507 }
508
509
0d969553
Y
510// Construct a great profile that goes till the bounding box
511// -> by tangency with first and last edge of the Wire
512// -> by normals to base faces : statistically better
513// Intersect everythin to find the final profile
7fd59977 514
515
0d969553 516// ---case of sliding : construction of the face profile
7fd59977 517 if(Sliding) {
518#ifdef DEB
519 if (trc) cout << " still Sliding" << endl;
520#endif
521 TopoDS_Face Prof;
522 Standard_Boolean ProfileOK;
523 ProfileOK = SlidingProfile(Prof,RevolRib,myTol,Concavite,myPln,BndFace,CheckPnt,
524 FirstFace,LastFace,FirstVertex,LastVertex,
525 FirstEdge,LastEdge);
526
527 if (!ProfileOK) {
528#ifdef DEB
529 cout << "Not computable" << endl;
530 if (trc) cout << "Face profile not computable" << endl;
531#endif
532 myStatusError = BRepFeat_NoFaceProf;
533 NotDone();
534 return;
535 }
536
537
0d969553
Y
538// ---Propagation on faces of the initial shape
539// to find the faces concerned by the rib
7fd59977 540 Standard_Boolean falseside = Standard_True;
541 Sliding = Propagate(SliList, Prof, myFirstPnt, myLastPnt, falseside);
0d969553 542// Control if there is everything required to have the material at the proper side
7fd59977 543 if(falseside == Standard_False) {
544#ifdef DEB
545 cout << " Verify plane and wire orientation" << endl;
546#endif
547 myStatusError = BRepFeat_FalseSide;
548 NotDone();
549 return;
550 }
551 }
552
553
0d969553 554// ---Generation of the base profile of the rib
7fd59977 555
556 TopoDS_Wire w;
557 BB.MakeWire(w);
558 TopoDS_Edge thePreviousEdge;
559 TopoDS_Vertex theFV;
560 thePreviousEdge.Nullify();
561
0d969553 562// counter of the number of edges to fill the map
7fd59977 563 Standard_Integer counter = 1;
564
0d969553 565// ---case of sliding
7fd59977 566 if(Sliding && !myListOfEdges.IsEmpty()) {
567 BRepTools_WireExplorer EX1(myWire);
568 for(; EX1.More(); EX1.Next()) {
569 const TopoDS_Edge& E = EX1.Current();
570 if(!myLFMap.IsBound(E)) {
571 TopTools_ListOfShape theTmpList;
572 myLFMap.Bind(E, theTmpList);
573 }
574 if(E.IsSame(FirstEdge)) {
575 Standard_Real f, l;
576 Handle(Geom_Curve) cc = BRep_Tool::Curve(E, f, l);
577 gp_Pnt pt;
578 if(!FirstEdge.IsSame(LastEdge)) {
579 pt = BRep_Tool::Pnt(TopExp::LastVertex(E,Standard_True));
580 }
581 else {
582 pt = myLastPnt;
583 Standard_Real fpar = IntPar(cc, myFirstPnt);
584 Standard_Real lpar = IntPar(cc, pt);
585 Handle(Geom_Curve) ccc;
586 if(fpar > lpar) {
587 ccc = Handle(Geom_Curve)::DownCast(cc->Reversed());
588 cc = ccc;
589 }
590 }
591 TopoDS_Edge ee1;
592 if(thePreviousEdge.IsNull()) {
593 BRepLib_MakeVertex v1(myFirstPnt);
594 BRepLib_MakeVertex v2(pt);
595 BRepLib_MakeEdge e(cc, v1, v2);
596 ee1 = TopoDS::Edge(e.Shape());
597 }
598 else {
599 const TopoDS_Vertex& v1 = TopExp::LastVertex(thePreviousEdge,Standard_True);
600 BRepLib_MakeVertex v2(pt);
601
602 BRepLib_MakeEdge e(cc, v1, v2);
603 ee1 = TopoDS::Edge(e.Shape());
604 }
605 TopoDS_Shape aLocalShape = ee1.Oriented(E.Orientation());
606 ee1 = TopoDS::Edge(aLocalShape);
607// ee1 = TopoDS::Edge(ee1.Oriented(E.Orientation()));
608 if(counter == 1) theFV = TopExp::FirstVertex(ee1,Standard_True);
609 myLFMap(E).Append(ee1);
610 BB.Add(w, ee1);
611 thePreviousEdge = ee1;
612 counter++;
613 EX1.Next();
614 break;
615 }
616 }
617
0d969553 618// Case of several edges
7fd59977 619 if(!FirstEdge.IsSame(LastEdge)) {
620 for(; EX1.More(); EX1.Next()) {
621 const TopoDS_Edge& E = EX1.Current();
622 if(!myLFMap.IsBound(E)) {
623 TopTools_ListOfShape thelist1;
624 myLFMap.Bind(E, thelist1);
625 }
626 theList.Append(E);
627 Standard_Real f, l;
628 if(!E.IsSame(LastEdge)) {
629 Handle(Geom_Curve) ccc = BRep_Tool::Curve(E, f, l);
630 TopoDS_Vertex v1, v2;
631 if(!thePreviousEdge.IsNull()) {
632 v1 = TopExp::LastVertex(thePreviousEdge,Standard_True);
633 v2 = TopExp::LastVertex(E,Standard_True);
634 }
635 else {
636// v1 = TopExp::LastVertex(E,Standard_True);
637 v1 = TopExp::FirstVertex(E,Standard_True);
638 v2 = TopExp::LastVertex(E,Standard_True);
639 }
640 BRepLib_MakeEdge E1(ccc, v1, v2);
641 TopoDS_Edge E11 = TopoDS::Edge(E1.Shape());
642 TopoDS_Shape aLocalShape = E11.Oriented(E.Orientation());
643 E11 = TopoDS::Edge(aLocalShape);
644// E11 = TopoDS::Edge(E11.Oriented(E.Orientation()));
645 thePreviousEdge = E11;
646 myLFMap(E).Append(E11);
647 BB.Add(w, E11);
648 if(counter == 1) theFV = TopExp::FirstVertex(E11,Standard_True);
649 counter++;
650 }
651 else {
652 Standard_Real f, l;
653 Handle(Geom_Curve) cc = BRep_Tool::Curve(E, f, l);
654 gp_Pnt pf = BRep_Tool::Pnt(TopExp::FirstVertex(E,Standard_True));
655 gp_Pnt pl = myLastPnt;
656 TopoDS_Edge ee;
657 if(thePreviousEdge.IsNull()) {
658 BRepLib_MakeEdge e(cc, pf , pl);
659 ee = TopoDS::Edge(e.Shape());
660 }
661 else {
662 const TopoDS_Vertex& v1 = TopExp::LastVertex(thePreviousEdge,Standard_True);
663 BRepLib_MakeVertex v2(pl);
664 BRepLib_MakeEdge e(cc, v1, v2);
665 ee = TopoDS::Edge(e.Shape());
666 }
667 TopoDS_Shape aLocalShape = ee.Oriented(E.Orientation());
668 ee = TopoDS::Edge(aLocalShape);
669// ee = TopoDS::Edge(ee.Oriented(E.Orientation()));
670 BB.Add(w, ee);
671 myLFMap(E).Append(ee);
672 if(counter == 1) theFV = TopExp::FirstVertex(ee,Standard_True);
673 thePreviousEdge = ee;
674 counter++;
675 break;
676 }
677 }
678 }
679
680 TopTools_ListIteratorOfListOfShape it(myListOfEdges);
681 Standard_Boolean FirstOK = Standard_False;
682 Standard_Boolean LastOK = Standard_False;
683
684 gp_Pnt theLastPnt = myLastPnt;
685 Standard_Integer sens = 0;
686 TopoDS_Edge theEdge, theLEdge, theFEdge;
687 Standard_Integer counter1 = counter;
688 TopTools_ListOfShape NewListOfEdges;
689 NewListOfEdges.Clear();
690 while (!FirstOK) {
691 const TopoDS_Edge& edg = TopoDS::Edge(it.Value());
692 gp_Pnt fp, lp;
693 Standard_Real f, l;
694 Handle(Geom_Curve) ccc = BRep_Tool::Curve(edg, f, l);
695 Handle(Geom_TrimmedCurve) cc = new Geom_TrimmedCurve(ccc, f, l);
696 if ( edg.Orientation() == TopAbs_REVERSED) cc->Reverse();
697
698 fp = cc->Value(cc->FirstParameter());
699 lp = cc->Value(cc->LastParameter());
700 Standard_Real dist = fp.Distance(theLastPnt);
701 if(dist <= myTol) {
702 sens = 1;
703 LastOK = Standard_True;
704 }
705 else {
706 dist = lp.Distance(theLastPnt);
707 if(dist <= myTol) {
708 sens = 2;
709 LastOK = Standard_True;
710 cc->Reverse();
711 }
712 }
713 Standard_Integer FirstFlag = 0;
714 if(sens==1 && lp.Distance(myFirstPnt) <= myTol) {
715 FirstOK = Standard_True;
716 FirstFlag = 1;
717 }
718 else if(sens==2 && fp.Distance(myFirstPnt) <= myTol) {
719 FirstOK = Standard_True;
720 FirstFlag = 2;
721 }
722
723 if (LastOK) {
724 TopoDS_Edge eeee;
725 Standard_Real fpar = cc->FirstParameter();
726 Standard_Real lpar = cc->LastParameter();
727 if(!FirstOK) {
728 if(thePreviousEdge.IsNull()) {
729 BRepLib_MakeEdge e(cc, fpar, lpar);
730 eeee = TopoDS::Edge(e.Shape());
731 }
732 else {
733 const TopoDS_Vertex& v1 = TopExp::LastVertex(thePreviousEdge,Standard_True);
734 BRepLib_MakeVertex v2(cc->Value(lpar));
735 BRepLib_MakeEdge e(cc, v1, v2);
736 eeee = TopoDS::Edge(e.Shape());
737 }
738 }
739 else {
740 if(thePreviousEdge.IsNull()) {
741 BRepLib_MakeVertex v1(cc->Value(fpar));
742 BRepLib_MakeEdge e(cc, v1, theFV);
743 eeee = TopoDS::Edge(e.Shape());
744 }
745 else {
746 const TopoDS_Vertex& v1 = TopExp::LastVertex(thePreviousEdge,Standard_True);
747 BRepLib_MakeEdge e(cc, v1, theFV);
748 eeee = TopoDS::Edge(e.Shape());
749 }
750 }
751
752 thePreviousEdge = eeee;
753 BB.Add(w, eeee);
754 if(counter == 1) theFV = TopExp::FirstVertex(eeee,Standard_True);
755 counter1++;
756 NewListOfEdges.Append(edg);
757 theEdge = eeee;
6e6cd5d9 758
7fd59977 759 if(dist <= myTol)
760 theFEdge = edg;
761 theLastPnt = BRep_Tool::Pnt(TopExp::LastVertex(theEdge,Standard_True));
762 }
763
764 if(FirstFlag == 1) {
765 theLEdge = edg;
766 }
767 else if(FirstFlag == 2) {
768 theLEdge = theEdge;
769 }
770
771 if(LastOK) {
772 it.Initialize(myListOfEdges);
773 LastOK = Standard_False;
774 }
775 else if(it.More()) it.Next();
776 else {
777 Sliding = Standard_False;
778 break;
779 }
780 sens = 0;
781 }
782
783
784 TopTools_DataMapOfShapeListOfShape SlidMap;
785 SlidMap.Clear();
786
787 if(Sliding && counter1 > counter) {
788 TopTools_ListIteratorOfListOfShape it;
789 TopTools_DataMapIteratorOfDataMapOfShapeListOfShape itm;
790 TopExp_Explorer EX2(w, TopAbs_EDGE);
791 Standard_Integer ii = 0;
792 for(; EX2.More(); EX2.Next()) {
793 const TopoDS_Edge& E = TopoDS::Edge(EX2.Current());
794 ii++;
795 if(ii >= counter && ii <= counter1) {
796 it.Initialize(NewListOfEdges);
797 Standard_Integer jj = 0;
798 for(; it.More(); it.Next()) {
799 const TopoDS_Edge& e2 = TopoDS::Edge(it.Value());
800 jj++;
801 if(jj== (ii - counter +1)) {
802 itm.Initialize(mySlface);
803 for(; itm.More(); itm.Next()) {
804 const TopoDS_Face& fac = TopoDS::Face(itm.Key());
805 const TopTools_ListOfShape& ledg = itm.Value();
806 TopTools_ListIteratorOfListOfShape itedg(ledg);
807 //Standard_Integer iiii = 0;
808 for(; itedg.More(); itedg.Next()) {
809 const TopoDS_Edge& e1 = TopoDS::Edge(itedg.Value());
810 if(e1.IsSame(e2)){
811 if(!SlidMap.IsBound(fac)) {
812 TopTools_ListOfShape thelist2;
813 SlidMap.Bind(fac, thelist2);
814 }
815 SlidMap(fac).Append(E);
816 }
817 }
818 }
819 }
820 }
821 }
822 }
823 }
824
825 mySlface.Clear();
826 mySlface = SlidMap;
827 }
828
0d969553
Y
829// ---Arguments of LocOpe_LinearForm : arguments of the prism
830// sliding
7fd59977 831 if(Sliding) {
832 TopoDS_Face F;
833 BB.MakeFace(F, myPln, myTol);
834 BB.Add(F, w);
835 mySkface = F;
836 myPbase = mySkface;
837 mySUntil.Nullify();
838 }
839
840
0d969553 841// ---Case without sliding : construction of the face profile
7fd59977 842 if(!Sliding) {
843#ifdef DEB
844 if (trc) {
845 if (Modify) cout << " Sliding failure" << endl;
846 cout << " no Sliding" << endl;
847 }
848#endif
849 TopExp_Explorer explo1(BndFace, TopAbs_WIRE);
850 TopoDS_Wire WWW = TopoDS::Wire(explo1.Current());
851 BRepTools_WireExplorer explo(WWW);
852 BRep_Builder Bu;
853 TopoDS_Wire Wiwiwi;
854 Bu.MakeWire(Wiwiwi);
855 TopoDS_Vertex NewV1, NewV2, LastV, v;
856 NewV1.Nullify(); NewV2.Nullify(); LastV.Nullify();
857
858 for(; explo.More(); explo.Next()) {
859 const TopoDS_Edge& e = TopoDS::Edge(explo.Current());
860 TopoDS_Vertex v1 = TopExp::FirstVertex(e,Standard_True);
861 TopoDS_Vertex v2 = TopExp::LastVertex(e,Standard_True);
862
863 Standard_Real f, l;//, t;
864 Handle(Geom_Curve) ln = BRep_Tool::Curve(e, f, l);
865// Handle(Geom_Curve) lln = BRep_Tool::Curve(e, f, l);
866// Handle(Geom_Curve) ln;
867// if(e.Orientation() == TopAbs_REVERSED) {
868// ln = Handle(Geom_Curve)::DownCast(lln->Reversed());
869// v = v1; v1 = v2; v2= v;
870// f = IntPar(ln, BRep_Tool::Pnt(v1));
871// l = IntPar(ln, BRep_Tool::Pnt(v2));
872// }
873// else ln = lln;
874
875 Handle(Geom2d_Curve) l2d = GeomAPI::To2d(ln, Plane->Pln());
876 Geom2dAPI_InterCurveCurve intcc(l2d, ln2d, Precision::Confusion());
877 TopoDS_Vertex VV; VV.Nullify();
878 TopoDS_Edge ee1, ee2;
879
880 if(intcc.NbPoints() > 0) {
881 gp_Pnt2d P = intcc.Point(1);
882 gp_Pnt point;
883 myPln->D0(P.X(), P.Y(), point);
884 Standard_Real par = IntPar(ln, point);
885 if(f <= par && l >= par) {
886 Bu.MakeVertex(VV, point, Precision::Confusion());
887 }
888 }
889
890 if(VV.IsNull() && NewV1.IsNull()) continue;
891
892 if(!VV.IsNull() && NewV1.IsNull()) {
893 NewV1 = VV;
894 LastV = v2;
895 BRepLib_MakeEdge ee1(NewV1, LastV);
896 Bu.Add(Wiwiwi, ee1);
897 continue;
898 }
899
900 if(VV.IsNull() && !NewV1.IsNull()) {
901 BRepLib_MakeEdge ee1(LastV, v2);
902 LastV = v2;
903 Bu.Add(Wiwiwi, e);
904 continue;
905 }
906
907 if(!VV.IsNull() && !NewV1.IsNull()) {
908 NewV2 = VV;
909 BRepLib_MakeEdge ee1(LastV, NewV2);
910 LastV = NewV2;
911 Bu.Add(Wiwiwi, ee1);
912 BRepLib_MakeEdge ee2(LastV, NewV1);
913 Bu.Add(Wiwiwi, ee2);
914 break;
915 }
916 }
917
918 BRepLib_MakeFace newbndface(myPln->Pln(), Wiwiwi, Standard_True);
919 TopoDS_Face NewBndFace = TopoDS::Face(newbndface.Shape());
920
921 BRepTopAdaptor_FClass2d Cl(NewBndFace, Precision::Confusion());
922 Standard_Real paru, parv;
923 ElSLib::Parameters(myPln->Pln(), CheckPnt, paru, parv);
924 gp_Pnt2d checkpnt2d(paru, parv);
925 if(Cl.Perform(checkpnt2d, Standard_True) == TopAbs_OUT) {
926 //modified by NIZNHY-PKV Fri Mar 22 16:52:52 2002 f
927 //BRepAlgo_Cut c(BndFace, NewBndFace);
928 BRepAlgoAPI_Cut c(BndFace, NewBndFace);
929 //modified by NIZNHY-PKV Fri Mar 22 16:52:57 2002 t
930 TopExp_Explorer exp(c.Shape(), TopAbs_WIRE);
931 const TopoDS_Wire& w = TopoDS::Wire(exp.Current());
932 // akm 13/02/02 : we know the plane. Why not to use it?
933 // BRepLib_MakeFace ff(w);
934 BRepLib_MakeFace ff(myPln->Pln(), w, Standard_True);
935 NewBndFace = TopoDS::Face(ff.Shape());
936 }
937
938
939 if(!BRepAlgo::IsValid(NewBndFace)) {
940#ifdef DEB
941 cout << "Invalid new bounding face" << endl;
942#endif
943 myStatusError = BRepFeat_InvShape;
944 NotDone();
945 return;
946 }
947
948 BndFace = NewBndFace;
949
950
951 TopoDS_Face Prof;
952 Standard_Boolean ProfileOK;
953 ProfileOK = NoSlidingProfile(Prof,RevolRib,myTol,Concavite,myPln,
954 bnd,BndFace,CheckPnt,
955 FirstFace,LastFace,FirstVertex,LastVertex,
956 FirstEdge,LastEdge,OnFirstFace,OnLastFace);
957
958 if (!ProfileOK) {
959#ifdef DEB
960 cout << "Not computable" << endl;
961 if (trc) cout << " Face profile not computable" << endl;
962#endif
963 myStatusError = BRepFeat_NoFaceProf;
964 NotDone();
965 return;
966 }
967
968
0d969553
Y
969// ---Propagation on the faces of the initial shape
970// to find the faces concerned by the rib
7fd59977 971 Standard_Boolean falseside = Standard_True;
972 Propagate(SliList, Prof, myFirstPnt, myLastPnt, falseside);
0d969553 973// Control if there is everything required to have the material at the proper side
7fd59977 974 if(falseside == Standard_False) {
975#ifdef DEB
976 cout << " Verify plane and wire orientation" << endl;
977#endif
978 myStatusError = BRepFeat_FalseSide;
979 NotDone();
980 return;
981 }
982
983 mySlface.Clear();
984
985 TopTools_ListIteratorOfListOfShape it;
986 it.Initialize(SliList);
987
988 TopoDS_Shape comp;
989
990 BRep_Builder BB;
991 BB.MakeShell(TopoDS::Shell(comp));
992
993 for(; it.More(); it.Next()) {
994 BB.Add(comp, it.Value());
995 }
996
997 mySUntil = comp;
998
999 mySkface = Prof;
1000 myPbase = Prof;
1001 }
1002
1003 mySliding = Sliding;
1004
1005 TopExp_Explorer exp;
1006 for ( exp.Init(mySbase,TopAbs_FACE);exp.More();exp.Next()) {
1007 TopTools_ListOfShape thelist3;
1008 myMap.Bind(exp.Current(), thelist3);
1009 myMap(exp.Current()).Append(exp.Current());
1010 }
1011}
1012
1013
1014
1015//=======================================================================
1016//function : Add
0d969553 1017//purpose : add elements of gluing
7fd59977 1018//=======================================================================
1019
1020void BRepFeat_MakeRevolutionForm::Add(const TopoDS_Edge& E,
1021 const TopoDS_Face& F)
1022{
1023#ifdef DEB
1024 Standard_Boolean trc = BRepFeat_GettraceFEAT();
1025 if (trc) cout << "BRepFeat_MakeRevolutionForm::Add" << endl;
1026#endif
1027 if(mySlface.IsEmpty()) {
1028 TopExp_Explorer exp;
1029 for (exp.Init(mySbase,TopAbs_FACE);exp.More();exp.Next()) {
1030 if (exp.Current().IsSame(F)) {
1031 break;
1032 }
1033 }
1034 if (!exp.More()) {
1035 Standard_ConstructionError::Raise();
1036 }
1037
1038 if (!mySlface.IsBound(F)) {
1039 TopTools_ListOfShape thelist;
1040 mySlface.Bind(F, thelist);
1041 }
1042 TopTools_ListIteratorOfListOfShape itl(mySlface(F));
1043 for (; itl.More();itl.Next()) {
1044 if (itl.Value().IsSame(E)) {
1045 break;
1046 }
1047 }
1048 if (!itl.More()) {
1049 mySlface(F).Append(E);
1050 }
1051 }
1052}
1053
1054
1055
1056//=======================================================================
1057//function : Perform
1058//purpose : construction
1059//=======================================================================
1060
1061void BRepFeat_MakeRevolutionForm::Perform()
1062{
1063#ifdef DEB
1064 Standard_Boolean trc = BRepFeat_GettraceFEAT();
1065 if (trc) cout << "BRepFeat_MakeRevolutionForm::Perform()" << endl;
1066#endif
1067 if(mySbase.IsNull() || mySkface.IsNull() || myPbase.IsNull()) {
1068#ifdef DEB
1069 if (trc) cout << " Fields not initialized" << endl;
1070#endif
1071 myStatusError = BRepFeat_NotInitialized;
1072 NotDone();
1073 return;
1074 }
1075
1076 gp_Pnt Pt;
1077
1078 TopExp_Explorer exx(myPbase, TopAbs_VERTEX);
1079 for(; exx.More(); exx.Next()) {
1080 const TopoDS_Vertex& vv = TopoDS::Vertex(exx.Current());
1081 if(!vv.IsNull()) {
1082 Pt = BRep_Tool::Pnt(vv);
1083 break;
1084 }
1085 }
1086
1087 if(myAngle2 != 0) {
1088 gp_Trsf T;
1089 T.SetRotation(myAxe, -myAngle2);
1090 BRepBuilderAPI_Transform trsf(T);
1091 trsf.Perform(myPbase, Standard_False);
1092 TopoDS_Face Pbase = TopoDS::Face(trsf.Shape());
1093 TopTools_DataMapIteratorOfDataMapOfShapeListOfShape iter(myLFMap);
1094 for(; iter.More(); iter.Next()) {
1095 const TopoDS_Shape& e1 = iter.Value().First();
1096 TopExp_Explorer ex1(myPbase, TopAbs_EDGE);
1097 TopExp_Explorer ex2(Pbase, TopAbs_EDGE);
1098 for(; ex1.More(); ex1.Next()) {
1099 if(ex1.Current().IsSame(e1)) {
1100 myLFMap(iter.Key()).Clear();
1101 myLFMap(iter.Key()).Append(ex2.Current());
1102 }
1103 ex2.Next();
1104 }
1105 }
1106
1107 TopTools_DataMapIteratorOfDataMapOfShapeListOfShape iter1(mySlface);
1108 for(; iter1.More(); iter1.Next()) {
1109 const TopoDS_Shape& f1 = iter1.Key();
1110 const TopoDS_Shape& e1 = iter1.Value().First();
1111 TopExp_Explorer ex1(myPbase, TopAbs_EDGE);
1112 TopExp_Explorer ex2(Pbase, TopAbs_EDGE);
1113 for(; ex1.More(); ex1.Next()) {
1114 const TopoDS_Shape& E1 = ex1.Current();
1115 const TopoDS_Shape& E2 = ex2.Current();
1116 if(E1.IsSame(e1)) {
1117 mySlface(f1).Clear();
1118 mySlface(f1).Append(E2);
1119 }
1120 ex2.Next();
1121 }
1122 }
1123 myPbase = Pbase;
1124 trsf.Perform(mySkface, Standard_False);
0d969553 1125// flo : check if it is required to reattributr the field mySkface
7fd59977 1126// TopoDS_Face mySkface = TopoDS::Face(trsf.Shape());
1127 mySkface = TopoDS::Face(trsf.Shape());
1128 }
1129
1130 LocOpe_RevolutionForm theForm;
1131 theForm.Perform(myPbase, myAxe, (myAngle1+myAngle2));
0d969553 1132 TopoDS_Shape VraiForm = theForm.Shape(); // uncut primitive
7fd59977 1133
0d969553 1134// management of descendants
7fd59977 1135 MajMap(myPbase,theForm,myMap,myFShape,myLShape);
1136
1137 myGluedF.Clear();
1138
1139
1140
1141 gp_Pln Pln0 = myPln->Pln();
1142 BRepLib_MakeFace f(Pln0);
1143
1144
1145 gp_Vec vec1 = myHeight1*Normal(f, Pt);
1146 gp_Vec vec2 = -myHeight2*Normal(f, Pt);
1147
1148 gp_Pln Pln1 = Pln0.Translated(vec1);
1149 gp_Pln Pln2 = Pln0.Translated(vec2);
1150
1151 BRepLib_MakeFace ff1(Pln1);
1152 BRepLib_MakeFace ff2(Pln2);
1153 TopoDS_Face f1 = TopoDS::Face(ff1.Shape());
1154 TopoDS_Face f2 = TopoDS::Face(ff2.Shape());
1155 BRepFeat::FaceUntil(mySbase, f1);
1156 BRepFeat::FaceUntil(mySbase, f2);
1157
1158 LocOpe_CSIntersector ASI1(f1);
1159 LocOpe_CSIntersector ASI2(f2);
1160
1161 Handle(Geom_Line) normale = new Geom_Line(Pt, vec1);
1162 TColGeom_SequenceOfCurve scur;
1163 scur.Append(normale);
1164
1165 ASI1.Perform(scur);
1166 ASI2.Perform(scur);
1167
1168 if(!ASI1.IsDone() || !ASI2.IsDone() ||
1169 ASI1.NbPoints(1) != 1 || ASI2.NbPoints(1) != 1) {
1170#ifdef DEB
1171 if (trc) cout << " Intersection failure" << endl;
1172#endif
1173 myStatusError = BRepFeat_BadIntersect;
1174 NotDone();
1175 return;
1176 }
1177
1178 TopAbs_Orientation Ori1 = ASI1.Point(1,1).Orientation();
1179 TopAbs_Orientation Ori2 = TopAbs::Reverse(ASI2.Point(1,1).Orientation());
1180 TopoDS_Face FF1 = ASI1.Point(1,1).Face();
1181 TopoDS_Face FF2 = ASI2.Point(1,1).Face();
1182
1183 TopoDS_Shape Comp;
1184 BRep_Builder B;
1185 B.MakeCompound(TopoDS::Compound(Comp));
1186 TopoDS_Solid S1 = BRepFeat::Tool(f1,FF1,Ori1);
1187 TopoDS_Solid S2 = BRepFeat::Tool(f2,FF2,Ori2);
1188 if (!S1.IsNull()) B.Add(Comp,S1);
1189 if (!S2.IsNull()) B.Add(Comp,S2);
1190
1191 //modified by NIZNHY-PKV Fri Mar 22 16:53:20 2002 f
1192 //BRepAlgo_Cut trP(VraiForm,Comp);
1193 BRepAlgoAPI_Cut trP(VraiForm,Comp);
1194 //modified by NIZNHY-PKV Fri Mar 22 16:53:23 2002 t
1195 // coupe de la nervure par deux plans parallels
1196 TopTools_DataMapOfShapeListOfShape SlidingMap;
1197
0d969553 1198// management of descendants
7fd59977 1199
1200 TopTools_DataMapIteratorOfDataMapOfShapeListOfShape it1;
1201 it1.Initialize(myMap);
1202 for(; it1.More(); it1.Next()) {
1203 const TopoDS_Shape& orig = it1.Key();
1204 if(it1.Value().IsEmpty()) continue;
1205 const TopoDS_Shape& sh = it1.Value().First();
1206 exx.Init(VraiForm, TopAbs_FACE);
1207 for(; exx.More(); exx.Next()) {
1208 const TopoDS_Face& fac = TopoDS::Face(exx.Current());
1209 TopExp_Explorer exx1(fac, TopAbs_WIRE);
1210 const TopoDS_Wire& thew = TopoDS::Wire(exx1.Current());
1211 if(thew.IsSame(myFShape)) {
1212 const TopTools_ListOfShape& desfaces = trP.Modified(f2);
1213 myMap(myFShape) = desfaces;
1214 continue;
1215 }
1216 else if(thew.IsSame(myLShape)) {
1217 const TopTools_ListOfShape& desfaces = trP.Modified(f1);
1218 myMap(myLShape) = desfaces;
1219 continue;
1220 }
1221 if(fac.IsSame(sh)) {
1222 if (trP.IsDeleted(fac)) {
1223 }
1224 else {
1225 const TopTools_ListOfShape& desfaces = trP.Modified(fac);
1226 if(!desfaces.IsEmpty()) {
1227 myMap(orig).Clear();
1228 myMap(orig) = trP.Modified(fac);
1229 }
1230 }
1231 }
1232 }
1233 }
1234
1235 exx.Init(VraiForm, TopAbs_FACE);
1236 for(; exx.More(); exx.Next()) {
1237 const TopoDS_Face& fac = TopoDS::Face(exx.Current());
1238 TopTools_ListOfShape thelist;
1239 SlidingMap.Bind(fac, thelist);
1240 if (trP.IsDeleted(fac)) {
1241 }
1242 else {
1243 const TopTools_ListOfShape& desfaces = trP.Modified(fac);
1244 if(!desfaces.IsEmpty())
1245 SlidingMap(fac) = desfaces;
1246 else
1247 SlidingMap(fac).Append(fac);
1248 }
1249 }
1250
1251
0d969553 1252// gestion of faces of sliding
7fd59977 1253 SetGluedFaces(mySlface, theForm, SlidingMap, myGluedF);
1254
0d969553 1255 VraiForm = trP.Shape(); // primitive cut
7fd59977 1256
1257 if(!myGluedF.IsEmpty())
1258 myPerfSelection = BRepFeat_NoSelection;
1259 else
1260 myPerfSelection = BRepFeat_SelectionSh;
1261
1262 exx.Init(myPbase, TopAbs_EDGE);
1263 for(; exx.More(); exx.Next()) {
1264 const TopoDS_Edge& e = TopoDS::Edge(exx.Current());
1265 if(!myMap.IsBound(e)) {
1266#ifdef DEB
1267 if (trc) cout << " Sliding face not in Base shape" << endl;
1268#endif
1269 myStatusError = BRepFeat_IncSlidFace;
1270 NotDone();
1271 return;
1272 }
1273 }
1274
1275 myGShape = VraiForm;
1276
1277 if(!myGluedF.IsEmpty() && !mySUntil.IsNull()) {
1278#ifdef DEB
1279 cout << "The case is not computable" << endl;
1280 if (trc) cout << " Glued faces not empty and Until shape not null" << endl;
1281#endif
1282 myStatusError = BRepFeat_InvShape;
1283 NotDone();
1284 return;
1285 }
1286
0d969553 1287 LFPerform(); // topological reconstruction
7fd59977 1288}
1289
1290
1291//=======================================================================
1292//function : Propagate
0d969553
Y
1293//purpose : propagation on the faces of the inital shape, find faces
1294// concerned by the rib
7fd59977 1295//=======================================================================
1296
1297Standard_Boolean BRepFeat_MakeRevolutionForm::Propagate(TopTools_ListOfShape& SliList,
1298 const TopoDS_Face& fac,
1299 const gp_Pnt& Firstpnt,
1300 const gp_Pnt& Lastpnt,
1301 Standard_Boolean& falseside)
1302{
1303#ifdef DEB
1304 Standard_Boolean trc = BRepFeat_GettraceFEATRIB();
1305 if (trc) cout << "BRepFeat_MakeRevolutionForm::Propagate" << endl;
1306#endif
1307 gp_Pnt Firstpoint = Firstpnt;
1308 gp_Pnt Lastpoint = Lastpnt;
1309
1310 Standard_Boolean result = Standard_True;
1311 TopoDS_Face CurrentFace, saveFace;
1312 CurrentFace = TopoDS::Face(SliList.First());
1313 saveFace = CurrentFace;
1314 // BRepBuilderAPI_MakeFace fac(myPln);
1315 Standard_Boolean LastOK = Standard_False, FirstOK= Standard_False;
1316 TopoDS_Vertex v1, v2, v3, v4, Vert;
1317 //modified by NIZNHY-PKV Fri Mar 22 16:54:09 2002 f
1318 //BRepAlgo_Section sect (fac, CurrentFace, Standard_False);
1319 BRepAlgoAPI_Section sect (fac, CurrentFace, Standard_False);
1320 //modified by NIZNHY-PKV Fri Mar 22 16:54:14 2002 t
1321 sect.Approximation(Standard_True);
1322 sect.Build();
1323 TopExp_Explorer Ex;
1324 TopoDS_Edge e, e1;
1325 gp_Pnt FP, LP;
1326 Standard_Integer ii = 0;
1327 for (Ex.Init(sect.Shape(), TopAbs_EDGE); Ex.More(); Ex.Next()) {
1328 ii++;
1329 if(ii==1){
1330 e = TopoDS::Edge(Ex.Current());
1331 }
1332 else if (ii > 1) {
1333 e1 = TopoDS::Edge(Ex.Current());
1334 break;
1335 }
1336 }
1337 if(e.IsNull()) {
1338 falseside = Standard_False;
1339 return Standard_False;
1340 }
1341 //
1342 //modified by NIZNHY-PKV Tue Apr 2 15:08:23 2002 f
1343 if(!e1.IsNull()) {
1344 Standard_Real aTolV1, aTolV2;
1345 myListOfEdges.Clear();
1346 TopTools_ListOfShape thelist;
1347 mySlface.Bind(CurrentFace, thelist);
1348 mySlface(CurrentFace).Append(e1);
1349
1350 myListOfEdges.Append(e1);
1351
1352 v1 = TopExp::FirstVertex(e1,Standard_True);
1353 v2 = TopExp::LastVertex (e1,Standard_True);
1354
1355 FP = BRep_Tool::Pnt(v1);
1356 LP = BRep_Tool::Pnt(v2);
1357
1358 aTolV1=BRep_Tool::Tolerance(v1);
1359 aTolV2=BRep_Tool::Tolerance(v2);
1360
1361 if(FP.Distance(Firstpoint) <= aTolV1 ||
1362 FP.Distance(Lastpoint) <= aTolV1) {
1363 FirstOK = Standard_True;
1364 }
1365 if(LP.Distance(Firstpoint)<= aTolV2 ||
1366 LP.Distance(Lastpoint) <= aTolV2) {
1367 LastOK = Standard_True;
1368 }
1369
1370 if(LastOK && FirstOK) {
1371 return result;
1372 }
1373
1374 else {
1375 myListOfEdges.Clear();
1376 }
1377 }
1378 //modified by NIZNHY-PKV Tue Apr 2 15:08:26 2002 t
1379 //
1380 if(!e1.IsNull()) {
1381 myListOfEdges.Clear();
1382 TopTools_ListOfShape thelist1;
1383 mySlface.Bind(CurrentFace, thelist1);
1384 mySlface(CurrentFace).Append(e);
1385
1386 myListOfEdges.Append(e);
1387
1388// mySlface.Bind(CurrentFace,TopTools_ListOfShape());
1389 mySlface(CurrentFace).Append(e1);
1390// myListOfEdges.Append(e1);
1391
1392 v1 = TopExp::FirstVertex(e,Standard_True);
1393 v2 = TopExp::LastVertex(e,Standard_True);
1394 v3 = TopExp::FirstVertex(e1,Standard_True);
1395 v4 = TopExp::LastVertex(e1,Standard_True);
1396 gp_Pnt p1, p2, p3, p4;
1397 p1 = BRep_Tool::Pnt(v1); FP = p1;
1398 p2 = BRep_Tool::Pnt(v2); LP = p2;
1399 p3 = BRep_Tool::Pnt(v3);
1400 p4 = BRep_Tool::Pnt(v4);
1401 if(p1.Distance(Firstpoint) <= BRep_Tool::Tolerance(v1)) {
1402 if(p3.Distance(Lastpoint) <= BRep_Tool::Tolerance(v3)) {
1403 FirstOK = Standard_True;
1404 Lastpoint = p4;
1405 }
1406 else if(p4.Distance(Lastpoint) <= BRep_Tool::Tolerance(v4)) {
1407 FirstOK = Standard_True;
1408 Lastpoint = p3;
1409 }
1410 else {
1411 e1.Nullify();
1412 }
1413 }
1414 else if(p1.Distance(Lastpoint) <= BRep_Tool::Tolerance(v1)) {
1415 if(p3.Distance(Firstpoint) <= BRep_Tool::Tolerance(v3)) {
1416 FirstOK = Standard_True;
1417 Firstpoint = p4;
1418 }
1419 else if(p4.Distance(Firstpoint) <= BRep_Tool::Tolerance(v4)) {
1420 FirstOK = Standard_True;
1421 Firstpoint = p3;
1422 }
1423 else {
1424 e1.Nullify();
1425 }
1426 }
1427 else if(p2.Distance(Firstpoint) <= BRep_Tool::Tolerance(v2)) {
1428 if(p3.Distance(Lastpoint) <= BRep_Tool::Tolerance(v3)) {
1429 LastOK = Standard_True;
1430 Lastpoint = p4;
1431 }
1432 else if(p4.Distance(Lastpoint) <= BRep_Tool::Tolerance(v4)) {
1433 LastOK = Standard_True;
1434 Lastpoint = p3;
1435 }
1436 else {
1437 e1.Nullify();
1438 }
1439 }
1440 else if(p2.Distance(Lastpoint) <= BRep_Tool::Tolerance(v2)) {
1441 if(p3.Distance(Firstpoint) <= BRep_Tool::Tolerance(v3)) {
1442 LastOK = Standard_True;
1443 Firstpoint = p4;
1444 }
1445 else if(p4.Distance(Firstpoint) <= BRep_Tool::Tolerance(v4)) {
1446 LastOK = Standard_True;
1447 Firstpoint = p3;
1448 }
1449 else {
1450 e1.Nullify();
1451 }
1452 }
1453 else {
4e57c75e 1454 e = e1;
7fd59977 1455 e1.Nullify();
1456 }
1457 }
1458 if(e1.IsNull()) {
7fd59977 1459 myListOfEdges.Clear();
1460 TopTools_ListOfShape thelist2;
1461 mySlface.Bind(CurrentFace, thelist2);
1462 mySlface(CurrentFace).Append(e);
1463
1464 myListOfEdges.Append(e);
1465
1466 v1 = TopExp::FirstVertex(e,Standard_True);
1467 v2 = TopExp::LastVertex(e,Standard_True);
1468
1469 FP = BRep_Tool::Pnt(v1);
1470 LP = BRep_Tool::Pnt(v2);
1471
1472 if(FP.Distance(Firstpoint) <= BRep_Tool::Tolerance(v1)
1473 || FP.Distance(Lastpoint) <= BRep_Tool::Tolerance(v1)) {
1474 FirstOK = Standard_True;
1475 }
1476 if(LP.Distance(Firstpoint) <= BRep_Tool::Tolerance(v2)
1477 || LP.Distance(Lastpoint) <= BRep_Tool::Tolerance(v2)) {
1478 LastOK = Standard_True;
1479 }
1480
1481 if(LastOK && FirstOK) {
1482 return result;
1483 }
1484 }
1485
1486 TopTools_IndexedDataMapOfShapeListOfShape mapedges;
1487 TopExp::MapShapesAndAncestors(mySbase, TopAbs_EDGE, TopAbs_FACE, mapedges);
1488 TopExp_Explorer ex;
1489 TopoDS_Edge FirstEdge;
1490
1491 TopoDS_Vertex Vprevious; Vprevious.Nullify();
1492 TopoDS_Vertex Vpreprevious; Vpreprevious.Nullify();
1493
1494 while(!FirstOK) {
0d969553 1495 // find edge connected to v1:
7fd59977 1496 gp_Pnt pt;
1497 if(!v1.IsNull()) pt= BRep_Tool::Pnt(v1);
1498 gp_Pnt ptprev;
1499 if(!Vprevious.IsNull()) ptprev = BRep_Tool::Pnt(Vprevious);
1500 gp_Pnt ptpreprev;
1501 if(!Vpreprevious.IsNull()) ptpreprev = BRep_Tool::Pnt(Vpreprevious);
1502
1503 if((!Vprevious.IsNull() && ptprev.Distance(pt) <= myTol) ||
1504 (!Vpreprevious.IsNull() && ptpreprev.Distance(pt) <= myTol)) {
1505 falseside = Standard_False;
1506 return Standard_False;
1507 }
1508
1509 for (ex.Init(CurrentFace, TopAbs_EDGE); ex.More(); ex.Next()) {
1510 const TopoDS_Edge& e = TopoDS::Edge(ex.Current());
1511
1512 BRepExtrema_ExtPC projF(v1, e);
1513
1514 if(projF.IsDone() && projF.NbExt() >=1) {
1515 Standard_Real dist2min = RealLast();
1516 Standard_Integer index = 0;
1517 for (Standard_Integer sol =1 ; sol <= projF.NbExt(); sol++) {
1518 if (projF.SquareDistance(sol) <= dist2min) {
1519 index = sol;
1520 dist2min = projF.SquareDistance(sol);
1521 }
1522 }
1523 if (index != 0) {
1524 if (dist2min <= BRep_Tool::Tolerance(e) * BRep_Tool::Tolerance(e)) {
1525 FirstEdge = e;
1526 break;
1527 }
1528 }
1529 }
1530 }
1531
1532 const TopTools_ListOfShape& L = mapedges.FindFromKey(FirstEdge);
1533 TopTools_ListIteratorOfListOfShape It(L);
1534
1535 for (; It.More(); It.Next()) {
1536 const TopoDS_Face& FF = TopoDS::Face(It.Value());
1537 if (!FF.IsSame(CurrentFace)) {
1538 CurrentFace = FF;
1539 break;
1540 }
1541 }
1542
1543 //modified by NIZNHY-PKV Fri Mar 22 16:54:28 2002 f
1544 //BRepAlgo_Section sectf (fac, CurrentFace, Standard_False);
1545 BRepAlgoAPI_Section sectf (fac, CurrentFace, Standard_False);
1546 //modified by NIZNHY-PKV Fri Mar 22 16:54:33 2002 t
1547 sectf.Approximation(Standard_True);
1548 sectf.Build();
1549
1550 TopoDS_Edge edg1;
1551 for (Ex.Init(sectf.Shape(), TopAbs_EDGE); Ex.More(); Ex.Next()) {
1552 edg1 = TopoDS::Edge(Ex.Current());
1553 gp_Pnt ppp1 = BRep_Tool::Pnt(TopExp::FirstVertex(edg1,Standard_True));
1554 gp_Pnt ppp2 = BRep_Tool::Pnt(TopExp::LastVertex(edg1,Standard_True));
1555 if(ppp1.Distance(BRep_Tool::Pnt(v1)) <= BRep_Tool::Tolerance(v1) ||
1556 ppp2.Distance(BRep_Tool::Pnt(v1)) <= BRep_Tool::Tolerance(v1))
1557 break;
1558 }
1559
1560 TopTools_ListOfShape thelist3;
1561 mySlface.Bind(CurrentFace, thelist3);
1562 mySlface(CurrentFace).Append(edg1);
1563 myListOfEdges.Append(edg1);
1564
1565 if (!edg1.IsNull()) SliList.Prepend(CurrentFace);
1566 else return Standard_False;
1567
1568 Vert = TopExp::FirstVertex(edg1,Standard_True);
1569 gp_Pnt PP = BRep_Tool::Pnt(Vert);
1570 FP = BRep_Tool::Pnt(v1);
1571 Standard_Real tol = BRep_Tool::Tolerance(edg1);
1572 Standard_Real tol1 = BRep_Tool::Tolerance(v1);
1573 if(tol1 > tol) tol = tol1;
1574 Standard_Real dist = PP.Distance(FP);
1575 if (dist <= tol) {
1576 Vpreprevious = Vprevious;
1577 Vprevious = v1;
1578 v1 = TopExp::LastVertex(edg1,Standard_True);
1579 }
1580 else {
1581 Vpreprevious = Vprevious;
1582 Vprevious = v1;
1583 v1 = Vert;
1584 }
1585
1586 FP = BRep_Tool::Pnt(v1);
1587
1588 if(FP.Distance(Firstpoint) <= BRep_Tool::Tolerance(v1)
1589 || FP.Distance(Lastpoint) <= BRep_Tool::Tolerance(v1)) {
1590 FirstOK = Standard_True;
1591 }
1592 }
1593
1594 CurrentFace = saveFace;
1595 Vprevious.Nullify();
1596 Vpreprevious.Nullify();
1597
1598 while(!LastOK) {
0d969553 1599 // find edge connected to v2:
7fd59977 1600 gp_Pnt pt;
1601 if(!v2.IsNull()) pt= BRep_Tool::Pnt(v2);
1602 gp_Pnt ptprev;
1603 if(!Vprevious.IsNull()) ptprev = BRep_Tool::Pnt(Vprevious);
1604 gp_Pnt ptpreprev;
1605 if(!Vpreprevious.IsNull()) ptpreprev = BRep_Tool::Pnt(Vpreprevious);
1606
1607 if((!Vprevious.IsNull() && ptprev.Distance(pt) <= myTol) ||
1608 (!Vpreprevious.IsNull() && ptpreprev.Distance(pt) <= myTol)) {
1609 falseside = Standard_False;
1610 return Standard_False;
1611 }
1612
1613 for (ex.Init(CurrentFace, TopAbs_EDGE); ex.More(); ex.Next()) {
1614 const TopoDS_Edge& e = TopoDS::Edge(ex.Current());
1615 BRepExtrema_ExtPC projF(v2, e);
1616
1617 if(projF.IsDone() && projF.NbExt() >=1) {
1618 Standard_Real dist2min = RealLast();
1619 Standard_Integer index = 0;
1620 for (Standard_Integer sol =1 ; sol <= projF.NbExt(); sol++) {
1621 if (projF.SquareDistance(sol) <= dist2min) {
1622 index = sol;
1623 dist2min = projF.SquareDistance(sol);
1624 }
1625 }
1626 if (index != 0) {
1627 if (dist2min <= BRep_Tool::Tolerance(e) * BRep_Tool::Tolerance(e)) {
1628 FirstEdge = e;
1629 break;
1630 }
1631 }
1632 }
1633 }
1634
1635 const TopTools_ListOfShape& L = mapedges.FindFromKey(FirstEdge);
1636 TopTools_ListIteratorOfListOfShape It(L);
1637
1638 for (; It.More(); It.Next()) {
1639 const TopoDS_Face& FF = TopoDS::Face(It.Value());
1640 if (!FF.IsSame(CurrentFace)) {
1641 CurrentFace = FF;
1642 break;
1643 }
1644 }
1645
1646 ii = 0;
1647
1648 //modified by NIZNHY-PKV Fri Mar 22 16:54:45 2002 f
1649 //BRepAlgo_Section sectf (fac, CurrentFace, Standard_False);
1650 BRepAlgoAPI_Section sectf (fac, CurrentFace, Standard_False);
1651 //modified by NIZNHY-PKV Fri Mar 22 16:54:52 2002 t
1652 sectf.Approximation(Standard_True);
1653 sectf.Build();
1654
1655 TopoDS_Edge edg2;
1656 for (Ex.Init(sectf.Shape(), TopAbs_EDGE); Ex.More(); Ex.Next()) {
1657 edg2 = TopoDS::Edge(Ex.Current());
1658 gp_Pnt ppp1 = BRep_Tool::Pnt(TopExp::FirstVertex(edg2,Standard_True));
1659 gp_Pnt ppp2 = BRep_Tool::Pnt(TopExp::LastVertex(edg2,Standard_True));
1660 if(ppp1.Distance(BRep_Tool::Pnt(v2)) <= BRep_Tool::Tolerance(v2) ||
1661 ppp2.Distance(BRep_Tool::Pnt(v2)) <= BRep_Tool::Tolerance(v2))
1662 break;
1663 }
1664 TopTools_ListOfShape thelist4;
1665 mySlface.Bind(CurrentFace, thelist4);
1666 mySlface(CurrentFace).Append(edg2);
1667 myListOfEdges.Append(edg2);
1668
1669 if (!edg2.IsNull()) SliList.Append(CurrentFace);
1670 else return Standard_False;
1671
1672 Vert = TopExp::FirstVertex(edg2,Standard_True);
1673 gp_Pnt PP = BRep_Tool::Pnt(Vert);
1674 FP = BRep_Tool::Pnt(v2);
1675 if (PP.Distance(FP)<= BRep_Tool::Tolerance(v2)) {
1676 Vpreprevious = Vprevious;
1677 Vprevious = v2;
1678 v2 = TopExp::LastVertex(edg2,Standard_True);
1679 }
1680 else {
1681 v2 = Vert;
1682 }
1683 FP = BRep_Tool::Pnt(v2);
1684
1685
1686 if(FP.Distance(Firstpoint) <= BRep_Tool::Tolerance(v2)
1687 || FP.Distance(Lastpoint) <= BRep_Tool::Tolerance(v2)) {
1688 LastOK = Standard_True;
1689 }
1690 }
1691 if(!e1.IsNull()) myListOfEdges.Append(e1);
1692 return result;
1693
1694}
1695
1696
1697//=======================================================================
1698//function : MajMap
0d969553 1699//purpose : management of descendants
7fd59977 1700//=======================================================================
1701
1702static void MajMap(const TopoDS_Shape& theB,
1703 const LocOpe_RevolutionForm& theP,
1704 TopTools_DataMapOfShapeListOfShape& theMap, // myMap
1705 TopoDS_Shape& theFShape, // myFShape
1706 TopoDS_Shape& theLShape) // myLShape
1707{
1708 TopExp_Explorer exp(theP.FirstShape(),TopAbs_WIRE);
1709 if (exp.More()) {
1710 theFShape = exp.Current();
1711 TopTools_ListOfShape thelist;
1712 theMap.Bind(theFShape, thelist);
1713 for (exp.Init(theP.FirstShape(),TopAbs_FACE);exp.More();exp.Next()) {
1714 const TopoDS_Shape& sh = exp.Current();
1715 theMap(theFShape).Append(sh);
1716 }
1717 }
1718
1719 exp.Init(theP.LastShape(),TopAbs_WIRE);
1720 if (exp.More()) {
1721 theLShape = exp.Current();
1722 TopTools_ListOfShape thelist1;
1723 theMap.Bind(theLShape, thelist1);
1724 for (exp.Init(theP.LastShape(),TopAbs_FACE);exp.More();exp.Next()) {
1725 const TopoDS_Shape& sh = exp.Current();
1726 theMap(theLShape).Append(sh);
1727 }
1728 }
1729
1730 for (exp.Init(theB,TopAbs_EDGE); exp.More(); exp.Next()) {
1731 if (!theMap.IsBound(exp.Current())) {
7fd59977 1732 TopTools_ListOfShape thelist2;
1733 theMap.Bind(exp.Current(), thelist2);
1734 theMap(exp.Current()) = theP.Shapes(exp.Current());
1735 }
1736 }
1737}
1738
1739
1740 //=======================================================================
1741//function : SetGluedFaces
0d969553 1742//purpose : managemnet of sliding faces
7fd59977 1743//=======================================================================
1744
1745static void SetGluedFaces(const TopTools_DataMapOfShapeListOfShape& theSlmap,
1746 LocOpe_RevolutionForm& thePrism,
1747 const TopTools_DataMapOfShapeListOfShape& SlidingMap,
1748 TopTools_DataMapOfShapeShape& theMap)
1749{
0d969553 1750 // Slidings
7fd59977 1751 TopTools_DataMapIteratorOfDataMapOfShapeListOfShape itm(theSlmap);
1752 if(!theSlmap.IsEmpty()) {
1753 for (; itm.More(); itm.Next()) {
1754 const TopoDS_Face& fac = TopoDS::Face(itm.Key());
1755 const TopTools_ListOfShape& ledg = itm.Value();
1756 TopTools_ListIteratorOfListOfShape it;
1757 for (it.Initialize(ledg); it.More(); it.Next()) {
1758 const TopTools_ListOfShape& gfac = thePrism.Shapes(it.Value());
1759 if (gfac.Extent() != 1) {
1760#ifdef DEB
1761 cout << "Pb SetGluedFace" << endl;
1762#endif
1763 }
1764 TopTools_DataMapIteratorOfDataMapOfShapeListOfShape iterm(SlidingMap);
1765 for(; iterm.More(); iterm.Next()) {
1766 const TopoDS_Face& ff = TopoDS::Face(iterm.Key());
1767 const TopTools_ListOfShape& lfaces = iterm.Value();
1768 if(lfaces.IsEmpty()) continue;
1769 const TopoDS_Face& fff = TopoDS::Face(lfaces.First());
1770 if(gfac.First().IsSame(ff)) theMap.Bind(fff,fac);
1771 }
1772 }
1773 }
1774 }
1775}
1776