0021762: Integration of new Boolean Operation algorithm to OCCT.
[occt.git] / src / BOPAlgo / BOPAlgo_Builder_4.cxx
1 // Created by: Peter KURNEV
2 // Copyright (c) 2010-2012 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 // The content of this file is subject to the Open CASCADE Technology Public
8 // License Version 6.5 (the "License"). You may not use the content of this file
9 // except in compliance with the License. Please obtain a copy of the License
10 // at http://www.opencascade.org and read it completely before using this file.
11 //
12 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
13 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
14 //
15 // The Original Code and all software distributed under the License is
16 // distributed on an "AS IS" basis, without warranty of any kind, and the
17 // Initial Developer hereby disclaims all such warranties, including without
18 // limitation, any warranties of merchantability, fitness for a particular
19 // purpose or non-infringement. Please see the License for the specific terms
20 // and conditions governing the rights and limitations under the License.
21
22
23 #include <BOPAlgo_Builder.ixx>
24
25 #include <TopoDS_Iterator.hxx>
26
27 #include <BOPCol_ListOfShape.hxx>
28 #include <BOPCol_MapOfShape.hxx>
29
30 #include <BOPTools_AlgoTools.hxx>
31 #include <BOPTools.hxx>
32
33 //=======================================================================
34 //function : Generated
35 //purpose  : 
36 //=======================================================================
37   const TopTools_ListOfShape& BOPAlgo_Builder::Generated(const TopoDS_Shape& theS)
38 {
39   Standard_Boolean bHasImage, bToReverse;
40   TopAbs_ShapeEnum aType;
41   BOPCol_ListIteratorOfListOfShape aIt;
42   //
43   myHistShapes.Clear();
44   //
45   if (theS.IsNull()) {
46     return myHistShapes;
47   }
48   //
49   bHasImage=myImages.IsBound(theS);
50   if (!bHasImage) {
51     return myHistShapes;
52   }
53   //
54   aType=theS.ShapeType();
55   //
56   if (!(aType==TopAbs_EDGE   || aType==TopAbs_FACE || 
57       aType==TopAbs_VERTEX || aType==TopAbs_SOLID)) {
58     return myHistShapes;
59   } 
60   //
61   //PrepareHistory();
62   //
63   const BOPCol_ListOfShape& aLSp=myImages.Find(theS);
64   aIt.Initialize(aLSp);
65   for (; aIt.More(); aIt.Next()) {
66     const TopoDS_Shape& aSp=aIt.Value();
67     if (myShapesSD.IsBound(aSp)) {
68       if (myMapShape.Contains(aSp)) {
69         TopoDS_Shape aSpR=myShapesSD.Find(aSp);
70         //
71         if (aType==TopAbs_VERTEX || aType==TopAbs_SOLID) {
72           aSpR.Orientation(theS.Orientation());
73         }
74         else {
75           bToReverse=BOPTools_AlgoTools::IsSplitToReverse(aSpR, theS, myContext);
76           if (bToReverse) {
77             aSpR.Reverse();
78           }
79         }
80         //
81           myHistShapes.Append(aSpR);
82       }
83     }
84   }
85   //
86   return myHistShapes;
87 }
88 //=======================================================================
89 //function : Modified
90 //purpose  : 
91 //=======================================================================
92   const TopTools_ListOfShape& BOPAlgo_Builder::Modified(const TopoDS_Shape& theS)
93 {
94   Standard_Boolean bHasImage, bToReverse;
95   TopAbs_ShapeEnum aType;
96   BOPCol_ListIteratorOfListOfShape aIt;
97   //
98   myHistShapes.Clear();
99   //
100   if (theS.IsNull()) {
101     return myHistShapes;
102   }
103   //
104   bHasImage=myImages.IsBound(theS);
105   if (!bHasImage) {
106     return myHistShapes;
107   }
108   //
109   aType=theS.ShapeType();
110   //
111   if (!(aType==TopAbs_EDGE   || aType==TopAbs_FACE || 
112       aType==TopAbs_VERTEX || aType==TopAbs_SOLID)) {
113     return myHistShapes;
114   } 
115   //
116   //PrepareHistory();
117   //
118   const BOPCol_ListOfShape& aLSp=myImages.Find(theS);
119   aIt.Initialize(aLSp);
120   for (; aIt.More(); aIt.Next()) {
121     TopoDS_Shape aSp=aIt.Value();
122     if (!myShapesSD.IsBound(aSp)) {
123       if (myMapShape.Contains(aSp)) {
124         //
125         if (aType==TopAbs_VERTEX || aType==TopAbs_SOLID) {
126           aSp.Orientation(theS.Orientation());
127         }
128         else {
129           bToReverse=BOPTools_AlgoTools::IsSplitToReverse(aSp, theS, myContext);
130           if (bToReverse) {
131             aSp.Reverse();
132           }
133         }
134         //
135         myHistShapes.Append(aSp);
136       }
137     }
138   }
139   //
140   return myHistShapes;
141 }
142 //=======================================================================
143 //function : IsDeleted
144 //purpose  : 
145 //=======================================================================
146   Standard_Boolean BOPAlgo_Builder::IsDeleted(const TopoDS_Shape& theS)
147 {
148   Standard_Boolean bRet, bHasImage, bContains;
149   TopAbs_ShapeEnum aType;
150   BOPCol_ListIteratorOfListOfShape aIt;
151   //
152   bRet=Standard_False;
153   //
154   if (theS.IsNull()) {
155     return !bRet; //true
156   }
157   //
158   aType=theS.ShapeType();
159   if (!(aType==TopAbs_EDGE || aType==TopAbs_FACE || 
160       aType==TopAbs_VERTEX || aType==TopAbs_SOLID)) {
161     return !bRet;
162   }
163   //
164   bHasImage=myImages.IsBound(theS);
165   if (!bHasImage) {
166     return !bRet; //true
167   }
168   //
169   //PrepareHistory();
170   //
171   bContains=myMapShape.Contains(theS);
172   if (bContains) {
173     return bRet; //false
174   }
175   //
176   const BOPCol_ListOfShape& aLSp=myImages.Find(theS);
177   aIt.Initialize(aLSp);
178   for (; aIt.More(); aIt.Next()) {
179     TopoDS_Shape aSp=aIt.Value();
180     //
181     if (!myShapesSD.IsBound(aSp)) {
182       if (myMapShape.Contains(aSp)) {
183         return bRet; //false
184       }
185     }
186     else {
187       TopoDS_Shape aSpR=myShapesSD.Find(aSp);
188       if (myMapShape.Contains(aSpR)) {
189         return bRet; //false
190       }
191     }
192   }
193   return !bRet; // true
194 }
195 //=======================================================================
196 //function : PrepareHistory
197 //purpose  : 
198 //=======================================================================
199   void BOPAlgo_Builder::PrepareHistory()
200 {
201   if (!myFlagHistory) {
202     return;
203   }
204   //
205   if(myShape.IsNull()) {
206     return;
207   }
208   //
209   Standard_Boolean bHasImage, bContainsSD;
210   TopAbs_ShapeEnum aType;
211   BOPCol_MapOfShape aMS;
212   BOPCol_ListIteratorOfListOfShape aIt;
213   BOPCol_MapIteratorOfMapOfShape aItM;
214   //
215   // 1. Clearing 
216   BOPAlgo_BuilderShape::PrepareHistory();
217   //
218   // 2. myMapShape - all shapes of result with theirs sub-shapes 
219   BOPTools::MapShapes(myShape, myMapShape);
220   //
221   // 3. MS - all argument shapes with theirs sub-shapes
222   aIt.Initialize(myArguments);
223   for (; aIt.More(); aIt.Next()) {
224     const TopoDS_Shape& aSx=aIt.Value();
225     BOPTools::MapShapes(aSx, aMS);
226   }
227   //
228   // 4. Treatment
229   aItM.Initialize(aMS);
230   for (; aItM.More(); aItM.Next()) {
231     const TopoDS_Shape& aSx=aItM.Key();
232     aType=aSx.ShapeType();
233     //
234     // 4.1 .myImagesResult
235     bHasImage=myImages.IsBound(aSx); 
236     //
237     BOPCol_ListOfShape aLSx;
238     if (!bHasImage) {
239       if (myMapShape.Contains(aSx)) {
240         aLSx.Append(aSx);
241         myImagesResult.Add(aSx, aLSx);
242       }
243     }
244     else {
245       const BOPCol_ListOfShape& aLSp=myImages.Find(aSx);
246       aIt.Initialize(aLSp);
247       for (; aIt.More(); aIt.Next()) {
248         const TopoDS_Shape& aSp=aIt.Value();
249         if (myMapShape.Contains(aSp)) {
250           aLSx.Append(aSp);
251         }
252       }
253       myImagesResult.Add(aSx, aLSx);
254     }
255     // <- A
256     //
257     // 4.2 As it was 
258     if (!myHasDeleted) {
259       myHasDeleted=IsDeleted(aSx);
260     }
261     //
262     if (!myHasGenerated || !myHasModified) {
263       if (aType==TopAbs_EDGE   || aType==TopAbs_FACE || 
264           aType==TopAbs_VERTEX || aType==TopAbs_SOLID) {
265         if (bHasImage) {
266           const BOPCol_ListOfShape& aLSp=myImages.Find(aSx);
267           aIt.Initialize(aLSp);
268           for (; aIt.More(); aIt.Next()) {
269             const TopoDS_Shape& aSp=aIt.Value();
270             //
271             if (myMapShape.Contains(aSp)) {
272               bContainsSD=myShapesSD.IsBound(aSp);
273               //
274               if (!myHasGenerated) {
275                 if (bContainsSD) {
276                   myHasGenerated=Standard_True;
277                 }
278               }
279               if (!myHasModified) {
280                 if (!bContainsSD) {
281                   myHasModified=Standard_True;
282                 }
283               }
284             } // if (myMapShape.Contains(aSp))
285           }
286         }
287       } 
288     }
289   }
290   myFlagHistory=Standard_True;
291 }
292
293 // <- A
294     /*
295     BOPCol_ListOfShape aLSx;
296     if (!bHasImage) {
297       if (myMapShape.Contains(aSx)) {
298         aLSx.Append(aSx);
299         myImagesResult.Add(aSx, aLSx);
300       }
301     }
302     else {
303       const BOPCol_ListOfShape& aLSp=myImages.Find(aSx);
304       aIt.Initialize(aLSp);
305       for (; aIt.More(); aIt.Next()) {
306         const TopoDS_Shape& aSp=aIt.Value();
307         if (myMapShape.Contains(aSp)) {
308           aLSx.Append(aSp);
309         }
310       }
311       myImagesResult.Add(aSx, aLSx);
312     }
313     */