0031035: Coding - uninitialized class fields reported by Visual Studio Code Analysis
[occt.git] / src / BRepFeat / BRepFeat_MakePrism.cxx
1 // Created on: 1996-02-13
2 // Created by: Jacques GOUSSARD
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 <BRepAlgoAPI_Cut.hxx>
21 #include <BRepAlgoAPI_Fuse.hxx>
22 #include <BRepBndLib.hxx>
23 #include <BRepBuilderAPI.hxx>
24 #include <BRepFeat.hxx>
25 #include <BRepFeat_MakePrism.hxx>
26 #include <BRepLib_MakeFace.hxx>
27 #include <BRepPrimAPI_MakeBox.hxx>
28 #include <BRepTools.hxx>
29 #include <Geom_Curve.hxx>
30 #include <Geom_Line.hxx>
31 #include <Geom_Plane.hxx>
32 #include <Geom_RectangularTrimmedSurface.hxx>
33 #include <Geom_Surface.hxx>
34 #include <gp_Ax1.hxx>
35 #include <gp_Dir.hxx>
36 #include <gp_Pln.hxx>
37 #include <gp_Pnt.hxx>
38 #include <gp_Pnt2d.hxx>
39 #include <gp_Vec.hxx>
40 #include <LocOpe.hxx>
41 #include <LocOpe_CSIntersector.hxx>
42 #include <LocOpe_PntFace.hxx>
43 #include <LocOpe_Prism.hxx>
44 #include <Precision.hxx>
45 #include <Standard_ConstructionError.hxx>
46 #include <TColGeom_SequenceOfCurve.hxx>
47 #include <TColgp_SequenceOfPnt.hxx>
48 #include <TopExp.hxx>
49 #include <TopExp_Explorer.hxx>
50 #include <TopoDS.hxx>
51 #include <TopoDS_Compound.hxx>
52 #include <TopoDS_Edge.hxx>
53 #include <TopoDS_Face.hxx>
54 #include <TopoDS_Shape.hxx>
55 #include <TopoDS_Solid.hxx>
56 #include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
57 #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
58 #include <TopTools_ListIteratorOfListOfShape.hxx>
59 #include <TopTools_ListOfShape.hxx>
60 #include <TopTools_MapOfShape.hxx>
61
62 #ifdef OCCT_DEBUG
63 extern Standard_Boolean BRepFeat_GettraceFEAT();
64 #endif
65
66 static void MajMap(const TopoDS_Shape&, // base
67                    const LocOpe_Prism&,
68                    TopTools_DataMapOfShapeListOfShape&, // myMap
69                    TopoDS_Shape&,  // myFShape
70                    TopoDS_Shape&); // myLShape
71
72 static Standard_Boolean ToFuse(const TopoDS_Face& ,
73                                const TopoDS_Face&);
74
75 static Standard_Real HeightMax(const TopoDS_Shape& theSbase,
76                                const TopoDS_Face& theSkface,
77                                const TopoDS_Shape& theSFrom,
78                                const TopoDS_Shape& theSUntil);
79
80 static Standard_Integer SensOfPrism(const Handle(Geom_Curve) C,
81                                     const TopoDS_Shape& Until);
82
83 static Handle(Geom_Curve) TestCurve(const TopoDS_Shape&,
84                                     const gp_Vec&);
85
86
87 //=======================================================================
88 //function : Init
89 //purpose  : 
90 //=======================================================================
91
92 void BRepFeat_MakePrism::Init(const TopoDS_Shape& Sbase,
93                               const TopoDS_Shape& Pbase,
94                               const TopoDS_Face& Skface,
95                               const gp_Dir& Direc,
96                               const Standard_Integer Mode,
97                               const Standard_Boolean Modify)
98 {
99 #ifdef OCCT_DEBUG
100   Standard_Boolean trc = BRepFeat_GettraceFEAT();
101   if (trc) std::cout << "BRepFeat_MakePrism::Init" << std::endl;
102 #endif
103   mySkface = Skface;
104   SketchFaceValid();
105   mySbase  = Sbase;
106   BasisShapeValid();
107   myPbase  = Pbase;
108   mySlface.Clear();
109   myDir    = Direc;
110   if(Mode == 0) {
111     myFuse   = Standard_False;
112     myJustFeat = Standard_False;
113   }
114   else if(Mode == 1) {
115     myFuse   = Standard_True;
116     myJustFeat = Standard_False;
117   }
118   else if(Mode == 2) {
119     myFuse   = Standard_True;
120     myJustFeat = Standard_True;
121   }
122   else {    
123   }
124   myModify = Modify;
125   myJustGluer = Standard_False;
126
127
128   //-------------- ifv
129   //mySkface.Nullify();
130   //-------------- ifv
131
132
133   myShape.Nullify();
134   myNewEdges.Clear();
135   myTgtEdges.Clear();
136   myMap.Clear();
137   myFShape.Nullify();
138   myLShape.Nullify();
139   TopExp_Explorer exp;
140   for (exp.Init(mySbase,TopAbs_FACE);exp.More();exp.Next()) {
141     TopTools_ListOfShape thelist;
142     myMap.Bind(exp.Current(), thelist);
143     myMap(exp.Current()).Append(exp.Current());
144   }
145 #ifdef OCCT_DEBUG
146   if (trc) {
147     if (myJustFeat)  std::cout << " Just Feature" << std::endl;
148     if (myFuse)  std::cout << " Fuse" << std::endl;
149     if (!myFuse)  std::cout << " Cut" << std::endl;
150     if (!myModify) std::cout << " Modify = 0" << std::endl;
151   }
152 #endif 
153 }
154
155
156 //=======================================================================
157 //function : Add
158 //purpose  : add elements of sliding (edge on face)
159 //=======================================================================
160
161 void BRepFeat_MakePrism::Add(const TopoDS_Edge& E,
162                              const TopoDS_Face& F)
163 {
164 #ifdef OCCT_DEBUG
165   Standard_Boolean trc = BRepFeat_GettraceFEAT();
166   if (trc) std::cout << "BRepFeat_MakePrism::Add(Edge,face)" << std::endl;
167 #endif
168   TopExp_Explorer exp;
169   for (exp.Init(mySbase,TopAbs_FACE);exp.More();exp.Next()) {
170     if (exp.Current().IsSame(F)) {
171       break;
172     }
173   }
174   if (!exp.More()) {
175     throw Standard_ConstructionError();
176   }
177   
178   for (exp.Init(myPbase,TopAbs_EDGE);exp.More();exp.Next()) {
179     if (exp.Current().IsSame(E)) {
180       break;
181     }
182   }
183   if (!exp.More()) {
184     throw Standard_ConstructionError();
185   }
186   
187   if (!mySlface.IsBound(F)) {
188     TopTools_ListOfShape thelist1;
189     mySlface.Bind(F, thelist1);
190   }
191   TopTools_ListIteratorOfListOfShape itl(mySlface(F));
192   for (; itl.More();itl.Next()) {
193     if (itl.Value().IsSame(E)) {
194       break;
195     }
196   }
197   if (!itl.More()) {
198     mySlface(F).Append(E);
199   }
200 }
201
202
203 //=======================================================================
204 //function : Perform
205 //purpose  : construction of prism of length Length and 
206 //           call of reconstruction topo
207 //=======================================================================
208
209 void BRepFeat_MakePrism::Perform(const Standard_Real Length)
210 {
211 #ifdef OCCT_DEBUG
212   Standard_Boolean trc = BRepFeat_GettraceFEAT();
213   if (trc) std::cout << "BRepFeat_MakePrism::Perform(Length)" << std::endl;
214 #endif
215   mySFrom.Nullify();
216   ShapeFromValid();
217   mySUntil.Nullify();
218   ShapeUntilValid();
219   myGluedF.Clear();
220   myPerfSelection = BRepFeat_NoSelection;
221   PerfSelectionValid();
222   gp_Vec V(Length*myDir);
223   
224 //construction of prism of height Length
225
226   LocOpe_Prism thePrism(myPbase,V);
227   TopoDS_Shape VraiPrism = thePrism.Shape();
228   
229 // management of descendants
230   MajMap(myPbase,thePrism,myMap,myFShape,myLShape);
231   
232
233   myGShape = VraiPrism;    // the primitive
234   GeneratedShapeValid();
235   
236   TopoDS_Face FFace;
237   
238   Standard_Boolean found = Standard_False;
239
240 // try to detect the faces of gluing 
241 // in case if the top of the prism is tangent to the initial shape
242
243   if(!mySkface.IsNull() || !mySlface.IsEmpty()) {
244     if(myLShape.ShapeType() == TopAbs_WIRE) {
245       TopExp_Explorer ex1(VraiPrism, TopAbs_FACE);
246       for(; ex1.More(); ex1.Next()) {
247         TopExp_Explorer ex2(ex1.Current(), TopAbs_WIRE);
248         for(; ex2.More(); ex2.Next()) {
249           if(ex2.Current().IsSame(myLShape)) {
250             FFace = TopoDS::Face(ex1.Current());
251             found = Standard_True;
252             break;
253           }
254         }
255         if(found) break;
256       }
257     }
258     
259     TopExp_Explorer exp(mySbase, TopAbs_FACE);
260     for(; exp.More(); exp.Next()) {
261       const TopoDS_Face& ff = TopoDS::Face(exp.Current());
262       if(ToFuse(ff, FFace)) {
263         TopTools_DataMapOfShapeListOfShape sl;
264         if(!FFace.IsSame(myPbase) && BRepFeat::IsInside(ff, FFace)) 
265           break;
266       }
267     }
268   }
269
270 // management of faces of gluing given by the user
271
272   GluedFacesValid();
273
274   if(!myGluedF.IsEmpty()) {   // case gluing
275     myJustGluer = Standard_True;
276     thePrism.Curves(myCurves);
277     myBCurve = thePrism.BarycCurve();    
278     GlobalPerform();  // topological reconstruction 
279   }
280
281 // if there is no gluing  -> call of ope topo
282   if(!myJustGluer) {
283     if(myFuse == 1 && !myJustFeat) {
284       BRepAlgoAPI_Fuse f(mySbase, myGShape);
285       myShape = f.Shape();
286       UpdateDescendants(f, myShape, Standard_False);
287       Done();
288     }
289     else if(myFuse == 0) {
290       BRepAlgoAPI_Cut c(mySbase, myGShape);
291       myShape = c.Shape();
292       UpdateDescendants(c, myShape, Standard_False);
293       Done();
294     }
295     else {
296       myShape = myGShape;
297       Done();
298     }
299   }
300 }
301
302
303 //=======================================================================
304 //function : Perform
305 //purpose  : construction of prism oriented at the face Until, sufficiently 
306 //           long; call of topological reconstruction          
307 //=======================================================================
308
309 void BRepFeat_MakePrism::Perform(const TopoDS_Shape& Until)
310 {
311 #ifdef OCCT_DEBUG
312   Standard_Boolean trc = BRepFeat_GettraceFEAT();
313   if (trc) std::cout << "BRepFeat_MakePrism::Perform(Until)" << std::endl;
314 #endif
315   if (Until.IsNull()) {
316     throw Standard_ConstructionError();
317   }
318   TopExp_Explorer exp(Until, TopAbs_FACE);
319   if (!exp.More()) {
320     throw Standard_ConstructionError();
321   }
322   myGluedF.Clear();
323   myPerfSelection = BRepFeat_SelectionU;
324   PerfSelectionValid();
325   mySFrom.Nullify();
326   ShapeFromValid();
327   mySUntil = Until;
328   Standard_Boolean Trf = TransformShapeFU(1);  
329   ShapeUntilValid();
330   Handle(Geom_Curve) C = TestCurve(myPbase,myDir);  
331   Standard_Integer sens = SensOfPrism(C, mySUntil);
332   Standard_Real Height = HeightMax(mySbase, mySkface, mySFrom, mySUntil);
333   gp_Vec V(2*sens*Height*myDir);
334
335 // construction of long prism
336   LocOpe_Prism thePrism(myPbase,V);
337   TopoDS_Shape VraiPrism = thePrism.Shape();
338
339 // in case of support of face Until
340   if(!Trf) {    
341     MajMap(myPbase,thePrism,myMap,myFShape,myLShape);    
342     myGShape = VraiPrism;
343     GeneratedShapeValid();
344     GluedFacesValid();
345     thePrism.Curves(myCurves);
346     myBCurve = thePrism.BarycCurve();
347     GlobalPerform();
348   }
349   else {    // until support -> passage to topological operations
350     MajMap(myPbase,thePrism,myMap,myFShape,myLShape);    
351     TColGeom_SequenceOfCurve scur;
352     scur.Clear();    
353     scur.Append(C);
354
355 // direction of the prism depending on Until
356
357     LocOpe_CSIntersector ASI(mySUntil);
358     ASI.Perform(scur);
359     TopAbs_Orientation Or;
360     if (ASI.IsDone() && ASI.NbPoints(1) >=1) {
361       if (myFuse == 1) {
362         Or = ASI.Point(1, 1).Orientation();
363       }
364       else {
365         Or = ASI.Point(1, ASI.NbPoints(1)).Orientation();
366       }
367       if(sens==-1) Or=TopAbs::Reverse(Or);
368       TopoDS_Face FUntil = ASI.Point(1,1).Face();
369       TopoDS_Shape Comp;
370       BRep_Builder B;
371       B.MakeCompound(TopoDS::Compound(Comp));
372       TopoDS_Solid S = BRepFeat::Tool(mySUntil, FUntil, Or);
373       if (!S.IsNull()) B.Add(Comp,S);
374       BRepAlgoAPI_Cut trP(VraiPrism,Comp);
375       UpdateDescendants(trP, trP.Shape(), Standard_False);
376       //
377       TopExp_Explorer ex(trP.Shape(), TopAbs_SOLID);
378       TopoDS_Shape Cutsh = ex.Current();
379       if (myFuse == 1 && !myJustFeat) {
380         BRepAlgoAPI_Fuse f(mySbase, Cutsh);
381         myShape = f.Shape();
382         UpdateDescendants(f, myShape, Standard_False);
383         Done();
384       }
385       else if(myFuse == 0) {
386         BRepAlgoAPI_Cut c(mySbase, Cutsh);
387         myShape = c.Shape();
388         UpdateDescendants(c, myShape, Standard_False);
389         Done();
390       }
391       else {
392         myShape = Cutsh;
393         Done();
394       }
395     }
396   }
397 }
398
399 //=======================================================================
400 //function : Perform
401 //purpose  : construction of a sufficiently long and properly oriented prism
402 //           call of topological reconstruction
403 //=======================================================================
404
405 void BRepFeat_MakePrism::Perform(const TopoDS_Shape& From,
406                                  const TopoDS_Shape& Until)
407 {
408 #ifdef OCCT_DEBUG
409   Standard_Boolean trc = BRepFeat_GettraceFEAT();
410   if (trc) std::cout << "BRepFeat_MakePrism::Perform(From,Until)" << std::endl;
411 #endif
412   if (From.IsNull() || Until.IsNull()) {
413     throw Standard_ConstructionError();
414   }
415
416   if (!mySkface.IsNull()) {
417     if (From.IsSame(mySkface)) {
418       myJustGluer = Standard_True;
419       Perform(Until);
420       if (myJustGluer) return;
421     }
422     else if (Until.IsSame(mySkface)) {
423       myJustGluer = Standard_True;
424       Perform(From);
425       if (myJustGluer) return;
426     } 
427   }
428   
429   myGluedF.Clear();
430   myPerfSelection = BRepFeat_SelectionFU;
431   PerfSelectionValid();
432   
433   TopExp_Explorer exp(From, TopAbs_FACE);
434   if (!exp.More()) {
435     throw Standard_ConstructionError();
436   }
437   exp.Init(Until, TopAbs_FACE);
438   if (!exp.More()) {
439     throw Standard_ConstructionError();
440   }
441   mySFrom = From;
442   Standard_Boolean Trff = TransformShapeFU(0);
443   ShapeFromValid();
444   mySUntil = Until;
445   Standard_Boolean Trfu = TransformShapeFU(1);
446   ShapeUntilValid();  
447   if(Trfu != Trff) {
448     NotDone();
449     myStatusError = BRepFeat_IncTypes;
450     return;
451   }
452
453 // length depending on bounding boxes
454
455   Standard_Real Height = HeightMax(mySbase, mySkface, mySFrom, mySUntil);
456   Handle(Geom_Curve) C = TestCurve(myPbase,myDir);  
457   Standard_Integer sens;  // direction of prism
458   Standard_Integer tran;  // transfer of prism
459   if(From.IsSame(Until)) {
460     sens = 1;
461     tran = -1;
462   }
463   else {
464     sens = SensOfPrism(C, mySUntil);
465     tran = sens*SensOfPrism(C, mySFrom);
466   }
467   LocOpe_Prism thePrism;   
468   if(tran < 0) {
469     gp_Vec Vtra(-3*Height*sens/2.*myDir);
470     thePrism.Perform(myPbase,3*sens*Height*myDir,Vtra);
471   }
472   else {
473     thePrism.Perform(myPbase,2*sens*Height*myDir);
474   }
475   TopoDS_Shape VraiPrism = thePrism.Shape();
476   
477   if(!Trff) {
478     MajMap(myPbase,thePrism,myMap,myFShape,myLShape);
479     
480     myGShape = VraiPrism;
481     GeneratedShapeValid();
482     GluedFacesValid();
483     thePrism.Curves(myCurves);
484     myBCurve = thePrism.BarycCurve();
485     GlobalPerform();
486   }
487   else {    // case until support -> topological operation
488     MajMap(myPbase,thePrism,myMap,myFShape,myLShape);    
489     TColGeom_SequenceOfCurve scur;
490     scur.Clear();    
491     scur.Append(C);
492     LocOpe_CSIntersector ASI1(mySUntil);
493     LocOpe_CSIntersector ASI2(mySFrom);
494     ASI1.Perform(scur);
495     ASI2.Perform(scur);
496     TopAbs_Orientation OrU, OrF;
497     TopoDS_Face FFrom, FUntil;
498     Standard_Real ParF, ParU;
499     if (ASI1.IsDone() && ASI1.NbPoints(1) >=1) {
500       if (myFuse == 1) {
501               OrU = ASI1.Point(1,1).Orientation();
502       }
503       else {
504               OrU = ASI1.Point(1,ASI1.NbPoints(1)).Orientation();
505       }
506       if(sens==-1) OrU = TopAbs::Reverse(OrU);
507       FUntil = ASI1.Point(1,1).Face();
508       ParU = ASI1.Point(1,1).Parameter();
509     }
510     else {
511       NotDone();
512       myStatusError = BRepFeat_NoIntersectU;
513       return;
514     }
515     if (ASI2.IsDone() && ASI2.NbPoints(1) >=1) {
516       OrF = ASI2.Point(1,1).Orientation();
517       if(sens==1) OrF = TopAbs::Reverse(OrF);
518       FFrom = ASI2.Point(1,1).Face();
519       ParF = ASI2.Point(1,1).Parameter();
520     }
521     else {
522       NotDone();
523       myStatusError = BRepFeat_NoIntersectF;
524       return;
525     }
526     if(tran > 0 && (Abs(ParU) < Abs(ParF)))
527     {
528       TopAbs_Orientation Or;
529       Or = OrU;
530       OrU = OrF;
531       OrF = Or;
532     }
533     //
534     TopTools_ListOfShape aLTools;
535     TopoDS_Solid S = BRepFeat::Tool(mySUntil, FUntil, OrU);
536     if (!S.IsNull()) {
537       aLTools.Append(S);
538     }
539     else {
540       NotDone();
541       myStatusError = BRepFeat_NullToolU;
542       return;
543     }
544     TopoDS_Solid SS = BRepFeat::Tool(mySFrom, FFrom, OrF);
545     if (!SS.IsNull()) {
546       aLTools.Append(SS);
547     }
548     else {
549       NotDone();
550       myStatusError = BRepFeat_NullToolF;
551       return;
552     }
553     //
554     TopTools_ListOfShape aLObj;
555     aLObj.Append(VraiPrism);
556     //
557     BRepAlgoAPI_Cut trP;
558     trP.SetArguments(aLObj);
559     trP.SetTools(aLTools);
560     trP.Build();
561     UpdateDescendants(trP, trP.Shape(), Standard_False);
562     if(myFuse == 1 && !myJustFeat) {
563       BRepAlgoAPI_Fuse f(mySbase, trP.Shape());
564       myShape = f.Shape();
565       UpdateDescendants(f, myShape, Standard_False);
566       Done();
567     }
568     else if(myFuse == 0) {
569       BRepAlgoAPI_Cut c(mySbase, trP.Shape());
570       myShape = c.Shape();
571       UpdateDescendants(c, myShape, Standard_False);
572       Done();
573     }
574     else {
575       myShape = trP.Shape();
576       Done();
577     }
578   }
579 }
580
581 //=======================================================================
582 //function : PerformUntilEnd
583 //purpose  : construction of a prism and reconstruction
584 //=======================================================================
585
586 void BRepFeat_MakePrism::PerformUntilEnd()
587 {
588 #ifdef OCCT_DEBUG
589   Standard_Boolean trc = BRepFeat_GettraceFEAT();
590   if (trc) std::cout << "BRepFeat_MakePrism::PerformUntilEnd()" << std::endl;
591 #endif
592   myPerfSelection = BRepFeat_SelectionSh;
593   PerfSelectionValid();
594   myGluedF.Clear();
595   mySUntil.Nullify();
596   ShapeUntilValid();
597   mySFrom.Nullify();
598   ShapeFromValid();
599   Standard_Real Height = HeightMax(mySbase, mySkface, mySFrom, mySUntil);
600   gp_Vec V(2*Height*myDir);
601   
602   LocOpe_Prism thePrism(myPbase,V);
603   TopoDS_Shape VraiPrism = thePrism.Shape();
604   
605   MajMap(myPbase,thePrism,myMap,myFShape,myLShape);
606   
607   myGShape = VraiPrism;
608   GeneratedShapeValid();
609   GluedFacesValid();
610
611   if(myFuse == 0) {
612     BRepAlgoAPI_Cut c(mySbase, myGShape);
613     if (c.IsDone()) {
614       myShape = c.Shape();
615       UpdateDescendants(c, myShape, Standard_False);
616       Done();
617     }
618   }
619   else {
620     thePrism.Curves(myCurves);
621     myBCurve = thePrism.BarycCurve();
622     GlobalPerform();
623   }
624 }
625
626 //=======================================================================
627 //function : PerformFromEnd
628 //purpose  : 
629 //=======================================================================
630
631 void BRepFeat_MakePrism::PerformFromEnd(const TopoDS_Shape& Until)
632 {
633 #ifdef OCCT_DEBUG
634   Standard_Boolean trc = BRepFeat_GettraceFEAT();
635   if (trc) std::cout << "BRepFeat_MakePrism::PerformFromEnd(From,Until)" << std::endl;
636 #endif
637   if (Until.IsNull()) {
638     throw Standard_ConstructionError();
639   }
640   if (!mySkface.IsNull() && Until.IsSame(mySkface)) {
641     myDir.Reverse();
642     PerformUntilEnd();
643     return;
644   }
645   TopExp_Explorer exp;
646   exp.Init(Until, TopAbs_FACE);
647   if (!exp.More()) {
648     throw Standard_ConstructionError();
649   }
650   myPerfSelection = BRepFeat_SelectionShU;
651   PerfSelectionValid();
652   mySFrom.Nullify();
653   ShapeFromValid();
654   mySUntil = Until;
655   Standard_Boolean Trf = TransformShapeFU(1);
656   ShapeUntilValid();
657   Handle(Geom_Curve) C = TestCurve(myPbase,myDir);  
658   Standard_Integer sens = SensOfPrism(C, mySUntil);
659   Standard_Real Height = HeightMax(mySbase, mySkface, mySFrom, mySUntil);
660   gp_Vec Vtra(-3*Height*sens/2.*myDir);
661   gp_Vec Vect(3*sens*Height*myDir);
662   LocOpe_Prism thePrism(myPbase,Vect,Vtra);
663   TopoDS_Shape VraiPrism = thePrism.Shape();
664   
665   if(!Trf) {  // case face until 
666     MajMap(myPbase,thePrism,myMap,myFShape,myLShape);
667     myGShape = VraiPrism;
668     GeneratedShapeValid();
669     myGluedF.Clear();
670     GluedFacesValid();
671     thePrism.Curves(myCurves);
672     myBCurve = thePrism.BarycCurve();
673     GlobalPerform();
674   }
675   else {   // case support
676     MajMap(myPbase,thePrism,myMap,myFShape,myLShape);    
677     TColGeom_SequenceOfCurve scur;
678     scur.Clear();    
679     scur.Append(C);
680     LocOpe_CSIntersector ASI1(mySUntil);
681     LocOpe_CSIntersector ASI2(mySbase);
682     ASI1.Perform(scur);
683     ASI2.Perform(scur);
684     TopAbs_Orientation OrU = TopAbs_FORWARD, OrF = TopAbs_FORWARD;
685     TopoDS_Face FUntil, FFrom;
686     if (ASI1.IsDone() && ASI1.NbPoints(1) >=1) {
687       OrU = ASI1.Point(1,1).Orientation();
688       if(sens==-1) {
689         OrU = TopAbs::Reverse(OrU);
690       }
691       FUntil = ASI1.Point(1,1).Face();
692     }
693     if (ASI2.IsDone() && ASI2.NbPoints(1) >=1) {
694       OrF = ASI2.Point(1,1).Orientation();
695 //      if(sens==1) OrF = TopAbs::Reverse(OrF);
696       FFrom = ASI2.Point(1 ,1).Face();
697       Handle(Geom_Surface) S = BRep_Tool::Surface(FFrom);
698       if (S->DynamicType() == 
699           STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
700         S = Handle(Geom_RectangularTrimmedSurface)::
701           DownCast(S)->BasisSurface();
702       }
703       BRepLib_MakeFace fac(S, Precision::Confusion());
704       mySFrom = fac.Face();  
705       Trf = TransformShapeFU(0);
706       FFrom = TopoDS::Face(mySFrom);
707     }
708
709     TopTools_ListOfShape aLTools;
710     TopoDS_Solid Sol = BRepFeat::Tool(mySUntil, FUntil, OrU);
711     if (!Sol.IsNull()) {
712       aLTools.Append(Sol);
713     }
714     else {
715       NotDone();
716       myStatusError = BRepFeat_NullToolU;
717       return;
718     }
719
720     TopoDS_Solid Sol1 = BRepFeat::Tool(mySFrom, FFrom, OrF);
721     if (!Sol1.IsNull()) {
722       aLTools.Append(Sol1);
723     }
724     else {
725       NotDone();
726       myStatusError = BRepFeat_NullToolF;
727       return;
728     }
729     //
730     TopTools_ListOfShape aLObj;
731     aLObj.Append(VraiPrism);
732     //
733     BRepAlgoAPI_Cut trP;
734     trP.SetArguments(aLObj);
735     trP.SetTools(aLTools);
736     trP.Build();
737     //
738     UpdateDescendants(trP, trP.Shape(), Standard_False);
739     if(myFuse == 1 && !myJustFeat) {
740       BRepAlgoAPI_Fuse f(mySbase, trP.Shape());
741       myShape = f.Shape();
742       UpdateDescendants(f, myShape, Standard_False);
743       Done();
744     }
745     else if(myFuse == 0) {
746       BRepAlgoAPI_Cut c(mySbase, trP.Shape());
747       myShape = c.Shape();
748       UpdateDescendants(c, myShape, Standard_False);
749       Done();
750     }
751     else {
752       myShape = trP.Shape();
753       Done();
754     }
755   }
756 }
757
758 //=======================================================================
759 //function : PerformThruAll
760 //purpose  : 
761 //=======================================================================
762
763 void BRepFeat_MakePrism::PerformThruAll()
764 {
765 #ifdef OCCT_DEBUG
766   Standard_Boolean trc = BRepFeat_GettraceFEAT();
767   if (trc) std::cout << "BRepFeat_MakePrism::PerformThruAll()" << std::endl;
768 #endif
769   mySUntil.Nullify();
770   ShapeUntilValid();
771   mySFrom.Nullify();
772   ShapeFromValid();
773   if(myFuse == 0) {
774     myPerfSelection = BRepFeat_NoSelection;
775   }
776   else {
777     myPerfSelection = BRepFeat_SelectionSh;
778   }
779   PerfSelectionValid();
780   myGluedF.Clear();
781   GluedFacesValid();
782
783   Standard_Real Height = HeightMax(mySbase, mySkface, mySFrom, mySUntil);
784   gp_Vec V(3*Height*myDir);
785   gp_Vec Vtra(-3*Height/2.*myDir);
786   LocOpe_Prism thePrism(myPbase,V,Vtra);
787   TopoDS_Shape VraiPrism = thePrism.Shape();
788   MajMap(myPbase,thePrism,myMap,myFShape,myLShape);
789
790   myGShape = VraiPrism;
791   GeneratedShapeValid();  
792
793   if(myFuse == 0) {
794     BRepAlgoAPI_Cut c(mySbase, myGShape);
795     if (c.IsDone()) {
796       myShape = c.Shape();
797       UpdateDescendants(c, myShape, Standard_False);
798       Done();
799     }
800   }
801   else {
802     thePrism.Curves(myCurves);
803     myBCurve = thePrism.BarycCurve();
804     GlobalPerform();
805   }
806 }
807
808 //=======================================================================
809 //function : PerformUntilHauteur
810 //purpose  : 
811 //=======================================================================
812
813 void BRepFeat_MakePrism::PerformUntilHeight(const TopoDS_Shape& Until,
814                                             const Standard_Real Length)
815 {
816 #ifdef OCCT_DEBUG
817   Standard_Boolean trc = BRepFeat_GettraceFEAT();
818   if (trc) std::cout << "BRepFeat_MakePrism::PerformUntilHeight(Until,Length)" << std::endl;
819 #endif
820   if (Until.IsNull()) {
821     Perform(Length);
822   }
823   if(Length == 0) {
824     Perform(Until);
825   }
826   TopExp_Explorer exp(Until, TopAbs_FACE);
827   if (!exp.More()) {
828     throw Standard_ConstructionError();
829   }
830   myGluedF.Clear();
831   myPerfSelection = BRepFeat_NoSelection;
832   PerfSelectionValid();
833   mySFrom.Nullify();
834   ShapeFromValid();
835   mySUntil = Until;
836   Standard_Boolean Trf = TransformShapeFU(1);
837   ShapeUntilValid();
838   Handle(Geom_Curve) C = TestCurve(myPbase,myDir);  
839   Standard_Integer sens = SensOfPrism(C, mySUntil);
840   gp_Vec V(sens*Length*myDir);
841   LocOpe_Prism thePrism(myPbase,V);
842   TopoDS_Shape VraiPrism = thePrism.Shape();
843
844   if(!Trf) {
845     MajMap(myPbase,thePrism,myMap,myFShape,myLShape);
846     
847     myGShape = VraiPrism;
848     GeneratedShapeValid();
849     GluedFacesValid();
850     thePrism.Curves(myCurves);
851     myBCurve = thePrism.BarycCurve();
852     GlobalPerform();
853   }
854   else {
855     MajMap(myPbase,thePrism,myMap,myFShape,myLShape);    
856     TColGeom_SequenceOfCurve scur;
857     scur.Clear();    
858     scur.Append(C);
859     LocOpe_CSIntersector ASI(mySUntil);
860     ASI.Perform(scur);
861     TopAbs_Orientation Or;
862     if (ASI.IsDone() && ASI.NbPoints(1) >=1) {
863       if (myFuse == 1) {
864         Or = ASI.Point(1,1).Orientation();
865       }
866       else {
867         Or = ASI.Point(1,ASI.NbPoints(1)).Orientation();
868       }
869       if(sens==-1) Or=TopAbs::Reverse(Or);
870       TopoDS_Face FUntil = ASI.Point(1,1).Face();
871       TopoDS_Shape Comp;
872       BRep_Builder B;
873       B.MakeCompound(TopoDS::Compound(Comp));
874       TopoDS_Solid S = BRepFeat::Tool(mySUntil, FUntil, Or);
875       if (!S.IsNull()) B.Add(Comp,S);
876
877       BRepAlgoAPI_Cut trP(VraiPrism,Comp);
878       UpdateDescendants(trP, trP.Shape(), Standard_False);
879       if(myFuse == 1 && !myJustFeat) {
880         BRepAlgoAPI_Fuse f(mySbase, trP.Shape());
881         myShape = f.Shape();
882         UpdateDescendants(f, myShape, Standard_False);
883         Done();
884       }
885       else if(myFuse == 0) {
886         BRepAlgoAPI_Cut c(mySbase, trP.Shape());
887         myShape = c.Shape();
888         UpdateDescendants(c, myShape, Standard_False);
889         Done();
890       }
891       else {
892         myShape = trP.Shape();
893         Done();
894       }
895     }
896   }
897 }
898
899 //=======================================================================
900 //function : Curves
901 //purpose  : sequence of curves parallel to the axis of prism 
902 //=======================================================================
903
904 void BRepFeat_MakePrism::Curves(TColGeom_SequenceOfCurve& scur)
905 {
906   scur = myCurves;
907 }
908
909 //=======================================================================
910 //function : BarycCurve
911 //purpose  : curve parallel to the axis of the prism passing through the center  
912 //           of masses
913 //=======================================================================
914
915 Handle(Geom_Curve) BRepFeat_MakePrism::BarycCurve()
916 {
917   return myBCurve;
918 }
919
920
921 //=======================================================================
922 //function : HeightMax
923 //purpose  : Calculate the height of the prism following the parameters of
924 //           bounding box
925 //=======================================================================
926
927 static Standard_Real HeightMax(const TopoDS_Shape& theSbase,
928                                const TopoDS_Face&  theSkface,
929                                const TopoDS_Shape& theSFrom,
930                                const TopoDS_Shape& theSUntil)
931 {
932   Bnd_Box Box;
933   BRepBndLib::Add(theSbase,Box);
934   BRepBndLib::Add(theSkface,Box);
935   if(!theSFrom.IsNull()) {
936     Standard_Boolean FacRevolInfini = Standard_False;
937     TopExp_Explorer exp;
938     exp.Init(theSFrom, TopAbs_EDGE);
939     for(; exp.More(); exp.Next()) {
940       TopExp_Explorer exp1;
941       exp1.Init(exp.Current(), TopAbs_VERTEX);
942       if(!exp1.More()) {
943         FacRevolInfini = Standard_True;
944         break;
945       }
946     }
947     if(!FacRevolInfini)
948       BRepBndLib::Add(theSFrom,Box);
949   }
950   if(!theSUntil.IsNull()) 
951   {
952     Standard_Boolean FacRevolInfini = Standard_False;
953     TopExp_Explorer exp;
954     exp.Init(theSUntil, TopAbs_EDGE);
955     for(; exp.More(); exp.Next()) 
956     {
957       TopExp_Explorer exp1;
958       exp1.Init(exp.Current(), TopAbs_VERTEX);
959       if(!exp1.More()) 
960       {
961         FacRevolInfini = Standard_True;
962         break;
963       }
964     }
965     if(!FacRevolInfini)
966       BRepBndLib::Add(theSUntil,Box);
967   }
968
969   Standard_Real c[6];
970
971   Box.Get(c[0],c[2],c[4],c[1],c[3],c[5]);
972   Standard_Real parmin=c[0], parmax = c[0];
973   for(Standard_Integer i = 0 ; i < 6; i++) {
974     if(c[i] > parmax) parmax = c[i];
975     if(c[i] < parmin ) parmin = c[i];    
976   }
977 //#ifndef OCCT_DEBUG
978   Standard_Real Height = fabs(2.*(parmax - parmin));
979 //#else
980 //  Standard_Real Height = abs(2.*(parmax - parmin));
981 //#endif
982   return(Height);
983 }
984
985
986 //=======================================================================
987 //function : SensOfPrism
988 //purpose  : Direction of the prism depending on the shape Until
989 //=======================================================================
990 Standard_Integer SensOfPrism(const Handle(Geom_Curve) C,
991                              const TopoDS_Shape& Until)
992 {
993   LocOpe_CSIntersector ASI1(Until);
994   TColGeom_SequenceOfCurve scur;
995   scur.Append(C);
996   ASI1.Perform(scur);
997   Standard_Integer sens = 1;
998   if(ASI1.IsDone() && ASI1.NbPoints(1) >= 1) {
999     if(ASI1.Point(1, 1).Parameter() < 0. && 
1000        ASI1.Point(1, ASI1.NbPoints(1)).Parameter() < 0.) {
1001       sens = -1;
1002     }
1003   }
1004   else if(BRepFeat::ParametricBarycenter(Until,C) < 0) {
1005       sens = -1;
1006   }
1007   else {}
1008   return sens;
1009 }
1010
1011 //=======================================================================
1012 //function : MajMap
1013 //purpose  : management of descendants
1014 //=======================================================================
1015
1016 static void MajMap(const TopoDS_Shape& theB,
1017                    const LocOpe_Prism& theP,
1018                    TopTools_DataMapOfShapeListOfShape& theMap, // myMap
1019                    TopoDS_Shape& theFShape,  // myFShape
1020                    TopoDS_Shape& theLShape) // myLShape
1021 {
1022   TopExp_Explorer exp(theP.FirstShape(),TopAbs_WIRE);
1023   if (exp.More()) {
1024     theFShape = exp.Current();
1025     TopTools_ListOfShape thelist2;
1026     theMap.Bind(theFShape, thelist2);
1027     for (exp.Init(theP.FirstShape(),TopAbs_FACE);exp.More();exp.Next()) {
1028       theMap(theFShape).Append(exp.Current());
1029     }
1030   }
1031   
1032   exp.Init(theP.LastShape(),TopAbs_WIRE);
1033   if (exp.More()) {
1034     theLShape = exp.Current();
1035     TopTools_ListOfShape thelist3;
1036     theMap.Bind(theLShape, thelist3);
1037     for (exp.Init(theP.LastShape(),TopAbs_FACE);exp.More();exp.Next()) {
1038       theMap(theLShape).Append(exp.Current());
1039     }
1040   }
1041
1042   for (exp.Init(theB,TopAbs_EDGE); exp.More(); exp.Next()) {
1043     if (!theMap.IsBound(exp.Current())) {
1044       TopTools_ListOfShape thelist4;
1045       theMap.Bind(exp.Current(), thelist4);
1046       theMap(exp.Current()) = theP.Shapes(exp.Current());
1047     }
1048   }
1049 }
1050
1051
1052 //=======================================================================
1053 //function : MajMap
1054 //purpose  : management of descendants
1055 //=======================================================================
1056
1057 static Handle(Geom_Curve) TestCurve(const TopoDS_Shape& Base,
1058                                     const gp_Vec& V)
1059 {
1060   gp_Pnt bar(0., 0., 0.);
1061   TColgp_SequenceOfPnt spt;
1062   LocOpe::SampleEdges(Base,spt);
1063   for (Standard_Integer jj=1;jj<=spt.Length(); jj++) {
1064     const gp_Pnt& pvt = spt(jj);
1065     bar.ChangeCoord() += pvt.XYZ();
1066   }
1067   bar.ChangeCoord().Divide(spt.Length());
1068   gp_Ax1 newAx(bar,V);
1069   Handle(Geom_Line) theLin = new Geom_Line(newAx);
1070   return theLin;
1071 }
1072
1073
1074
1075
1076 //=======================================================================
1077 //function : ToFuse
1078 //purpose  : face SameDomaine or not
1079 //=======================================================================
1080
1081 static Standard_Boolean ToFuse (const TopoDS_Face& F1, const TopoDS_Face& F2)
1082 {
1083   if (F1.IsNull() || F2.IsNull()) {
1084     return Standard_False;
1085   }
1086
1087   Handle(Geom_Surface) S1,S2;
1088   TopLoc_Location loc1, loc2;
1089   Handle(Standard_Type) typS1,typS2;
1090   const Standard_Real tollin = Precision::Confusion();
1091   const Standard_Real tolang = Precision::Angular();
1092
1093   S1 = BRep_Tool::Surface(F1,loc1);
1094   S2 = BRep_Tool::Surface(F2,loc2);
1095
1096   typS1 = S1->DynamicType();
1097   typS2 = S2->DynamicType();
1098
1099   if (typS1 == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
1100     S1 =  Handle(Geom_RectangularTrimmedSurface)::DownCast (S1)->BasisSurface();
1101     typS1 = S1->DynamicType();
1102   }
1103
1104   if (typS2 == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
1105     S2 =  Handle(Geom_RectangularTrimmedSurface)::DownCast (S2)->BasisSurface();
1106     typS2 = S2->DynamicType();
1107   }
1108
1109   if (typS1 != typS2) {
1110     return Standard_False;
1111   }
1112
1113
1114   Standard_Boolean ValRet = Standard_False;
1115   if (typS1 == STANDARD_TYPE(Geom_Plane)) {
1116     gp_Pln pl1( Handle(Geom_Plane)::DownCast (S1)->Pln());
1117     gp_Pln pl2( Handle(Geom_Plane)::DownCast (S2)->Pln());
1118
1119     // apply locations
1120     if (! loc1.IsIdentity())
1121       pl1.Transform (loc1.Transformation());
1122     if (! loc2.IsIdentity())
1123       pl2.Transform (loc2.Transformation());
1124
1125     if (pl1.Position().IsCoplanar(pl2.Position(),tollin,tolang)) {
1126       ValRet = Standard_True;
1127     }
1128   }
1129
1130   return ValRet;
1131 }
1132
1133
1134
1135
1136
1137