0023024: Update headers of OCCT files
[occt.git] / src / BOP / BOP_BlockBuilder.cxx
CommitLineData
b311480e 1// Created on: 1993-03-11
2// Created by: Jean Yves LEBEY
3// Copyright (c) 1993-1999 Matra Datavision
4// Copyright (c) 1999-2012 OPEN CASCADE SAS
5//
6// The content of this file is subject to the Open CASCADE Technology Public
7// License Version 6.5 (the "License"). You may not use the content of this file
8// except in compliance with the License. Please obtain a copy of the License
9// at http://www.opencascade.org and read it completely before using this file.
10//
11// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
12// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
13//
14// The Original Code and all software distributed under the License is
15// distributed on an "AS IS" basis, without warranty of any kind, and the
16// Initial Developer hereby disclaims all such warranties, including without
17// limitation, any warranties of merchantability, fitness for a particular
18// purpose or non-infringement. Please see the License for the specific terms
19// and conditions governing the rights and limitations under the License.
20
7fd59977 21
22#include <BOP_BlockBuilder.ixx>
23
24#include <Standard_Failure.hxx>
25
26//=======================================================================
27//function : BOP_BlockBuilder::BOP_BlockBuilder
28//purpose :
29//=======================================================================
b311480e 30BOP_BlockBuilder::BOP_BlockBuilder()
7fd59977 31:
32 myIsDone(Standard_False)
33{
34}
35
36//=======================================================================
37//function : BOP_BlockBuilder::BOP_BlockBuilder
38//purpose :
39//=======================================================================
40 BOP_BlockBuilder::BOP_BlockBuilder (BOP_ShapeSet& SS)
41 :myIsDone(Standard_False)
42{
43 MakeBlock(SS);
44}
45
46//=======================================================================
47//function : MakeBlock
48//purpose :
49//=======================================================================
50 void BOP_BlockBuilder::MakeBlock(BOP_ShapeSet& SS)
51{
52 // Compute the set of connexity blocks of elements of element set SS
53 //
54 // Logic :
55 // - A block is a set of connex elements of SS
56 // - We assume that any element of SS appears in only 1 connexity block.
57 //
58 // Implementation :
59 // - All the elements of all the blocks are stored in map myOrientedShapeMap(M).
60 // - A connexity block is a segment [f,l] of element indices of M.
61 // - myBlocks is a sequence of integer; each integer is the index of the
62 // first element (in M) of a connexity block.
63 // - Bounds [f,l] of a connexity block are :
64 // f = myBlocks(i)
65 // l = myBlocks(i+1) - 1
66
67 myOrientedShapeMap.Clear();
68 myOrientedShapeMapIsValid.Clear();
69 myBlocks.Clear();
70 myBlocksIsRegular.Clear();
71 //
72 Standard_Boolean IsRegular, CurNei, Mextent, Eindex,
73 EnewinM, searchneighbours, condregu;
74 Standard_Integer iiregu;
75 //
76 //
77 SS.InitStartElements();
78 for (; SS.MoreStartElements(); SS.NextStartElement()) {
79 const TopoDS_Shape& E = SS.StartElement();
80 Mextent = myOrientedShapeMap.Extent();
81 Eindex = AddElement(E);
82
83 // E = current element of the element set SS
84 // Mextent = index of last element stored in map M, before E is added.
85 // Eindex = index of E added to M : Eindex > Mextent => E is new in M
86
87 EnewinM = (Eindex > Mextent);
88 if (EnewinM) {
89 //
90 // make a new block starting at element Eindex
91 myBlocks.Append(Eindex);
92 IsRegular = Standard_True; CurNei = 0;
93 // put in current block all the elements connex to E :
94 // while an element E has been added to M
95 // - compute neighbours of E : N(E)
96 // - add each element N of N(E) to M
97
98 Mextent = myOrientedShapeMap.Extent();
99 searchneighbours = (Eindex <= Mextent);
100 while (searchneighbours) {
101
102 // E = element of M on which neighbours must be searched
103 // first step : Eindex = index of starting element of SS
104 // next steps : Eindex = index of neighbours of starting element of SS
105 const TopoDS_Shape& anE = myOrientedShapeMap(Eindex);
106 CurNei = SS.MaxNumberSubShape(anE);
107
108 condregu = (CurNei > 2) ? Standard_False : Standard_True;
109
110 IsRegular = IsRegular && condregu;
111 //
112 // compute neighbours of E : add them to M to increase M.Extent().
113 SS.InitNeighbours(anE);
114
115 for (; SS.MoreNeighbours(); SS.NextNeighbour()) {
116 const TopoDS_Shape& N = SS.Neighbour();
117 AddElement(N);
118 }
119
120 Eindex++;
121 Mextent = myOrientedShapeMap.Extent();
122 searchneighbours = (Eindex <= Mextent);
123
124 } // while (searchneighbours)
125
126 iiregu = IsRegular ? 1 : 0;
127 myBlocksIsRegular.Append(iiregu);
128 } // if (EnewinM)
129 } // for ()
130 //
131 // To value the l bound of the last connexity block created above,
132 // we create an artificial block of value = myOrientedShapeMap.Extent() + 1
133 // The real number of connexity blocks is myBlocks.Length() - 1
134 Mextent = myOrientedShapeMap.Extent();
135 myBlocks.Append(Mextent + 1);
136
137 myIsDone = Standard_True;
138}
139
140//=======================================================================
141//function : InitBlock
142//purpose :
143//=======================================================================
144 void BOP_BlockBuilder::InitBlock()
145{
146 myBlockIndex = 1;
147}
148
149//=======================================================================
150//function : MoreBlock
151//purpose :
152//=======================================================================
153 Standard_Boolean BOP_BlockBuilder::MoreBlock() const
154{
155 // the length of myBlocks is 1 + number of connexity blocks
156 Standard_Integer l = myBlocks.Length();
157 Standard_Boolean b = (myBlockIndex < l);
158 return b;
159}
160
161//=======================================================================
162//function : NextBlock
163//purpose :
164//=======================================================================
165 void BOP_BlockBuilder::NextBlock()
166{
167 myBlockIndex++;
168}
169
170//=======================================================================
171//function : BlockIterator
172//purpose :
173//=======================================================================
174 BOP_BlockIterator BOP_BlockBuilder::BlockIterator() const
175{
176 Standard_Integer lower, upper;
177
178 lower = myBlocks(myBlockIndex);
179 upper = myBlocks(myBlockIndex+1)-1;
180
181 return BOP_BlockIterator(lower,upper);
182}
183
184//=======================================================================
185//function : Element
186//purpose :
187//=======================================================================
188 const TopoDS_Shape& BOP_BlockBuilder::Element (const BOP_BlockIterator& BI) const
189{
190 Standard_Boolean isbound = BI.More();
191 if (!isbound) {
192 Standard_Failure::Raise("OutOfRange");
193 }
194
195 Standard_Integer index = BI.Value();
196 const TopoDS_Shape& E = myOrientedShapeMap(index);
197 return E;
198}
199//=======================================================================
200//function : Element
201//purpose :
202//=======================================================================
203 const TopoDS_Shape& BOP_BlockBuilder::Element (const Standard_Integer index) const
204{
205 Standard_Boolean isbound = myOrientedShapeMapIsValid.IsBound(index);
206 if (!isbound) {
207 Standard_Failure::Raise("OutOfRange");
208 }
209 const TopoDS_Shape& E = myOrientedShapeMap(index);
210 return E;
211}
212//=======================================================================
213//function : Element
214//purpose :
215//=======================================================================
216 Standard_Integer BOP_BlockBuilder::Element (const TopoDS_Shape& E) const
217{
218 Standard_Boolean isbound = myOrientedShapeMap.Contains(E);
219 if (!isbound) {
220 Standard_Failure::Raise("OutOfRange");
221 }
222
223 Standard_Integer I = myOrientedShapeMap.FindIndex(E);
224 return I;
225}
226
227//=======================================================================
228//function : ElementIsValid
229//purpose :
230//=======================================================================
231 Standard_Boolean BOP_BlockBuilder::ElementIsValid (const BOP_BlockIterator& BI) const
232{
233 Standard_Boolean isvalid, isbound = BI.More();
234 if (!isbound) {
235 return Standard_False;
236 }
237 Standard_Integer Sindex, isb;
238
239 Sindex = BI.Value();
240 isb = myOrientedShapeMapIsValid.Find(Sindex);
241 isvalid = (isb == 1)? Standard_True: Standard_False;
242
243 return isvalid;
244}
245//=======================================================================
246//function : ElementIsValid
247//purpose :
248//=======================================================================
249 Standard_Boolean BOP_BlockBuilder::ElementIsValid (const Standard_Integer Sindex) const
250{
251 Standard_Boolean isvalid, isbound = myOrientedShapeMapIsValid.IsBound(Sindex);
252 if (!isbound) return Standard_False;
253
254 Standard_Integer isb = myOrientedShapeMapIsValid.Find(Sindex);
255 isvalid = (isb == 1)? Standard_True: Standard_False;
256
257 return isvalid;
258}
259
260//=======================================================================
261//function : AddElement
262//purpose :
263//=======================================================================
264 Standard_Integer BOP_BlockBuilder::AddElement(const TopoDS_Shape& S)
265{
266 Standard_Integer Sindex = myOrientedShapeMap.Add(S);
267 myOrientedShapeMapIsValid.Bind(Sindex, 1);
268
269 return Sindex;
270}
271
272//=======================================================================
273//function : SetValid
274//purpose :
275//=======================================================================
276 void BOP_BlockBuilder::SetValid(const BOP_BlockIterator& BI,
277 const Standard_Boolean isvalid)
278{
279 Standard_Boolean isbound = BI.More();
280 if (!isbound) {
281 return;
282 }
283 Standard_Integer Sindex, i;
284 Sindex = BI.Value();
285 i = (isvalid) ? 1 : 0;
286 myOrientedShapeMapIsValid.Bind(Sindex,i);
287}
288//=======================================================================
289//function : SetValid
290//purpose :
291//=======================================================================
292 void BOP_BlockBuilder::SetValid(const Standard_Integer Sindex,
293 const Standard_Boolean isvalid)
294{
295 Standard_Boolean isbound = myOrientedShapeMapIsValid.IsBound(Sindex);
296 if (!isbound) {
297 return;
298 }
299
300 Standard_Integer i = (isvalid) ? 1 : 0;
301 myOrientedShapeMapIsValid.Bind(Sindex,i);
302}
303
304//=======================================================================
305//function : CurrentBlockIsRegular
306//purpose :
307//=======================================================================
308 Standard_Boolean BOP_BlockBuilder::CurrentBlockIsRegular()
309{
310 Standard_Boolean b = Standard_False;
311 Standard_Integer i = myBlocksIsRegular.Value(myBlockIndex);
312
313 if(i == 1) {
314 b = Standard_True;
315 }
316 return b;
317}
318
319