0024002: Overall code and build procedure refactoring -- automatic
[occt.git] / src / BOPAlgo / BOPAlgo_Tools.cxx
1 // Created by: Peter KURNEV
2 // Copyright (c) 1999-2014 OPEN CASCADE SAS
3 //
4 // This file is part of Open CASCADE Technology software library.
5 //
6 // This library is free software; you can redistribute it and/or modify it under
7 // the terms of the GNU Lesser General Public License version 2.1 as published
8 // by the Free Software Foundation, with special exception defined in the file
9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10 // distribution for complete text of the license and disclaimer of any warranty.
11 //
12 // Alternatively, this file may be used under the terms of Open CASCADE
13 // commercial license or contractual agreement.
14
15
16 #include <BOPAlgo_Tools.hxx>
17 #include <BOPCol_IndexedMapOfInteger.hxx>
18 #include <BOPDS_CommonBlock.hxx>
19 #include <BOPDS_DataMapOfPaveBlockListOfPaveBlock.hxx>
20 #include <BOPDS_DS.hxx>
21 #include <BOPDS_IndexedMapOfPaveBlock.hxx>
22 #include <BOPDS_MapOfPaveBlock.hxx>
23 #include <BOPDS_PaveBlock.hxx>
24
25 //=======================================================================
26 //function : MakeBlocksCnx
27 //purpose  : 
28 //=======================================================================
29   void BOPAlgo_Tools::MakeBlocksCnx(const BOPCol_IndexedDataMapOfIntegerListOfInteger& aMILI,
30                                     BOPCol_DataMapOfIntegerListOfInteger& aMBlocks,
31                                     Handle(NCollection_BaseAllocator)& aAllocator)
32 {
33   Standard_Integer aNbV, nV, aNbVS, nVP, nVx, aNbVP, aNbEC, k, i, j;
34   BOPCol_ListIteratorOfListOfInteger aItLI;
35   //
36   BOPCol_MapOfInteger aMVS(100, aAllocator);
37   BOPCol_IndexedMapOfInteger aMEC(100, aAllocator);
38   BOPCol_IndexedMapOfInteger aMVP(100, aAllocator);
39   BOPCol_IndexedMapOfInteger aMVAdd(100, aAllocator);
40   //
41   aNbV=aMILI.Extent();
42   //
43   for (k=0,i=1; i<=aNbV; ++i) {
44     aNbVS=aMVS.Extent();
45     if (aNbVS==aNbV) {
46       break;
47     }
48     //
49     nV = aMILI.FindKey(i);
50     if (aMVS.Contains(nV)){
51       continue;
52     }
53     aMVS.Add(nV);
54     //
55     aMEC.Clear();
56     aMVP.Clear();
57     aMVAdd.Clear();
58     //
59     aMVP.Add(nV);
60     for(;;) {
61       aNbVP=aMVP.Extent();
62       for (j=1; j<=aNbVP; ++j) {
63         nVP=aMVP(j);
64         const BOPCol_ListOfInteger& aLV=aMILI.FindFromKey(nVP);
65         aItLI.Initialize(aLV);
66         for (; aItLI.More(); aItLI.Next()) {
67           nVx=aItLI.Value();
68           if (aMEC.Contains(nVx)) {
69             continue;
70           }
71           //
72           aMVS.Add(nVx);
73           aMEC.Add(nVx);
74           aMVAdd.Add(nVx);
75         }
76       }
77       //
78       aNbVP=aMVAdd.Extent();
79       if (!aNbVP) {
80         break; // from while(1)
81       }
82       //
83       aMVP.Clear();
84       for (j=1; j<=aNbVP; ++j) {
85         aMVP.Add(aMVAdd(j));
86       }
87       aMVAdd.Clear();
88     }//while(1) {
89     //
90     BOPCol_ListOfInteger aLIx(aAllocator);
91     //
92     aNbEC = aMEC.Extent();
93     for (j=1; j<=aNbEC; ++j) {
94       nVx=aMEC(j);
95       aLIx.Append(nVx);
96     }
97     //
98     aMBlocks.Bind(k, aLIx);
99     ++k;
100   }//for (k=0,i=1; i<=aNbV; ++i)
101   aMVAdd.Clear();
102   aMVP.Clear();
103   aMEC.Clear();
104   aMVS.Clear();
105 }
106 //=======================================================================
107 //function : FillMap
108 //purpose  : 
109 //=======================================================================
110   void BOPAlgo_Tools::FillMap(const Standard_Integer n1,
111                               const Standard_Integer n2,
112                               BOPCol_IndexedDataMapOfIntegerListOfInteger& aMILI,
113                               Handle(NCollection_BaseAllocator)& aAllocator)
114 {
115   if (aMILI.Contains(n1)) {
116     BOPCol_ListOfInteger& aLI=aMILI.ChangeFromKey(n1);
117     aLI.Append(n2);
118   }
119   else {
120     BOPCol_ListOfInteger aLI(aAllocator);
121     aLI.Append(n2);
122     aMILI.Add(n1, aLI);
123   }
124   if (aMILI.Contains(n2)) {
125     BOPCol_ListOfInteger& aLI=aMILI.ChangeFromKey(n2);
126     aLI.Append(n1);
127   }
128   else {
129     BOPCol_ListOfInteger aLI(aAllocator);
130     aLI.Append(n1);
131     aMILI.Add(n2, aLI);
132   }
133 }
134 //=======================================================================
135 //function : FillMap
136 //purpose  : 
137 //=======================================================================
138   void BOPAlgo_Tools::FillMap(const Handle(BOPDS_PaveBlock)& aPB1,
139                               const Handle(BOPDS_PaveBlock)& aPB2,
140                               BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock& aMPBLPB,
141                               Handle(NCollection_BaseAllocator)& aAllocator)
142 {
143   if (aMPBLPB.Contains(aPB1)) {
144     BOPDS_ListOfPaveBlock& aLPB=aMPBLPB.ChangeFromKey(aPB1);
145     aLPB.Append(aPB2);
146   }
147   else {
148     BOPDS_ListOfPaveBlock aLPB(aAllocator);
149     aLPB.Append(aPB2);
150     aMPBLPB.Add(aPB1, aLPB);
151   }
152   if (aMPBLPB.Contains(aPB2)) {
153     BOPDS_ListOfPaveBlock& aLPB=aMPBLPB.ChangeFromKey(aPB2);
154     aLPB.Append(aPB1);
155   }
156   else {
157     BOPDS_ListOfPaveBlock aLPB(aAllocator);
158     aLPB.Append(aPB1);
159     aMPBLPB.Add(aPB2, aLPB);
160   }
161 }
162 //=======================================================================
163 //function : FillMap
164 //purpose  : 
165 //=======================================================================
166   void BOPAlgo_Tools::FillMap(const Handle(BOPDS_PaveBlock)& aPB,
167                               const Standard_Integer nF,
168                               BOPDS_IndexedDataMapOfPaveBlockListOfInteger& aMPBLI,
169                               Handle(NCollection_BaseAllocator)& aAllocator)
170 {
171   if (aMPBLI.Contains(aPB)) {
172     BOPCol_ListOfInteger& aLI=aMPBLI.ChangeFromKey(aPB);
173     aLI.Append(nF);
174   }
175   else {
176     BOPCol_ListOfInteger aLI(aAllocator);
177     aLI.Append(nF);
178     aMPBLI.Add(aPB, aLI);
179   }
180 }
181 //=======================================================================
182 //function : MakeBlocks
183 //purpose  : 
184 //=======================================================================
185   void BOPAlgo_Tools::MakeBlocks(const BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock& aMILI,
186                                  BOPDS_DataMapOfIntegerListOfPaveBlock& aMBlocks,
187                                  Handle(NCollection_BaseAllocator)& aAllocator)
188 {
189   Standard_Integer aNbV,  aNbVS, aNbVP, aNbEC, k, i, j;
190   BOPDS_ListIteratorOfListOfPaveBlock aItLI;
191   //
192   BOPDS_MapOfPaveBlock aMVS(100, aAllocator);
193   BOPDS_IndexedMapOfPaveBlock aMEC(100, aAllocator);
194   BOPDS_IndexedMapOfPaveBlock aMVP(100, aAllocator);
195   BOPDS_IndexedMapOfPaveBlock aMVAdd(100, aAllocator);
196   //
197   aNbV=aMILI.Extent();
198   //
199   for (k=0, i=1; i<=aNbV; ++i) {
200     aNbVS=aMVS.Extent();
201     if (aNbVS==aNbV) {
202       break;
203     }
204     //
205     const Handle(BOPDS_PaveBlock)& nV=aMILI.FindKey(i);
206     if (aMVS.Contains(nV)){
207       continue;
208     }
209     aMVS.Add(nV);
210     //
211     aMEC.Clear();
212     aMVP.Clear();
213     aMVAdd.Clear();
214     //
215     aMVP.Add(nV);
216     for(;;) {
217       aNbVP=aMVP.Extent();
218       for (j=1; j<=aNbVP; ++j) {
219         const Handle(BOPDS_PaveBlock)& nVP=aMVP(j);
220         const BOPDS_ListOfPaveBlock& aLV=aMILI.FindFromKey(nVP);
221         aItLI.Initialize(aLV);
222         for (; aItLI.More(); aItLI.Next()) {
223           const Handle(BOPDS_PaveBlock)& nVx=aItLI.Value();
224           if (aMEC.Contains(nVx)) {
225             continue;
226           }
227           //
228           aMVS.Add(nVx);
229           aMEC.Add(nVx);
230           aMVAdd.Add(nVx);
231         }
232       }
233       //
234       aNbVP=aMVAdd.Extent();
235       if (!aNbVP) {
236         break; // from while(1)
237       }
238       //
239       aMVP.Clear();
240       for (j=1; j<=aNbVP; ++j) {
241         aMVP.Add(aMVAdd(j));
242       }
243       aMVAdd.Clear();
244     }//while(1) {
245     //
246     BOPDS_ListOfPaveBlock aLIx(aAllocator);
247     //
248     aNbEC = aMEC.Extent();
249     for (j=1; j<=aNbEC; ++j) {
250       const Handle(BOPDS_PaveBlock)& nVx=aMEC(j);
251       aLIx.Append(nVx);
252     }
253     //
254     aMBlocks.Bind(k, aLIx);
255     ++k;
256   }//for (k=0, i=1; i<=aNbV; ++i)
257   aMVAdd.Clear();
258   aMVP.Clear();
259   aMEC.Clear();
260   aMVS.Clear();
261 }
262 //=======================================================================
263 //function : PerformCommonBlocks
264 //purpose  : 
265 //=======================================================================
266   void BOPAlgo_Tools::PerformCommonBlocks(BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock& aMPBLPB,
267                                           Handle(NCollection_BaseAllocator)& aAllocator,
268                                           BOPDS_PDS& pDS)
269 {
270   Standard_Integer aNbCB;
271   //
272   aNbCB=aMPBLPB.Extent();
273   if (!aNbCB) {
274     return;
275   }
276   //
277   Standard_Integer aNbPB, aNbBlocks, k;
278   BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
279   Handle(BOPDS_CommonBlock) aCB;
280   BOPDS_DataMapOfIntegerListOfPaveBlock aMBlocks(100, aAllocator);
281   //
282   BOPAlgo_Tools::MakeBlocks(aMPBLPB, aMBlocks, aAllocator);
283   //
284   aNbBlocks = aMBlocks.Extent();
285   for (k=0; k<aNbBlocks; ++k) {
286     const BOPDS_ListOfPaveBlock& aLPB=aMBlocks.Find(k);
287     aNbPB=aLPB.Extent();
288     if (aNbPB>1) {
289       aCB=new BOPDS_CommonBlock;
290       //
291       aItLPB.Initialize(aLPB);
292       for (; aItLPB.More(); aItLPB.Next()) {
293         const Handle(BOPDS_PaveBlock)& aPBx=aItLPB.Value();
294         aCB->AddPaveBlock(aPBx);
295       }
296       //
297       aItLPB.Initialize(aLPB);
298       for (; aItLPB.More(); aItLPB.Next()) {
299         const Handle(BOPDS_PaveBlock)& aPBx=aItLPB.Value();
300         pDS->SetCommonBlock(aPBx, aCB);
301       }
302     }//if (aNbPB>1) {
303   }
304 }
305 //=======================================================================
306 //function : PerformCommonBlocks
307 //purpose  : 
308 //=======================================================================
309   void BOPAlgo_Tools::PerformCommonBlocks(const BOPDS_IndexedDataMapOfPaveBlockListOfInteger& aMPBLI,
310                                           Handle(NCollection_BaseAllocator)& ,//aAllocator
311                                           BOPDS_PDS& pDS)
312 {
313   Standard_Integer nF, i, aNb;
314   BOPCol_ListIteratorOfListOfInteger aItLI;
315   Handle(BOPDS_PaveBlock) aPB;
316   Handle(BOPDS_CommonBlock) aCB;
317   //
318   aNb=aMPBLI.Extent();
319   for (i=1; i<=aNb; ++i) {
320     aPB=aMPBLI.FindKey(i);
321     if (pDS->IsCommonBlock(aPB)) {
322       aCB=pDS->CommonBlock(aPB);
323     }
324     else {
325       aCB=new BOPDS_CommonBlock;
326       aCB->AddPaveBlock(aPB);
327     }
328     //
329     const BOPCol_ListOfInteger& aLI=aMPBLI.FindFromKey(aPB);
330     aItLI.Initialize(aLI);
331     for (; aItLI.More(); aItLI.Next()) {
332       nF=aItLI.Value();
333       aCB->AddFace(nF);
334     }
335     pDS->SetCommonBlock(aPB, aCB);
336   }
337 }