0026586: Eliminate compile warnings obtained by building occt with vc14: declaration...
[occt.git] / src / BRepFeat / BRepFeat_Form.cxx
1 // Created on: 1996-02-13
2 // Created by: Olga KOULECHOVA
3 // Copyright (c) 1996-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17
18 #include <Bnd_Box.hxx>
19 #include <BRep_Tool.hxx>
20 #include <BRepAlgo.hxx>
21 #include <BRepAlgoAPI_BooleanOperation.hxx>
22 #include <BRepAlgoAPI_Cut.hxx>
23 #include <BRepAlgoAPI_Fuse.hxx>
24 #include <BRepBndLib.hxx>
25 #include <BRepCheck_Analyzer.hxx>
26 #include <BRepFeat.hxx>
27 #include <BRepFeat_Builder.hxx>
28 #include <BRepFeat_Form.hxx>
29 #include <BRepLib.hxx>
30 #include <BRepTools_Modifier.hxx>
31 #include <BRepTools_TrsfModification.hxx>
32 #include <ElCLib.hxx>
33 #include <Geom_ConicalSurface.hxx>
34 #include <Geom_Curve.hxx>
35 #include <Geom_CylindricalSurface.hxx>
36 #include <Geom_Plane.hxx>
37 #include <Geom_RectangularTrimmedSurface.hxx>
38 #include <LocOpe.hxx>
39 #include <LocOpe_BuildShape.hxx>
40 #include <LocOpe_CSIntersector.hxx>
41 #include <LocOpe_FindEdges.hxx>
42 #include <LocOpe_Gluer.hxx>
43 #include <LocOpe_PntFace.hxx>
44 #include <LocOpe_SequenceOfCirc.hxx>
45 #include <Precision.hxx>
46 #include <Standard_NoSuchObject.hxx>
47 #include <TColgp_SequenceOfPnt.hxx>
48 #include <TopExp_Explorer.hxx>
49 #include <TopoDS.hxx>
50 #include <TopoDS_Compound.hxx>
51 #include <TopoDS_Shape.hxx>
52 #include <TopoDS_Solid.hxx>
53 #include <TopOpeBRepBuild_HBuilder.hxx>
54 #include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
55 #include <TopTools_DataMapIteratorOfDataMapOfShapeShape.hxx>
56 #include <TopTools_ListIteratorOfListOfShape.hxx>
57 #include <TopTools_MapIteratorOfMapOfShape.hxx>
58 #include <TopTools_MapOfShape.hxx>
59
60 //modified by NIZNHY-PKV Thu Mar 21 17:30:25 2002 f
61 //#include <BRepAlgo_Cut.hxx>
62 //#include <BRepAlgo_Fuse.hxx>
63 //modified by NIZNHY-PKV Thu Mar 21 17:30:29 2002 t
64 #ifdef OCCT_DEBUG
65 extern Standard_Boolean BRepFeat_GettraceFEAT();
66 #endif
67
68 static void Descendants(const TopoDS_Shape&,
69                         BRepFeat_Builder&,
70                         TopTools_MapOfShape&);
71
72 //=======================================================================
73 //function : Perform
74 //purpose  : topological reconstruction of the result
75 //=======================================================================
76   void BRepFeat_Form::GlobalPerform () 
77 {
78
79 #ifdef OCCT_DEBUG
80   Standard_Boolean trc = BRepFeat_GettraceFEAT();
81   if (trc) cout << "BRepFeat_Form::GlobalPerform ()" << endl;
82 #endif
83
84   if (!mySbOK || !myGSOK || !mySFOK || !mySUOK || !myGFOK || 
85       !mySkOK || !myPSOK) {
86 #ifdef OCCT_DEBUG
87     if (trc) cout << " Fields not initialized in BRepFeat_Form" << endl;
88 #endif
89     myStatusError = BRepFeat_NotInitialized;
90     NotDone();
91     return;
92   }
93
94 //--- Initialisation
95   TopExp_Explorer exp,exp2;
96   Standard_Integer theOpe = 2;
97   TopTools_DataMapIteratorOfDataMapOfShapeShape itm;
98
99   if(myJustFeat && !myFuse) {
100 #ifdef OCCT_DEBUG
101     if (trc) cout << " Invalid option : myJustFeat + Cut" << endl;
102 #endif
103     myStatusError = BRepFeat_InvOption;
104     NotDone();
105     return;    
106   }
107   else if(myJustFeat) {
108     theOpe = 2;
109   }
110   else if (!myGluedF.IsEmpty()) {
111     theOpe = 1;
112   }
113   else {}
114   Standard_Boolean ChangeOpe = Standard_False;
115
116   Standard_Boolean FromInShape = Standard_False;
117   Standard_Boolean UntilInShape = Standard_False;
118   
119   if (!mySFrom.IsNull()) {
120     FromInShape = Standard_True;
121     for (exp2.Init(mySFrom,TopAbs_FACE); exp2.More(); exp2.Next()) {
122       const TopoDS_Shape& ffrom = exp2.Current();
123       for (exp.Init(mySbase,TopAbs_FACE); exp.More(); exp.Next()) {
124         if (exp.Current().IsSame(ffrom)) {
125           break;
126         }
127       }
128       if (!exp.More()) {
129         FromInShape = Standard_False;
130 #ifdef OCCT_DEBUG
131         if (trc) cout << " From not in Shape" << endl;
132 #endif
133         break;
134       }
135     }
136   }
137
138   if (!mySUntil.IsNull()) {
139     UntilInShape = Standard_True;
140     for (exp2.Init(mySUntil,TopAbs_FACE); exp2.More(); exp2.Next()) {
141       const TopoDS_Shape& funtil = exp2.Current();
142       for (exp.Init(mySbase,TopAbs_FACE); exp.More(); exp.Next()) {
143         if (exp.Current().IsSame(funtil)) {
144           break;
145         }
146       }
147       if (!exp.More()) {
148         UntilInShape = Standard_False;
149 #ifdef OCCT_DEBUG
150         if (trc) cout << " Until not in Shape" << endl;
151 #endif
152         break;
153       }
154     }
155   }
156
157   TopTools_ListIteratorOfListOfShape it,it2;
158   Standard_Integer sens = 0;
159
160   TColGeom_SequenceOfCurve scur;
161   Curves(scur);
162
163   Standard_Real mf, Mf, mu, Mu;
164
165   TopAbs_Orientation Orifuntil = TopAbs_INTERNAL;
166   TopAbs_Orientation Oriffrom = TopAbs_INTERNAL;
167   TopoDS_Face FFrom,FUntil;
168   
169   LocOpe_CSIntersector ASI1;
170   LocOpe_CSIntersector ASI2;
171
172   TopTools_ListOfShape IntList;
173   IntList.Clear();
174
175 //--- 1) by intersection
176
177 // Intersection Tool Shape From
178   if (!mySFrom.IsNull()) {
179     ASI1.Init(mySFrom);
180     ASI1.Perform(scur);
181   }
182
183 // Intersection Tool Shape Until
184   if (!mySUntil.IsNull()) {
185     ASI2.Init(mySUntil);
186     ASI2.Perform(scur);
187   }
188
189   {
190 //  Find sens, FFrom, FUntil
191     for (Standard_Integer jj=1; jj<=scur.Length(); jj++) {
192       if (ASI1.IsDone() && ASI2.IsDone()) {
193         if (ASI1.NbPoints(jj) <= 0) {
194           continue;
195         }
196         mf = ASI1.Point(jj,1).Parameter();
197         Mf = ASI1.Point(jj,ASI1.NbPoints(jj)).Parameter();
198         if (ASI2.NbPoints(jj) <= 0) {
199           continue;
200         }
201         mu = ASI2.Point(jj,1).Parameter();
202         Mu = ASI2.Point(jj,ASI2.NbPoints(jj)).Parameter();
203         if (!scur(jj)->IsPeriodic()) {
204           Standard_Integer ku, kf;
205           if (! (mu > Mf || mf > Mu)) { //overlapping intervals
206             sens = 1;
207             kf = 1;
208             ku = ASI2.NbPoints(jj);
209           }   
210           else if (mu > Mf) {    
211             if (sens == -1) {
212               myStatusError = BRepFeat_IntervalOverlap;
213               NotDone();
214               return;
215             }
216             sens = 1;
217             kf = 1;
218             ku = ASI2.NbPoints(jj);
219           }
220           else {
221             if (sens == 1) {
222               myStatusError = BRepFeat_IntervalOverlap;
223               NotDone();
224               return;
225             }
226             sens = -1;
227             kf = ASI1.NbPoints(jj);
228             ku = 1;
229           }
230           if (Oriffrom == TopAbs_INTERNAL) {
231             TopAbs_Orientation Oript = ASI1.Point(jj,kf).Orientation();
232             if (Oript == TopAbs_FORWARD || Oript == TopAbs_REVERSED) {
233               if (sens == -1) {
234                 Oript = TopAbs::Reverse(Oript);
235               }
236               Oriffrom = TopAbs::Reverse(Oript);
237               FFrom = ASI1.Point(jj,kf).Face();
238             }
239           }
240           if (Orifuntil == TopAbs_INTERNAL) {
241             TopAbs_Orientation Oript = ASI2.Point(jj,ku).Orientation();
242             if (Oript == TopAbs_FORWARD || Oript == TopAbs_REVERSED) {
243               if (sens == -1) {
244                 Oript = TopAbs::Reverse(Oript);
245               }
246               Orifuntil = Oript;
247               FUntil = ASI2.Point(jj,ku).Face();
248             }
249           }
250         }
251       }
252       else if (ASI2.IsDone()) {
253         if (ASI2.NbPoints(jj) <= 0) 
254           continue;
255
256 // for base case prism on mySUntil -> ambivalent direction
257 //      ->  preferrable direction = 1
258         if(sens != 1) {
259           if (ASI2.Point(jj,1).Parameter()*
260               ASI2.Point(jj,ASI2.NbPoints(jj)).Parameter()<=0) 
261             sens=1;
262           else if (ASI2.Point(jj,1).Parameter()<0.) 
263             sens =-1;
264           else 
265             sens =1;
266         }
267
268         Standard_Integer ku;
269         if (sens == -1) {
270           ku = 1;
271         }
272         else {
273           ku = ASI2.NbPoints(jj);
274         }
275         if (Orifuntil == TopAbs_INTERNAL && sens != 0) {
276           TopAbs_Orientation Oript = ASI2.Point(jj,ku).Orientation();
277           if (Oript == TopAbs_FORWARD || Oript == TopAbs_REVERSED) {
278             if (sens == -1) {
279               Oript = TopAbs::Reverse(Oript);
280             }
281             Orifuntil = Oript;
282             FUntil = ASI2.Point(jj,ku).Face();
283           }
284         }
285       }
286       else { 
287         sens = 1;
288         break;
289       }
290     }
291   }
292
293   LocOpe_Gluer theGlue;
294   
295 //--- case of gluing
296
297   if (theOpe == 1) {
298 #ifdef OCCT_DEBUG
299     if (trc) cout << " Gluer" << endl;
300 #endif
301     Standard_Boolean Collage = Standard_True;  
302     // cut by FFrom && FUntil
303     TopoDS_Shape Comp;
304     BRep_Builder B;
305     B.MakeCompound(TopoDS::Compound(Comp));
306     if (!mySFrom.IsNull()) {
307       TopoDS_Solid S = BRepFeat::Tool(mySFrom,FFrom,Oriffrom);
308       if (!S.IsNull()) {
309         B.Add(Comp,S);
310       }
311     }
312     if (!mySUntil.IsNull()) {
313       TopoDS_Solid S = BRepFeat::Tool(mySUntil,FUntil,Orifuntil);
314       if (!S.IsNull()) {
315         B.Add(Comp,S);
316       }
317     }
318
319     LocOpe_FindEdges theFE;
320     TopTools_DataMapOfShapeListOfShape locmap;
321     TopExp_Explorer expp(Comp, TopAbs_SOLID);
322     if(expp.More() && !Comp.IsNull() && !myGShape.IsNull())  {
323       //modified by NIZNHY-PKV Thu Mar 21 17:15:36 2002 f
324       //BRepAlgo_Cut trP(myGShape,Comp);
325       BRepAlgoAPI_Cut trP(myGShape, Comp);
326       //modified by NIZNHY-PKV Thu Mar 21 17:15:58 2002 t
327       exp.Init(trP.Shape(), TopAbs_SOLID);
328       if (exp.Current().IsNull()) {
329         theOpe = 2;
330         ChangeOpe = Standard_True;
331         Collage = Standard_False;
332       }
333       else {// else X0
334         // Only solids are preserved
335         TopoDS_Shape theGShape;
336         B.MakeCompound(TopoDS::Compound(theGShape));
337         for (; exp.More(); exp.Next()) {
338           B.Add(theGShape,exp.Current());
339         }
340         if (!BRepAlgo::IsValid(theGShape)) {
341           theOpe = 2;
342           ChangeOpe = Standard_True;
343           Collage = Standard_False;
344         }
345         else {// else X1
346           if(!mySFrom.IsNull()) { 
347             TopExp_Explorer ex;
348             ex.Init(mySFrom, TopAbs_FACE);
349             for(; ex.More(); ex.Next()) {
350               const TopoDS_Face& fac = TopoDS::Face(ex.Current());
351               if (!FromInShape) {
352                 TopTools_ListOfShape thelist;
353                 myMap.Bind(fac, thelist);
354               }
355               else {
356                 TopTools_ListOfShape thelist1;
357                 locmap.Bind(fac, thelist1);
358               }
359               if (trP.IsDeleted(fac)) {
360               }
361               else if (!FromInShape) {
362                 myMap(fac) = trP.Modified(fac);
363                 if (myMap(fac).IsEmpty()) myMap(fac).Append(fac);
364               }
365               else {
366                 locmap(fac) =trP.Modified(fac) ;
367                 if (locmap(fac).IsEmpty()) locmap(fac).Append(fac);
368               }
369             }
370           }// if(!mySFrom.IsNull()) 
371           //
372           if(!mySUntil.IsNull()) { 
373             TopExp_Explorer ex;
374             ex.Init(mySUntil, TopAbs_FACE);
375             for(; ex.More(); ex.Next()) {
376               const TopoDS_Face& fac = TopoDS::Face(ex.Current());
377               if (!UntilInShape) {                
378                 TopTools_ListOfShape thelist2;
379                 myMap.Bind(fac,thelist2);
380               }
381               else {
382                 TopTools_ListOfShape thelist3;
383                 locmap.Bind(fac,thelist3);
384               }
385               if (trP.IsDeleted(fac)) {
386               }
387               else if (!UntilInShape) {
388                 myMap(fac) = trP.Modified(fac);
389                 if (myMap(fac).IsEmpty()) myMap(fac).Append(fac);
390               }
391               else {
392                 locmap(fac) = trP.Modified(fac);
393                 if (locmap(fac).IsEmpty()) locmap(fac).Append(fac);
394               }
395             }
396           }// if(!mySUntil.IsNull())
397           //
398           //modified by NIZNHY-PKV Thu Mar 21 17:21:49 2002 f
399           //UpdateDescendants(trP.Builder(),theGShape,Standard_True); // skip faces
400           UpdateDescendants(trP,theGShape,Standard_True); // skip faces
401           //modified by NIZNHY-PKV Thu Mar 21 17:22:32 2002 t
402
403           theGlue.Init(mySbase,theGShape);
404           for (itm.Initialize(myGluedF);itm.More();itm.Next()) {
405             const TopoDS_Face& gl = TopoDS::Face(itm.Key());
406             TopTools_ListOfShape ldsc;
407             if (trP.IsDeleted(gl)) {
408             }
409             else {
410               ldsc = trP.Modified(gl);
411               if (ldsc.IsEmpty()) ldsc.Append(gl);
412             }
413             const TopoDS_Face& glface = TopoDS::Face(itm.Value());        
414             for (it.Initialize(ldsc);it.More();it.Next()) {
415               const TopoDS_Face& fac = TopoDS::Face(it.Value());
416               Collage = BRepFeat::IsInside(fac, glface);
417               if(!Collage) {
418                 theOpe = 2;
419                 ChangeOpe = Standard_True;
420                 break;
421               }
422               else {
423                 theGlue.Bind(fac,glface);
424                 theFE.Set(fac,glface);
425                 for (theFE.InitIterator(); theFE.More();theFE.Next()) {
426                   theGlue.Bind(theFE.EdgeFrom(),theFE.EdgeTo());
427                 }
428               }
429             }
430           }
431         }// else X1
432       }// else X0
433     }// if(expp.More() && !Comp.IsNull() && !myGShape.IsNull()) 
434     else {
435       theGlue.Init(mySbase,myGShape);
436       for (itm.Initialize(myGluedF); itm.More();itm.Next()) {
437         const TopoDS_Face& glface = TopoDS::Face(itm.Key());
438         const TopoDS_Face& fac = TopoDS::Face(myGluedF(glface));
439         for (exp.Init(myGShape,TopAbs_FACE); exp.More(); exp.Next()) {
440           if (exp.Current().IsSame(glface)) {
441             break;
442           }
443         }
444         if (exp.More()) {
445           Collage = BRepFeat::IsInside(glface, fac);
446           if(!Collage) {
447             theOpe = 2;
448             ChangeOpe = Standard_True;
449             break;
450           }
451           else {
452             theGlue.Bind(glface, fac);
453             theFE.Set(glface, fac);
454             for (theFE.InitIterator(); theFE.More();theFE.Next()) {
455               theGlue.Bind(theFE.EdgeFrom(),theFE.EdgeTo());
456             }
457           }
458         }
459       }
460     }
461
462     // Add gluing on start and end face if necessary !!!
463     if (FromInShape && Collage) {
464       TopExp_Explorer ex(mySFrom,TopAbs_FACE);
465       for(; ex.More(); ex.Next()) {
466         const TopoDS_Face& fac2 = TopoDS::Face(ex.Current());
467 //        for (it.Initialize(myMap(fac2)); it.More(); it.Next()) {
468         for (it.Initialize(locmap(fac2)); it.More(); it.Next()) {
469           const TopoDS_Face& fac1 = TopoDS::Face(it.Value());
470           theFE.Set(fac1, fac2);
471           theGlue.Bind(fac1, fac2);
472           for (theFE.InitIterator(); theFE.More();theFE.Next()) {
473             theGlue.Bind(theFE.EdgeFrom(),theFE.EdgeTo());
474           }
475         }
476 //        myMap.UnBind(fac2);
477       }
478     }
479
480     if (UntilInShape && Collage) {
481       TopExp_Explorer ex(mySUntil, TopAbs_FACE);
482       for(; ex.More(); ex.Next()) {
483         const TopoDS_Face& fac2 = TopoDS::Face(ex.Current());
484 //        for (it.Initialize(myMap(fac2)); it.More(); it.Next()) {
485         for (it.Initialize(locmap(fac2)); it.More(); it.Next()) {
486           const TopoDS_Face& fac1 = TopoDS::Face(it.Value());
487           theGlue.Bind(fac1, fac2);
488           theFE.Set(fac1, fac2);
489           for (theFE.InitIterator(); theFE.More();theFE.Next()) {
490             theGlue.Bind(theFE.EdgeFrom(),theFE.EdgeTo());
491           }
492         }
493         //myMap.UnBind(fac2); // to avoid fac2 in Map when
494         // UpdateDescendants(theGlue) is called
495       }
496     }
497
498     LocOpe_Operation ope = theGlue.OpeType();
499     if (ope == LocOpe_INVALID ||
500         (myFuse && ope != LocOpe_FUSE) ||
501         (!myFuse && ope != LocOpe_CUT) ||
502         (!Collage)) {
503       theOpe = 2;
504       ChangeOpe = Standard_True;
505     }
506   }
507
508 //--- if the gluing is always applicable
509
510   if (theOpe == 1) {
511 #ifdef OCCT_DEBUG
512     if (trc) cout << " still Gluer" << endl;
513 #endif
514     theGlue.Perform();
515     if (theGlue.IsDone()) {
516       TopoDS_Shape shshs = theGlue.ResultingShape();
517 //      if (BRepOffsetAPI::IsTopologicallyValid(shshs)) {
518       if (BRepAlgo::IsValid(shshs)) {
519         UpdateDescendants(theGlue);
520         myNewEdges = theGlue.Edges();
521         myTgtEdges = theGlue.TgtEdges();
522 #ifdef OCCT_DEBUG
523           if (trc) cout << " Gluer result" << endl;
524 #endif
525         Done();
526         myShape = theGlue.ResultingShape();
527       }
528       else {
529         theOpe = 2;
530         ChangeOpe = Standard_True;
531       }
532     }
533     else {
534       theOpe = 2;
535       ChangeOpe = Standard_True;
536     }
537   }
538
539
540 //--- case without gluing + Tool with proper dimensions
541
542   if (theOpe == 2 && ChangeOpe && myJustGluer) {
543 #ifdef OCCT_DEBUG
544     if (trc) cout << " Gluer failure" << endl;
545 #endif
546     myJustGluer = Standard_False;
547     theOpe = 0;
548 //    Done();
549 //    return;
550   }
551
552 //--- case without gluing
553
554   if (theOpe == 2) {
555 #ifdef OCCT_DEBUG
556     if (trc) cout << " No Gluer" << endl;
557 #endif
558     TopoDS_Shape theGShape = myGShape;
559     if (ChangeOpe) {
560 #ifdef OCCT_DEBUG
561       if (trc) cout << " Passage to topological operations" << endl;
562 #endif
563     }    
564
565     TopoDS_Shape Comp;
566     BRep_Builder B;
567     B.MakeCompound(TopoDS::Compound(Comp));
568     if (!mySFrom.IsNull() || !mySUntil.IsNull()) {
569       if (!mySFrom.IsNull() && !FromInShape) {
570         TopoDS_Solid S = BRepFeat::Tool(mySFrom,FFrom,Oriffrom);
571         if (!S.IsNull()) {
572           B.Add(Comp,S);
573         }
574       }
575       if (!mySUntil.IsNull() && !UntilInShape) {
576         if (!mySFrom.IsNull()) {
577           if (!mySFrom.IsSame(mySUntil)) {
578             TopoDS_Solid S = BRepFeat::Tool(mySUntil,FUntil,Orifuntil);
579             if (!S.IsNull()) {
580               B.Add(Comp,S);
581             }
582           }
583         }
584         else {
585           TopoDS_Solid S = BRepFeat::Tool(mySUntil,FUntil,Orifuntil);
586           if (!S.IsNull()) {
587             B.Add(Comp,S);
588           }
589         }
590       }
591     }
592
593 // update type of selection
594     if(myPerfSelection == BRepFeat_SelectionU && !UntilInShape) {
595       myPerfSelection = BRepFeat_NoSelection;
596     }
597     else if(myPerfSelection == BRepFeat_SelectionFU &&
598             !FromInShape && !UntilInShape) {
599       myPerfSelection = BRepFeat_NoSelection;
600     }
601     else if(myPerfSelection == BRepFeat_SelectionShU && !UntilInShape) {
602       myPerfSelection = BRepFeat_NoSelection;
603     }
604     else {}
605
606     TopExp_Explorer expp(Comp, TopAbs_SOLID);
607     if(expp.More() && !Comp.IsNull() && !myGShape.IsNull())  {
608       //modified by NIZNHY-PKV Thu Mar 21 17:24:52 2002 f
609       //BRepAlgo_Cut trP(myGShape,Comp);
610       BRepAlgoAPI_Cut trP(myGShape, Comp);
611       //modified by NIZNHY-PKV Thu Mar 21 17:24:56 2002 t
612       // the result is necessarily a compound.
613       exp.Init(trP.Shape(),TopAbs_SOLID);
614       if (!exp.More()) {
615         myStatusError = BRepFeat_EmptyCutResult;
616         NotDone();
617         return;
618       }
619       // Only solids are preserved
620       theGShape.Nullify();
621       B.MakeCompound(TopoDS::Compound(theGShape));
622       for (; exp.More(); exp.Next()) {
623         B.Add(theGShape,exp.Current());
624       }
625       if (!BRepAlgo::IsValid(theGShape)) {
626         myStatusError = BRepFeat_InvShape;
627         NotDone();
628         return;
629       }
630       if(!mySFrom.IsNull()) {
631         if(!FromInShape) {
632           TopExp_Explorer ex(mySFrom, TopAbs_FACE);
633           for(; ex.More(); ex.Next()) {
634             const TopoDS_Face& fac = TopoDS::Face(ex.Current());
635             TopTools_ListOfShape thelist4;
636             myMap.Bind(fac,thelist4);
637             if (trP.IsDeleted(fac)) {
638             }
639             else {
640               myMap(fac) = trP.Modified(fac);
641              if (myMap(fac).IsEmpty())  myMap(fac).Append(fac);
642             }
643           }
644         }
645       }
646       if(!mySUntil.IsNull()) {
647         if(!UntilInShape) {
648           TopExp_Explorer ex(mySUntil, TopAbs_FACE);
649           for(; ex.More(); ex.Next()) {
650             const TopoDS_Face& fac = TopoDS::Face(ex.Current());
651             TopTools_ListOfShape thelist5;
652             myMap.Bind(fac,thelist5);
653             if (trP.IsDeleted(fac)) {
654             }
655             else {
656               myMap(fac) = trP.Modified(fac);
657               if (myMap.IsEmpty()) myMap(fac).Append(fac);
658             }
659           }
660         }
661       }
662       //modified by NIZNHY-PKV Thu Mar 21 17:27:23 2002 f
663       //UpdateDescendants(trP.Builder(),theGShape,Standard_True); 
664       UpdateDescendants(trP,theGShape,Standard_True); 
665       //modified by NIZNHY-PKV Thu Mar 21 17:27:31 2002 t
666     }//if(expp.More() && !Comp.IsNull() && !myGShape.IsNull())  {
667     //
668
669 //--- generation of "just feature" for assembly = Parts of tool
670     Standard_Boolean bFlag = (myPerfSelection == BRepFeat_NoSelection) ? 0 : 1;
671     BRepFeat_Builder theBuilder;
672     theBuilder.Init(mySbase, theGShape);
673     theBuilder.SetOperation(myFuse, bFlag);
674     theBuilder.Perform();
675     //
676     TopTools_ListOfShape lshape;
677     theBuilder.PartsOfTool(lshape);
678     //
679     Standard_Real pbmin = RealLast(), pbmax = RealFirst();
680     Standard_Real prmin = RealLast()  - 2*Precision::Confusion();
681     Standard_Real prmax = RealFirst() + 2*Precision::Confusion();
682     Standard_Boolean flag1 = Standard_False;
683     Handle(Geom_Curve) C;
684
685 //--- Selection of pieces of tool to be preserved
686     if(!lshape.IsEmpty() && myPerfSelection != BRepFeat_NoSelection) {
687 //      Find ParametricMinMax depending on the constraints of Shape From and Until
688 //   -> prmin, prmax, pbmin and pbmax
689       C = BarycCurve();
690       if (C.IsNull()) {
691         myStatusError = BRepFeat_EmptyBaryCurve; 
692         NotDone();
693         return;
694       }
695
696       if(myPerfSelection == BRepFeat_SelectionSh) {
697         BRepFeat::ParametricMinMax(mySbase,C, 
698                                    prmin, prmax, pbmin, pbmax, flag1);
699       }
700       else if(myPerfSelection == BRepFeat_SelectionFU) {
701         Standard_Real prmin1, prmax1, prmin2, prmax2;
702         Standard_Real prbmin1, prbmax1, prbmin2, prbmax2;
703       
704         BRepFeat::ParametricMinMax(mySFrom,C, 
705                                    prmin1, prmax1, prbmin1, prbmax1, flag1);
706         BRepFeat::ParametricMinMax(mySUntil,C, 
707                                    prmin2, prmax2, prbmin2, prbmax2, flag1);
708
709 // case of revolutions
710         if (C->IsPeriodic()) {
711           Standard_Real period = C->Period();
712           prmax = prmax2;
713           if (flag1) {
714             prmin = ElCLib::InPeriod(prmin1,prmax-period,prmax);
715           }
716           else {
717             prmin = Min(prmin1, prmin2);
718           }
719           pbmax = prbmax2;
720           pbmin = ElCLib::InPeriod(prbmin1,pbmax-period,pbmax);
721         }
722         else {
723           prmin = Min(prmin1, prmin2);
724           prmax = Max(prmax1, prmax2);
725           pbmin = Min(prbmin1, prbmin2);
726           pbmax = Max(prbmax1, prbmax2);
727         }
728       }
729       else if(myPerfSelection == BRepFeat_SelectionShU) {
730         Standard_Real prmin1, prmax1, prmin2, prmax2;
731         Standard_Real prbmin1, prbmax1, prbmin2, prbmax2;
732         
733         if(!myJustFeat && sens == 0) sens =1;
734         if (sens == 0) {
735           myStatusError = BRepFeat_IncDirection;
736           NotDone();
737           return;
738         }
739         
740         BRepFeat::ParametricMinMax(mySUntil,C, 
741                                    prmin1, prmax1, prbmin1, prbmax1, flag1);
742
743         BRepFeat::ParametricMinMax(mySbase,C, 
744                                    prmin2, prmax2, prbmin2, prbmax2, flag1);
745         if (sens == 1) {
746           prmin = prmin2;
747           prmax = prmax1;
748           pbmin = prbmin2;
749           pbmax = prbmax1;
750         }
751         else if (sens == -1) {
752           prmin = prmin1;
753           prmax = prmax2;
754           pbmin = prbmin1;
755           pbmax = prbmax2;
756         }
757       }
758       else if (myPerfSelection == BRepFeat_SelectionU) {
759         Standard_Real prmin1, prmax1, prbmin1, prbmax1;
760               if (sens == 0) {
761           myStatusError = BRepFeat_IncDirection;
762           NotDone();
763           return;
764         }
765         
766         // Find parts of the tool containing descendants of Shape Until
767         BRepFeat::ParametricMinMax(mySUntil,C, 
768                                    prmin1, prmax1, prbmin1, prbmax1, flag1);
769         if (sens == 1) {
770           prmin = RealFirst();
771           prmax = prmax1;
772           pbmin = RealFirst();
773           pbmax = prbmax1;
774         }
775         else if(sens == -1) {
776           prmin = prmin1;
777           prmax = RealLast();
778           pbmin = prbmin1;
779           pbmax = RealLast();
780         }
781       }
782
783
784 // Finer choice of ParametricMinMax in case when the tool 
785 // intersects Shapes From and Until
786 //       case of several intersections (keep PartsOfTool according to the selection)  
787 //       position of the face of intersection in PartsOfTool (before or after)
788       Standard_Real delta = Precision::Confusion();
789
790       if (myPerfSelection != BRepFeat_NoSelection) {
791 // modif of the test for cts21181 : (prbmax2 and prnmin2) -> (prbmin1 and prbmax1)
792 // correction take into account flag2 for pro15323 and flag3 for pro16060
793         if (!mySUntil.IsNull()) {
794           TopTools_MapOfShape mapFuntil;
795           Descendants(mySUntil,theBuilder,mapFuntil);
796           if (!mapFuntil.IsEmpty()) {
797             for (it.Initialize(lshape); it.More(); it.Next()) {
798               TopExp_Explorer expf;
799               for (expf.Init(it.Value(),TopAbs_FACE); 
800                    expf.More(); expf.Next()) {
801                 if (mapFuntil.Contains(expf.Current())) {
802                   Standard_Boolean flag2,flag3;
803                   Standard_Real prmin1, prmax1, prbmin1, prbmax1;
804                   Standard_Real prmin2, prmax2, prbmin2, prbmax2;
805                   BRepFeat::ParametricMinMax(expf.Current(),C, prmin1, prmax1,
806                                              prbmin1, prbmax1,flag3);
807                   BRepFeat::ParametricMinMax(it.Value(),C, prmin2, prmax2,
808                                              prbmin2, prbmax2,flag2);
809                   if (sens == 1) {
810                     Standard_Boolean testOK = !flag2;
811                     if (flag2) {
812                       testOK = !flag1;
813                       if (flag1 && prmax2 > prmin + delta) {
814                         testOK = !flag3;
815                         if (flag3 && prmax1 == prmax2) {
816                           testOK = Standard_True;
817                         }
818                       }
819                     }
820                     if (prbmin1 < pbmax && testOK) {
821                       if (flag2) {
822                         flag1 = flag2;
823                         prmax  = prmax2;
824                       }
825                       pbmax = prbmin1;
826                     }
827                   }
828                   else if (sens == -1){ 
829                     Standard_Boolean testOK = !flag2;
830                     if (flag2) {
831                       testOK = !flag1;
832                       if (flag1 && prmin2 < prmax - delta) {
833                         testOK = !flag3;
834                         if (flag3 && prmin1 == prmin2) {
835                           testOK = Standard_True;
836                         }
837                       }
838                     }
839                     if (prbmax1 > pbmin && testOK) {
840                       if (flag2) {
841                         flag1 = flag2;
842                         prmin  = prmin2;
843                       }
844                       pbmin = prbmax1;
845                     }
846                   }
847                   break;
848                 }                
849               }
850             }
851             it.Initialize(lshape);
852           }
853         }
854         if (!mySFrom.IsNull()) {
855           TopTools_MapOfShape mapFfrom;
856           Descendants(mySFrom, theBuilder, mapFfrom);
857           if (!mapFfrom.IsEmpty()) {
858             for (it.Initialize(lshape); it.More(); it.Next()) {
859               TopExp_Explorer expf;
860               for (expf.Init(it.Value(),TopAbs_FACE); 
861                    expf.More(); expf.Next()) {
862                 if (mapFfrom.Contains(expf.Current())) {
863                   Standard_Boolean flag2,flag3;
864                   Standard_Real prmin1, prmax1, prbmin1, prbmax1;
865                   Standard_Real prmin2, prmax2, prbmin2, prbmax2;
866                   BRepFeat::ParametricMinMax(expf.Current(),C, prmin1, prmax1,
867                                              prbmin1, prbmax1,flag3);
868                   BRepFeat::ParametricMinMax(it.Value(),C, prmin2, prmax2,
869                                              prbmin2, prbmax2,flag2);
870                   if (sens == 1) {
871                     Standard_Boolean testOK = !flag2;
872                     if (flag2) {
873                       testOK = !flag1;
874                       if (flag1 && prmin2 < prmax - delta) {
875                         testOK = !flag3;
876                         if (flag3 && prmin1 == prmin2) {
877                           testOK = Standard_True;
878                         }
879                       }
880                     }
881                     if (prbmax1 > pbmin && testOK) {
882                       if (flag2) {
883                         flag1 = flag2;
884                         prmin  = prmin2;
885                       }
886                       pbmin = prbmax1;
887                     }
888                   }
889                   else if (sens == -1){
890                     Standard_Boolean testOK = !flag2;
891                     if (flag2) {
892                       testOK = !flag1;
893                       if (flag1 && prmax2 > prmin + delta) {
894                         testOK = !flag3;
895                         if (flag3 && prmax1 == prmax2) {
896                           testOK = Standard_True;
897                         }
898                       }
899                     }
900                     if (prbmin1 < pbmax && testOK) {
901                       if (flag2) {
902                         flag1 = flag2;
903                         prmax  = prmax2;
904                       }
905                       pbmax = prbmin1;
906                     }
907                   }
908                   break;
909                 }                
910               }
911             }
912             it.Initialize(lshape);
913           }
914         }
915       }
916
917
918 // Parse PartsOfTool to preserve or not depending on ParametricMinMax
919       if (!myJustFeat) {
920         Standard_Boolean KeepParts = Standard_False;
921         Standard_Real prmin1, prmax1, prbmin1, prbmax1;
922         Standard_Real min, max, pmin, pmax;
923         Standard_Boolean flag2;
924         for (it.Initialize(lshape); it.More(); it.Next()) {
925           if (C->IsPeriodic()) {
926             Standard_Real period = C->Period();
927             Standard_Real pr, prb;
928             BRepFeat::ParametricMinMax(it.Value(),C, pr, prmax1,
929                                        prb, prbmax1,flag2,Standard_True);
930             if (flag2) {
931               prmin1 = ElCLib::InPeriod(pr,prmax1-period,prmax1);
932             }
933             else {
934               prmin1 = pr;
935             }
936             prbmin1 = ElCLib::InPeriod(prb,prbmax1-period,prbmax1);
937           }
938           else {
939             BRepFeat::ParametricMinMax(it.Value(),C, 
940                                        prmin1, prmax1, prbmin1, prbmax1,flag2);
941           }
942           if(flag2 == Standard_False || flag1 == Standard_False) {
943             pmin = pbmin;
944             pmax = pbmax;
945             min = prbmin1;
946             max = prbmax1;
947           }
948           else {
949             pmin = prmin;
950             pmax = prmax;
951             min = prmin1;
952             max = prmax1;
953           }
954           if (!((min > pmax - delta) || 
955                 (max < pmin + delta))) {
956             KeepParts = Standard_True;
957             const TopoDS_Shape& S = it.Value();
958             theBuilder.KeepPart(S);
959           }
960         }
961
962 // Case when no part of the tool is preserved
963         if (!KeepParts) {
964 #ifdef OCCT_DEBUG
965           if (trc) cout << " No parts of tool kept" << endl;
966 #endif
967           myStatusError = BRepFeat_NoParts;
968           NotDone();
969           return;
970         }
971       }
972       else {
973 // case JustFeature -> all PartsOfTool are preserved
974         Standard_Real prmin1, prmax1, prbmin1, prbmax1;
975         Standard_Real min, max, pmin, pmax;
976         Standard_Boolean flag2;
977         TopoDS_Shape Compo;
978         B.MakeCompound(TopoDS::Compound(Compo));
979         for (it.Initialize(lshape); it.More(); it.Next()) {
980           BRepFeat::ParametricMinMax(it.Value(),C, 
981                                      prmin1, prmax1, prbmin1, prbmax1,flag2);
982           if(flag2 == Standard_False || flag1 == Standard_False) {
983             pmin = pbmin;
984             pmax = pbmax;
985             min = prbmin1;
986             max = prbmax1;
987           }
988           else { 
989             pmin = prmin;
990             pmax = prmax;
991             min = prmin1;
992             max = prmax1;
993           }
994           if ((min < pmax - delta) && 
995               (max > pmin + delta)){
996             if (!it.Value().IsNull()) {
997               B.Add(Compo,it.Value());
998             }
999           }
1000         }
1001         myShape = Compo;
1002       }
1003     }
1004  
1005 //--- Generation of result myShape
1006
1007     if (!myJustFeat) {
1008       // removal of edges of section that have no common vertices
1009       // with PartsOfTool preserved
1010       //modified by NIZHNY-EMV Thu May 10 15:56:24 2012
1011       if (bFlag) { 
1012         theBuilder.PerformResult();
1013         myShape = theBuilder.Shape();
1014       } else {
1015         myShape = theBuilder.Shape();
1016       }
1017       //modified by NIZHNY-EMV Thu May 10 15:56:26 2012
1018       Done();
1019     }
1020     else {
1021       // all is already done
1022       Done();
1023     }
1024   }
1025
1026   myStatusError = BRepFeat_OK;
1027 }
1028
1029 //=======================================================================
1030 //function : IsDeleted
1031 //purpose  : 
1032 //=======================================================================
1033
1034 Standard_Boolean BRepFeat_Form::IsDeleted(const TopoDS_Shape& F)
1035 {
1036   return (myMap(F).IsEmpty());
1037 }
1038
1039 //=======================================================================
1040 //function : Modified
1041 //purpose  : 
1042 //=======================================================================
1043
1044 const TopTools_ListOfShape& BRepFeat_Form::Modified
1045    (const TopoDS_Shape& F)
1046 {
1047   if (myMap.IsBound(F)) {
1048     static TopTools_ListOfShape list;
1049     list.Clear(); // For the second passage DPF
1050     TopTools_ListIteratorOfListOfShape ite(myMap(F));
1051     for(; ite.More(); ite.Next()) {
1052       const TopoDS_Shape& sh = ite.Value();
1053       if(!sh.IsSame(F)) 
1054         list.Append(sh);
1055     }
1056     return list;
1057   }
1058   return myGenerated; // empty list
1059 }
1060
1061 //=======================================================================
1062 //function : Generated
1063 //purpose  : 
1064 //=======================================================================
1065
1066 const TopTools_ListOfShape& BRepFeat_Form::Generated
1067    (const TopoDS_Shape& S)
1068 {
1069   if (myMap.IsBound(S) && 
1070       S.ShapeType() != TopAbs_FACE) { // check if filter on face or not
1071     static TopTools_ListOfShape list;
1072     list.Clear(); // For the second passage DPF
1073     TopTools_ListIteratorOfListOfShape ite(myMap(S));
1074     for(; ite.More(); ite.Next()) {
1075       const TopoDS_Shape& sh = ite.Value();
1076       if(!sh.IsSame(S)) 
1077         list.Append(sh);
1078     }
1079     return list;
1080   }
1081   else return myGenerated;
1082 }
1083
1084
1085
1086 //=======================================================================
1087 //function : UpdateDescendants
1088 //purpose  : 
1089 //=======================================================================
1090
1091 void BRepFeat_Form::UpdateDescendants(const LocOpe_Gluer& G)
1092 {
1093   TopTools_DataMapIteratorOfDataMapOfShapeListOfShape itdm;
1094   TopTools_ListIteratorOfListOfShape it,it2;
1095   TopTools_MapIteratorOfMapOfShape itm;
1096
1097   for (itdm.Initialize(myMap);itdm.More();itdm.Next()) {
1098     const TopoDS_Shape& orig = itdm.Key();
1099     TopTools_MapOfShape newdsc;
1100     for (it.Initialize(itdm.Value());it.More();it.Next()) {
1101       const TopoDS_Face& fdsc = TopoDS::Face(it.Value()); 
1102       for (it2.Initialize(G.DescendantFaces(fdsc));
1103            it2.More();it2.Next()) {
1104         newdsc.Add(it2.Value());
1105       }
1106     }
1107     myMap.ChangeFind(orig).Clear();
1108     for (itm.Initialize(newdsc);itm.More();itm.Next()) {
1109       myMap.ChangeFind(orig).Append(itm.Key());
1110     }
1111   }
1112 }
1113
1114
1115
1116
1117
1118 //=======================================================================
1119 //function : FirstShape
1120 //purpose  : 
1121 //=======================================================================
1122
1123 const TopTools_ListOfShape& BRepFeat_Form::FirstShape() const
1124 {
1125   if (!myFShape.IsNull()) {
1126     return myMap(myFShape);
1127   }
1128   return myGenerated; // empty list
1129 }
1130
1131
1132 //=======================================================================
1133 //function : LastShape
1134 //purpose  : 
1135 //=======================================================================
1136
1137 const TopTools_ListOfShape& BRepFeat_Form::LastShape() const
1138 {
1139   if (!myLShape.IsNull()) {
1140     return myMap(myLShape);
1141   }
1142   return myGenerated; // empty list
1143 }
1144
1145
1146 //=======================================================================
1147 //function : NewEdges
1148 //purpose  : 
1149 //=======================================================================
1150
1151 const TopTools_ListOfShape& BRepFeat_Form::NewEdges() const
1152 {
1153   return myNewEdges;
1154 }
1155
1156
1157 //=======================================================================
1158 //function : NewEdges
1159 //purpose  : 
1160 //=======================================================================
1161
1162 const TopTools_ListOfShape& BRepFeat_Form::TgtEdges() const
1163 {
1164   return myTgtEdges;
1165 }
1166
1167
1168 //=======================================================================
1169 //function : TransformSUntil
1170 //purpose  : Limitation of the shape until the case of infinite faces
1171 //=======================================================================
1172
1173 Standard_Boolean BRepFeat_Form::TransformShapeFU(const Standard_Integer flag)
1174 {
1175 #ifdef OCCT_DEBUG
1176   Standard_Boolean trc = BRepFeat_GettraceFEAT();
1177 #endif
1178   Standard_Boolean Trf = Standard_False;
1179
1180   TopoDS_Shape shapefu;
1181   if(flag == 0)
1182     shapefu = mySFrom;
1183   else if(flag == 1)
1184     shapefu = mySUntil;
1185   else 
1186     return Trf;
1187
1188   TopExp_Explorer exp(shapefu, TopAbs_FACE);
1189   if (!exp.More()) { // no faces... It is necessary to return an error
1190 #ifdef OCCT_DEBUG
1191     if (trc) cout << " BRepFeat_Form::TransformShapeFU : invalid Shape" << endl;
1192 #endif
1193     return Trf;
1194   }
1195
1196   exp.Next();
1197   if (!exp.More()) { // the only face. Is it infinite?
1198     exp.ReInit();
1199     TopoDS_Face fac = TopoDS::Face(exp.Current());
1200
1201     Handle(Geom_Surface) S = BRep_Tool::Surface(fac);
1202     Handle(Standard_Type) styp = S->DynamicType();
1203     if (styp == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
1204       S = Handle(Geom_RectangularTrimmedSurface)::DownCast(S)->BasisSurface();
1205       styp =  S->DynamicType();
1206     }
1207
1208     if (styp == STANDARD_TYPE(Geom_Plane) ||
1209         styp == STANDARD_TYPE(Geom_CylindricalSurface) ||
1210         styp == STANDARD_TYPE(Geom_ConicalSurface)) {
1211       TopExp_Explorer exp1(fac, TopAbs_WIRE);
1212       if (!exp1.More()) {
1213         Trf = Standard_True;
1214       }
1215       else {
1216         Trf = BRep_Tool::NaturalRestriction(fac);
1217       }
1218
1219     }
1220     if (Trf) {
1221       BRepFeat::FaceUntil(mySbase, fac);
1222     }
1223
1224     if(flag == 0) {
1225       TopTools_ListOfShape thelist6;
1226       myMap.Bind(mySFrom,thelist6);
1227       myMap(mySFrom).Append(fac);
1228       mySFrom = fac;
1229     }
1230     else if(flag == 1) {
1231       TopTools_ListOfShape thelist7;
1232       myMap.Bind(mySUntil,thelist7);
1233       myMap(mySUntil).Append(fac);
1234       mySUntil = fac;
1235     }
1236     else {
1237     }
1238   }
1239   else {
1240     for (exp.ReInit(); exp.More(); exp.Next()) {
1241       const TopoDS_Shape& fac = exp.Current();
1242       TopTools_ListOfShape thelist8;
1243       myMap.Bind(fac,thelist8);
1244       myMap(fac).Append(fac);
1245     }
1246   }
1247 #ifdef OCCT_DEBUG
1248   if (trc) {
1249     if (Trf && (flag == 0)) cout << " TransformShapeFU From" << endl;
1250     if (Trf && (flag == 1)) cout << " TransformShapeFU Until" << endl;
1251   }
1252 #endif
1253   return Trf;
1254 }
1255
1256
1257 //=======================================================================
1258 //function : CurrentStatusError
1259 //purpose  : 
1260 //=======================================================================
1261
1262 BRepFeat_StatusError BRepFeat_Form::CurrentStatusError() const
1263 {
1264   return myStatusError;
1265 }
1266
1267 //=======================================================================
1268 //function : Descendants
1269 //purpose  : 
1270 //=======================================================================
1271
1272 static void Descendants(const TopoDS_Shape& S,
1273                         BRepFeat_Builder& theFB,
1274                         TopTools_MapOfShape& mapF)
1275 {
1276   mapF.Clear();
1277   TopTools_ListIteratorOfListOfShape it;
1278   TopExp_Explorer exp;
1279   for (exp.Init(S,TopAbs_FACE); exp.More(); exp.Next()) {
1280    
1281     const TopoDS_Face& fdsc = TopoDS::Face(exp.Current());
1282     const TopTools_ListOfShape& aLM=theFB.Modified(fdsc);
1283     it.Initialize(aLM);
1284     for (; it.More(); it.Next()) {
1285       mapF.Add(it.Value());
1286     }
1287     
1288   }
1289 }
1290
1291 //=======================================================================
1292 //function : UpdateDescendants
1293 //purpose  : 
1294 //=======================================================================
1295   void BRepFeat_Form::UpdateDescendants(const Handle(TopOpeBRepBuild_HBuilder)& B,
1296                                         const TopoDS_Shape& S,
1297                                         const Standard_Boolean SkipFace)
1298 {
1299   TopTools_DataMapIteratorOfDataMapOfShapeListOfShape itdm;
1300   TopTools_ListIteratorOfListOfShape it,it2;
1301   TopTools_MapIteratorOfMapOfShape itm;
1302   TopExp_Explorer exp;
1303
1304   for (itdm.Initialize(myMap);itdm.More();itdm.Next()) {
1305     const TopoDS_Shape& orig = itdm.Key();
1306     if (SkipFace && orig.ShapeType() == TopAbs_FACE) {
1307       continue;
1308     }
1309     TopTools_MapOfShape newdsc;
1310
1311     if (itdm.Value().IsEmpty()) {myMap.ChangeFind(orig).Append(orig);}
1312
1313     for (it.Initialize(itdm.Value());it.More();it.Next()) {
1314       const TopoDS_Shape& sh = it.Value();
1315       if(sh.ShapeType() != TopAbs_FACE) continue;
1316       const TopoDS_Face& fdsc = TopoDS::Face(it.Value()); 
1317       for (exp.Init(S,TopAbs_FACE);exp.More();exp.Next()) {
1318         if (exp.Current().IsSame(fdsc)) { // preserved
1319           newdsc.Add(fdsc);
1320           break;
1321         }
1322       }
1323       if (!exp.More()) {
1324         if (B->IsSplit(fdsc, TopAbs_OUT)) {
1325           for (it2.Initialize(B->Splits(fdsc,TopAbs_OUT));
1326                it2.More();it2.Next()) {
1327             newdsc.Add(it2.Value());
1328           }
1329         }
1330         if (B->IsSplit(fdsc, TopAbs_IN)) {
1331           for (it2.Initialize(B->Splits(fdsc,TopAbs_IN));
1332                it2.More();it2.Next()) {
1333             newdsc.Add(it2.Value());
1334           }
1335         }
1336         if (B->IsSplit(fdsc, TopAbs_ON)) {
1337           for (it2.Initialize(B->Splits(fdsc,TopAbs_ON));
1338                it2.More();it2.Next()) {
1339             newdsc.Add(it2.Value());
1340           }
1341         }
1342         if (B->IsMerged(fdsc, TopAbs_OUT)) {
1343           for (it2.Initialize(B->Merged(fdsc,TopAbs_OUT));
1344                it2.More();it2.Next()) {
1345             newdsc.Add(it2.Value());
1346           }
1347         }
1348         if (B->IsMerged(fdsc, TopAbs_IN)) {
1349           for (it2.Initialize(B->Merged(fdsc,TopAbs_IN));
1350                it2.More();it2.Next()) {
1351             newdsc.Add(it2.Value());
1352           }
1353         }
1354         if (B->IsMerged(fdsc, TopAbs_ON)) {
1355           for (it2.Initialize(B->Merged(fdsc,TopAbs_ON));
1356                it2.More();it2.Next()) {
1357             newdsc.Add(it2.Value());
1358           }
1359         }
1360       }
1361     }
1362     myMap.ChangeFind(orig).Clear();
1363     for (itm.Initialize(newdsc); itm.More(); itm.Next()) {
1364        // check the appartenance to the shape...
1365       for (exp.Init(S,TopAbs_FACE);exp.More();exp.Next()) {
1366         if (exp.Current().IsSame(itm.Key())) {
1367 //          const TopoDS_Shape& sh = itm.Key();
1368           myMap.ChangeFind(orig).Append(itm.Key());
1369           break;
1370         }
1371       }
1372     }
1373   }
1374 }
1375 //modified by NIZNHY-PKV Thu Mar 21 18:43:18 2002 f
1376 //=======================================================================
1377 //function : UpdateDescendants
1378 //purpose  : 
1379 //=======================================================================
1380   void BRepFeat_Form::UpdateDescendants(const BRepAlgoAPI_BooleanOperation& aBOP,
1381                                         const TopoDS_Shape& S,
1382                                         const Standard_Boolean SkipFace)
1383 {
1384   TopTools_DataMapIteratorOfDataMapOfShapeListOfShape itdm;
1385   TopTools_ListIteratorOfListOfShape it,it2;
1386   TopTools_MapIteratorOfMapOfShape itm;
1387   TopExp_Explorer exp;
1388
1389   for (itdm.Initialize(myMap);itdm.More();itdm.Next()) {
1390     const TopoDS_Shape& orig = itdm.Key();
1391     if (SkipFace && orig.ShapeType() == TopAbs_FACE) {
1392       continue;
1393     }
1394     TopTools_MapOfShape newdsc;
1395
1396     if (itdm.Value().IsEmpty()) {myMap.ChangeFind(orig).Append(orig);}
1397
1398     for (it.Initialize(itdm.Value());it.More();it.Next()) {
1399       const TopoDS_Shape& sh = it.Value();
1400       if(sh.ShapeType() != TopAbs_FACE) continue;
1401       const TopoDS_Face& fdsc = TopoDS::Face(it.Value()); 
1402       for (exp.Init(S,TopAbs_FACE);exp.More();exp.Next()) {
1403         if (exp.Current().IsSame(fdsc)) { // preserved
1404           newdsc.Add(fdsc);
1405           break;
1406         }
1407       }
1408       if (!exp.More()) {
1409         BRepAlgoAPI_BooleanOperation* pBOP=(BRepAlgoAPI_BooleanOperation*)&aBOP;
1410         const TopTools_ListOfShape& aLM=pBOP->Modified(fdsc);
1411         it2.Initialize(aLM);
1412         for (; it2.More(); it2.Next()) {
1413           const TopoDS_Shape& aS=it2.Value();
1414           newdsc.Add(aS);
1415         }
1416         
1417       }
1418     }
1419     myMap.ChangeFind(orig).Clear();
1420     for (itm.Initialize(newdsc); itm.More(); itm.Next()) {
1421        // check the appartenance to the shape...
1422       for (exp.Init(S,TopAbs_FACE);exp.More();exp.Next()) {
1423         if (exp.Current().IsSame(itm.Key())) {
1424 //          const TopoDS_Shape& sh = itm.Key();
1425           myMap.ChangeFind(orig).Append(itm.Key());
1426           break;
1427         }
1428       }
1429     }
1430   }
1431 }
1432 //modified by NIZNHY-PKV Thu Mar 21 18:43:36 2002 t