0024428: Implementation of LGPL license
[occt.git] / src / BOPAlgo / BOPAlgo_Builder_4.cxx
1 // Created by: Peter KURNEV
2 // Copyright (c) 2010-2014 OPEN CASCADE SAS
3 // Copyright (c) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
4 // Copyright (c) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, CEDRAT,
5 //                         EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 //
7 // This file is part of Open CASCADE Technology software library.
8 //
9 // This library is free software; you can redistribute it and / or modify it
10 // under the terms of the GNU Lesser General Public version 2.1 as published
11 // by the Free Software Foundation, with special exception defined in the file
12 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
13 // distribution for complete text of the license and disclaimer of any warranty.
14 //
15 // Alternatively, this file may be used under the terms of Open CASCADE
16 // commercial license or contractual agreement.
17
18 #include <BOPAlgo_Builder.ixx>
19
20 #include <TopoDS_Iterator.hxx>
21
22 #include <BOPCol_ListOfShape.hxx>
23 #include <BOPCol_MapOfShape.hxx>
24
25 #include <BOPTools_AlgoTools.hxx>
26 #include <BOPTools.hxx>
27
28 //=======================================================================
29 //function : Generated
30 //purpose  : 
31 //=======================================================================
32   const TopTools_ListOfShape& BOPAlgo_Builder::Generated(const TopoDS_Shape& theS)
33 {
34   Standard_Boolean bHasImage, bToReverse;
35   TopAbs_ShapeEnum aType;
36   BOPCol_ListIteratorOfListOfShape aIt;
37   //
38   myHistShapes.Clear();
39   //
40   if (theS.IsNull()) {
41     return myHistShapes;
42   }
43   //
44   bHasImage=myImages.IsBound(theS);
45   if (!bHasImage) {
46     return myHistShapes;
47   }
48   //
49   aType=theS.ShapeType();
50   //
51   if (!(aType==TopAbs_EDGE   || aType==TopAbs_FACE || 
52       aType==TopAbs_VERTEX || aType==TopAbs_SOLID)) {
53     return myHistShapes;
54   } 
55   //
56   //PrepareHistory();
57   //
58   const BOPCol_ListOfShape& aLSp=myImages.Find(theS);
59   aIt.Initialize(aLSp);
60   for (; aIt.More(); aIt.Next()) {
61     const TopoDS_Shape& aSp=aIt.Value();
62     if (myShapesSD.IsBound(aSp)) {
63       if (myMapShape.Contains(aSp)) {
64         TopoDS_Shape aSpR=myShapesSD.Find(aSp);
65         //
66         if (aType==TopAbs_VERTEX || aType==TopAbs_SOLID) {
67           aSpR.Orientation(theS.Orientation());
68         }
69         else {
70           bToReverse=BOPTools_AlgoTools::IsSplitToReverse(aSpR, theS, myContext);
71           if (bToReverse) {
72             aSpR.Reverse();
73           }
74         }
75         //
76           myHistShapes.Append(aSpR);
77       }
78     }
79   }
80   //
81   return myHistShapes;
82 }
83 //=======================================================================
84 //function : Modified
85 //purpose  : 
86 //=======================================================================
87   const TopTools_ListOfShape& BOPAlgo_Builder::Modified(const TopoDS_Shape& theS)
88 {
89   Standard_Boolean bHasImage, bToReverse;
90   TopAbs_ShapeEnum aType;
91   BOPCol_ListIteratorOfListOfShape aIt;
92   //
93   myHistShapes.Clear();
94   //
95   if (theS.IsNull()) {
96     return myHistShapes;
97   }
98   //
99   bHasImage=myImages.IsBound(theS);
100   if (!bHasImage) {
101     return myHistShapes;
102   }
103   //
104   aType=theS.ShapeType();
105   //
106   if (!(aType==TopAbs_EDGE   || aType==TopAbs_FACE || 
107       aType==TopAbs_VERTEX || aType==TopAbs_SOLID)) {
108     return myHistShapes;
109   } 
110   //
111   //PrepareHistory();
112   //
113   const BOPCol_ListOfShape& aLSp=myImages.Find(theS);
114   aIt.Initialize(aLSp);
115   for (; aIt.More(); aIt.Next()) {
116     TopoDS_Shape aSp=aIt.Value();
117     if (!myShapesSD.IsBound(aSp)) {
118       if (myMapShape.Contains(aSp)) {
119         //
120         if (aType==TopAbs_VERTEX || aType==TopAbs_SOLID) {
121           aSp.Orientation(theS.Orientation());
122         }
123         else {
124           bToReverse=BOPTools_AlgoTools::IsSplitToReverse(aSp, theS, myContext);
125           if (bToReverse) {
126             aSp.Reverse();
127           }
128         }
129         //
130         myHistShapes.Append(aSp);
131       }
132     }
133   }
134   //
135   return myHistShapes;
136 }
137 //=======================================================================
138 //function : IsDeleted
139 //purpose  : 
140 //=======================================================================
141   Standard_Boolean BOPAlgo_Builder::IsDeleted(const TopoDS_Shape& theS)
142 {
143   Standard_Boolean bRet, bHasImage, bContains;
144   TopAbs_ShapeEnum aType;
145   BOPCol_ListIteratorOfListOfShape aIt;
146   //
147   bRet=Standard_False;
148   //
149   if (theS.IsNull()) {
150     return !bRet; //true
151   }
152   //
153   aType=theS.ShapeType();
154   if (!(aType==TopAbs_EDGE || aType==TopAbs_FACE || 
155       aType==TopAbs_VERTEX || aType==TopAbs_SOLID)) {
156     return !bRet;
157   }
158   //
159   bHasImage=myImages.IsBound(theS);
160   if (!bHasImage) {
161     return !bRet; //true
162   }
163   //
164   //PrepareHistory();
165   //
166   bContains=myMapShape.Contains(theS);
167   if (bContains) {
168     return bRet; //false
169   }
170   //
171   const BOPCol_ListOfShape& aLSp=myImages.Find(theS);
172   aIt.Initialize(aLSp);
173   for (; aIt.More(); aIt.Next()) {
174     TopoDS_Shape aSp=aIt.Value();
175     //
176     if (!myShapesSD.IsBound(aSp)) {
177       if (myMapShape.Contains(aSp)) {
178         return bRet; //false
179       }
180     }
181     else {
182       TopoDS_Shape aSpR=myShapesSD.Find(aSp);
183       if (myMapShape.Contains(aSpR)) {
184         return bRet; //false
185       }
186     }
187   }
188   return !bRet; // true
189 }
190 //=======================================================================
191 //function : PrepareHistory
192 //purpose  : 
193 //=======================================================================
194   void BOPAlgo_Builder::PrepareHistory()
195 {
196   if (!myFlagHistory) {
197     return;
198   }
199   //
200   if(myShape.IsNull()) {
201     return;
202   }
203   //
204   Standard_Boolean bHasImage, bContainsSD;
205   TopAbs_ShapeEnum aType;
206   BOPCol_MapOfShape aMS;
207   BOPCol_ListIteratorOfListOfShape aIt;
208   BOPCol_MapIteratorOfMapOfShape aItM;
209   //
210   // 1. Clearing 
211   BOPAlgo_BuilderShape::PrepareHistory();
212   //
213   // 2. myMapShape - all shapes of result with theirs sub-shapes 
214   BOPTools::MapShapes(myShape, myMapShape);
215   //
216   // 3. MS - all argument shapes with theirs sub-shapes
217   aIt.Initialize(myArguments);
218   for (; aIt.More(); aIt.Next()) {
219     const TopoDS_Shape& aSx=aIt.Value();
220     BOPTools::MapShapes(aSx, aMS);
221   }
222   //
223   // 4. Treatment
224   aItM.Initialize(aMS);
225   for (; aItM.More(); aItM.Next()) {
226     const TopoDS_Shape& aSx=aItM.Key();
227     aType=aSx.ShapeType();
228     //
229     // 4.1 .myImagesResult
230     bHasImage=myImages.IsBound(aSx); 
231     //
232     BOPCol_ListOfShape aLSx;
233     if (!bHasImage) {
234       if (myMapShape.Contains(aSx)) {
235         aLSx.Append(aSx);
236         myImagesResult.Add(aSx, aLSx);
237       }
238     }
239     else {
240       const BOPCol_ListOfShape& aLSp=myImages.Find(aSx);
241       aIt.Initialize(aLSp);
242       for (; aIt.More(); aIt.Next()) {
243         const TopoDS_Shape& aSp=aIt.Value();
244         if (myMapShape.Contains(aSp)) {
245           aLSx.Append(aSp);
246         }
247       }
248       myImagesResult.Add(aSx, aLSx);
249     }
250     // <- A
251     //
252     // 4.2 As it was 
253     if (!myHasDeleted) {
254       myHasDeleted=IsDeleted(aSx);
255     }
256     //
257     if (!myHasGenerated || !myHasModified) {
258       if (aType==TopAbs_EDGE   || aType==TopAbs_FACE || 
259           aType==TopAbs_VERTEX || aType==TopAbs_SOLID) {
260         if (bHasImage) {
261           const BOPCol_ListOfShape& aLSp=myImages.Find(aSx);
262           aIt.Initialize(aLSp);
263           for (; aIt.More(); aIt.Next()) {
264             const TopoDS_Shape& aSp=aIt.Value();
265             //
266             if (myMapShape.Contains(aSp)) {
267               bContainsSD=myShapesSD.IsBound(aSp);
268               //
269               if (!myHasGenerated) {
270                 if (bContainsSD) {
271                   myHasGenerated=Standard_True;
272                 }
273               }
274               if (!myHasModified) {
275                 if (!bContainsSD) {
276                   myHasModified=Standard_True;
277                 }
278               }
279             } // if (myMapShape.Contains(aSp))
280           }
281         }
282       } 
283     }
284   }
285   myFlagHistory=Standard_True;
286 }
287
288 // <- A
289     /*
290     BOPCol_ListOfShape aLSx;
291     if (!bHasImage) {
292       if (myMapShape.Contains(aSx)) {
293         aLSx.Append(aSx);
294         myImagesResult.Add(aSx, aLSx);
295       }
296     }
297     else {
298       const BOPCol_ListOfShape& aLSp=myImages.Find(aSx);
299       aIt.Initialize(aLSp);
300       for (; aIt.More(); aIt.Next()) {
301         const TopoDS_Shape& aSp=aIt.Value();
302         if (myMapShape.Contains(aSp)) {
303           aLSx.Append(aSp);
304         }
305       }
306       myImagesResult.Add(aSx, aLSx);
307     }
308     */