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