| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // G4ClippablePolygon implementation << 26 //
>> 27 // $Id: G4ClippablePolygon.cc,v 1.12 2007/05/11 13:54:28 gcosmo Exp $
>> 28 // GEANT4 tag $Name: geant4-09-00-patch-01 $
>> 29 //
>> 30 //
>> 31 // --------------------------------------------------------------------
>> 32 // GEANT 4 class source file
>> 33 //
>> 34 //
>> 35 // G4ClippablePolygon.cc
27 // 36 //
28 // Includes code from G4VSolid (P.Kent, V.Gric 37 // Includes code from G4VSolid (P.Kent, V.Grichine, J.Allison)
>> 38 //
29 // ------------------------------------------- 39 // --------------------------------------------------------------------
30 40
31 #include "G4ClippablePolygon.hh" 41 #include "G4ClippablePolygon.hh"
32 42
33 #include "G4VoxelLimits.hh" 43 #include "G4VoxelLimits.hh"
34 #include "G4GeometryTolerance.hh" 44 #include "G4GeometryTolerance.hh"
35 45
>> 46 //
36 // Constructor 47 // Constructor
37 // 48 //
38 G4ClippablePolygon::G4ClippablePolygon() 49 G4ClippablePolygon::G4ClippablePolygon()
39 : normal(0.,0.,0.) 50 : normal(0.,0.,0.)
40 { 51 {
41 kCarTolerance = G4GeometryTolerance::GetInst 52 kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
42 } 53 }
43 54
>> 55
>> 56 //
44 // Destructor 57 // Destructor
45 // 58 //
46 G4ClippablePolygon::~G4ClippablePolygon() = de << 59 G4ClippablePolygon::~G4ClippablePolygon()
>> 60 {
>> 61 }
47 62
>> 63
>> 64 //
48 // AddVertexInOrder 65 // AddVertexInOrder
49 // 66 //
50 void G4ClippablePolygon::AddVertexInOrder( con 67 void G4ClippablePolygon::AddVertexInOrder( const G4ThreeVector vertex )
51 { 68 {
52 vertices.push_back( vertex ); 69 vertices.push_back( vertex );
53 } 70 }
54 71
>> 72
>> 73 //
55 // ClearAllVertices 74 // ClearAllVertices
56 // 75 //
57 void G4ClippablePolygon::ClearAllVertices() 76 void G4ClippablePolygon::ClearAllVertices()
58 { 77 {
59 vertices.clear(); 78 vertices.clear();
60 } 79 }
61 80
>> 81
>> 82 //
62 // Clip 83 // Clip
63 // 84 //
64 G4bool G4ClippablePolygon::Clip( const G4Voxel << 85 G4bool G4ClippablePolygon::Clip( const G4VoxelLimits &voxelLimit )
65 { 86 {
66 if (voxelLimit.IsLimited()) << 87 if (voxelLimit.IsLimited()) {
67 { <<
68 ClipAlongOneAxis( voxelLimit, kXAxis ); 88 ClipAlongOneAxis( voxelLimit, kXAxis );
69 ClipAlongOneAxis( voxelLimit, kYAxis ); 89 ClipAlongOneAxis( voxelLimit, kYAxis );
70 ClipAlongOneAxis( voxelLimit, kZAxis ); 90 ClipAlongOneAxis( voxelLimit, kZAxis );
71 } 91 }
72 92
73 return (!vertices.empty()); << 93 return (vertices.size() > 0);
74 } 94 }
75 95
>> 96
>> 97 //
76 // PartialClip 98 // PartialClip
77 // 99 //
78 // Clip, while ignoring the indicated axis 100 // Clip, while ignoring the indicated axis
79 // 101 //
80 G4bool G4ClippablePolygon::PartialClip( const << 102 G4bool G4ClippablePolygon::PartialClip( const G4VoxelLimits &voxelLimit,
81 const 103 const EAxis IgnoreMe )
82 { 104 {
83 if (voxelLimit.IsLimited()) << 105 if (voxelLimit.IsLimited()) {
84 { <<
85 if (IgnoreMe != kXAxis) ClipAlongOneAxis( 106 if (IgnoreMe != kXAxis) ClipAlongOneAxis( voxelLimit, kXAxis );
86 if (IgnoreMe != kYAxis) ClipAlongOneAxis( 107 if (IgnoreMe != kYAxis) ClipAlongOneAxis( voxelLimit, kYAxis );
87 if (IgnoreMe != kZAxis) ClipAlongOneAxis( 108 if (IgnoreMe != kZAxis) ClipAlongOneAxis( voxelLimit, kZAxis );
88 } 109 }
89 110
90 return (!vertices.empty()); << 111 return (vertices.size() > 0);
91 } 112 }
92 113
>> 114
>> 115 //
93 // GetExtent 116 // GetExtent
94 // 117 //
95 G4bool G4ClippablePolygon::GetExtent( const EA 118 G4bool G4ClippablePolygon::GetExtent( const EAxis axis,
96 G4 << 119 G4double &min,
97 G4 << 120 G4double &max ) const
98 { 121 {
99 // 122 //
100 // Okay, how many entries do we have? 123 // Okay, how many entries do we have?
101 // 124 //
102 std::size_t noLeft = vertices.size(); << 125 G4int noLeft = vertices.size();
103 126
104 // 127 //
105 // Return false if nothing is left 128 // Return false if nothing is left
106 // 129 //
107 if (noLeft == 0) return false; 130 if (noLeft == 0) return false;
108 131
109 // 132 //
110 // Initialize min and max to our first verte 133 // Initialize min and max to our first vertex
111 // 134 //
112 min = max = vertices[0].operator()( axis ); 135 min = max = vertices[0].operator()( axis );
113 136
114 // 137 //
115 // Compare to the rest 138 // Compare to the rest
116 // 139 //
117 for( std::size_t i=1; i<noLeft; ++i ) << 140 G4int i;
>> 141 for( i=1; i<noLeft; i++ )
118 { 142 {
119 G4double component = vertices[i].operator( 143 G4double component = vertices[i].operator()( axis );
120 if (component < min ) 144 if (component < min )
121 min = component; 145 min = component;
122 else if (component > max ) 146 else if (component > max )
123 max = component; 147 max = component;
124 } 148 }
125 149
126 return true; 150 return true;
127 } 151 }
128 152
>> 153
>> 154 //
129 // GetMinPoint 155 // GetMinPoint
130 // 156 //
131 // Returns pointer to minimum point along the 157 // Returns pointer to minimum point along the specified axis.
132 // Take care! Do not use pointer after destroy 158 // Take care! Do not use pointer after destroying parent polygon.
133 // 159 //
134 const G4ThreeVector* G4ClippablePolygon::GetMi << 160 const G4ThreeVector *G4ClippablePolygon::GetMinPoint( const EAxis axis ) const
135 { 161 {
136 std::size_t noLeft = vertices.size(); << 162 G4int noLeft = vertices.size();
137 if (noLeft==0) 163 if (noLeft==0)
138 { <<
139 G4Exception("G4ClippablePolygon::GetMinPoi 164 G4Exception("G4ClippablePolygon::GetMinPoint()",
140 "GeomSolids0002", FatalExcepti << 165 "InvalidSetup", FatalException, "Empty polygon.");
141 } << 166
142 <<
143 const G4ThreeVector *answer = &(vertices[0]) 167 const G4ThreeVector *answer = &(vertices[0]);
144 G4double min = answer->operator()(axis); 168 G4double min = answer->operator()(axis);
145 169
146 for( std::size_t i=1; i<noLeft; ++i ) << 170 G4int i;
>> 171 for( i=1; i<noLeft; i++ )
147 { 172 {
148 G4double component = vertices[i].operator( 173 G4double component = vertices[i].operator()( axis );
149 if (component < min) 174 if (component < min)
150 { 175 {
151 answer = &(vertices[i]); 176 answer = &(vertices[i]);
152 min = component; 177 min = component;
153 } 178 }
154 } 179 }
155 180
156 return answer; 181 return answer;
157 } 182 }
158 183
>> 184
>> 185 //
159 // GetMaxPoint 186 // GetMaxPoint
160 // 187 //
161 // Returns pointer to maximum point along the 188 // Returns pointer to maximum point along the specified axis.
162 // Take care! Do not use pointer after destroy 189 // Take care! Do not use pointer after destroying parent polygon.
163 // 190 //
164 const G4ThreeVector* G4ClippablePolygon::GetMa << 191 const G4ThreeVector *G4ClippablePolygon::GetMaxPoint( const EAxis axis ) const
165 { 192 {
166 std::size_t noLeft = vertices.size(); << 193 G4int noLeft = vertices.size();
167 if (noLeft==0) 194 if (noLeft==0)
168 { <<
169 G4Exception("G4ClippablePolygon::GetMaxPoi 195 G4Exception("G4ClippablePolygon::GetMaxPoint()",
170 "GeomSolids0002", FatalExcepti << 196 "InvalidSetup", FatalException, "Empty polygon.");
171 } << 197
172 <<
173 const G4ThreeVector *answer = &(vertices[0]) 198 const G4ThreeVector *answer = &(vertices[0]);
174 G4double max = answer->operator()(axis); 199 G4double max = answer->operator()(axis);
175 200
176 for( std::size_t i=1; i<noLeft; ++i ) << 201 G4int i;
>> 202 for( i=1; i<noLeft; i++ )
177 { 203 {
178 G4double component = vertices[i].operator( 204 G4double component = vertices[i].operator()( axis );
179 if (component > max) 205 if (component > max)
180 { 206 {
181 answer = &(vertices[i]); 207 answer = &(vertices[i]);
182 max = component; 208 max = component;
183 } 209 }
184 } 210 }
185 211
186 return answer; 212 return answer;
187 } 213 }
>> 214
188 215
>> 216 //
189 // InFrontOf 217 // InFrontOf
190 // 218 //
191 // Decide if this polygon is in "front" of ano 219 // Decide if this polygon is in "front" of another when
192 // viewed along the specified axis. For our pu 220 // viewed along the specified axis. For our purposes here,
193 // it is sufficient to use the minimum extent 221 // it is sufficient to use the minimum extent of the
194 // polygon along the axis to determine this. 222 // polygon along the axis to determine this.
195 // 223 //
196 // In case the minima of the two polygons are 224 // In case the minima of the two polygons are equal,
197 // we use a more sophisticated test. 225 // we use a more sophisticated test.
198 // 226 //
199 // Note that it is possible for the two follow 227 // Note that it is possible for the two following
200 // statements to both return true or both retu 228 // statements to both return true or both return false:
201 // polygon1.InFrontOf(polygon2) 229 // polygon1.InFrontOf(polygon2)
202 // polygon2.BehindOf(polygon1) 230 // polygon2.BehindOf(polygon1)
203 // 231 //
204 G4bool G4ClippablePolygon::InFrontOf( const G4 << 232 G4bool G4ClippablePolygon::InFrontOf( const G4ClippablePolygon &other,
205 EA 233 EAxis axis ) const
206 { 234 {
207 // 235 //
208 // If things are empty, do something semi-se 236 // If things are empty, do something semi-sensible
209 // 237 //
210 std::size_t noLeft = vertices.size(); << 238 G4int noLeft = vertices.size();
211 if (noLeft==0) return false; 239 if (noLeft==0) return false;
212 240
213 if (other.Empty()) return true; 241 if (other.Empty()) return true;
214 242
215 // 243 //
216 // Get minimum of other polygon 244 // Get minimum of other polygon
217 // 245 //
218 const G4ThreeVector *minPointOther = other.G 246 const G4ThreeVector *minPointOther = other.GetMinPoint( axis );
219 const G4double minOther = minPointOther->ope 247 const G4double minOther = minPointOther->operator()(axis);
220 248
221 // 249 //
222 // Get minimum of this polygon 250 // Get minimum of this polygon
223 // 251 //
224 const G4ThreeVector *minPoint = GetMinPoint( 252 const G4ThreeVector *minPoint = GetMinPoint( axis );
225 const G4double min = minPoint->operator()(ax 253 const G4double min = minPoint->operator()(axis);
226 254
227 // 255 //
228 // Easy decision 256 // Easy decision
229 // 257 //
230 if (min < minOther-kCarTolerance) return tru 258 if (min < minOther-kCarTolerance) return true; // Clear winner
231 259
232 if (minOther < min-kCarTolerance) return fal 260 if (minOther < min-kCarTolerance) return false; // Clear loser
233 261
234 // 262 //
235 // We have a tie (this will not be all that 263 // We have a tie (this will not be all that rare since our
236 // polygons are connected) 264 // polygons are connected)
237 // 265 //
238 // Check to see if there is a vertex in the 266 // Check to see if there is a vertex in the other polygon
239 // that is behind this one (or vice versa) 267 // that is behind this one (or vice versa)
240 // 268 //
241 G4bool answer; 269 G4bool answer;
242 G4ThreeVector normalOther = other.GetNormal( 270 G4ThreeVector normalOther = other.GetNormal();
243 271
244 if (std::fabs(normalOther(axis)) > std::fabs 272 if (std::fabs(normalOther(axis)) > std::fabs(normal(axis)))
245 { 273 {
246 G4double minP, maxP; 274 G4double minP, maxP;
247 GetPlanerExtent( *minPointOther, normalOth 275 GetPlanerExtent( *minPointOther, normalOther, minP, maxP );
248 276
249 answer = (normalOther(axis) > 0) ? (minP < 277 answer = (normalOther(axis) > 0) ? (minP < -kCarTolerance)
250 : (maxP > 278 : (maxP > +kCarTolerance);
251 } 279 }
252 else 280 else
253 { 281 {
254 G4double minP, maxP; 282 G4double minP, maxP;
255 other.GetPlanerExtent( *minPoint, normal, 283 other.GetPlanerExtent( *minPoint, normal, minP, maxP );
256 284
257 answer = (normal(axis) > 0) ? (maxP > +kCa 285 answer = (normal(axis) > 0) ? (maxP > +kCarTolerance)
258 : (minP < -kCa 286 : (minP < -kCarTolerance);
259 } 287 }
260 return answer; 288 return answer;
261 } 289 }
262 290
>> 291 //
263 // BehindOf 292 // BehindOf
264 // 293 //
265 // Decide if this polygon is behind another. 294 // Decide if this polygon is behind another.
266 // See notes in method "InFrontOf" 295 // See notes in method "InFrontOf"
267 // 296 //
268 G4bool G4ClippablePolygon::BehindOf( const G4C << 297 G4bool G4ClippablePolygon::BehindOf( const G4ClippablePolygon &other,
269 EAx 298 EAxis axis ) const
270 { 299 {
271 // 300 //
272 // If things are empty, do something semi-se 301 // If things are empty, do something semi-sensible
273 // 302 //
274 std::size_t noLeft = vertices.size(); << 303 G4int noLeft = vertices.size();
275 if (noLeft==0) return false; 304 if (noLeft==0) return false;
276 305
277 if (other.Empty()) return true; 306 if (other.Empty()) return true;
278 307
279 // 308 //
280 // Get minimum of other polygon 309 // Get minimum of other polygon
281 // 310 //
282 const G4ThreeVector *maxPointOther = other.G 311 const G4ThreeVector *maxPointOther = other.GetMaxPoint( axis );
283 const G4double maxOther = maxPointOther->ope 312 const G4double maxOther = maxPointOther->operator()(axis);
284 313
285 // 314 //
286 // Get minimum of this polygon 315 // Get minimum of this polygon
287 // 316 //
288 const G4ThreeVector *maxPoint = GetMaxPoint( 317 const G4ThreeVector *maxPoint = GetMaxPoint( axis );
289 const G4double max = maxPoint->operator()(ax 318 const G4double max = maxPoint->operator()(axis);
290 319
291 // 320 //
292 // Easy decision 321 // Easy decision
293 // 322 //
294 if (max > maxOther+kCarTolerance) return tru 323 if (max > maxOther+kCarTolerance) return true; // Clear winner
295 324
296 if (maxOther > max+kCarTolerance) return fal 325 if (maxOther > max+kCarTolerance) return false; // Clear loser
297 326
298 // 327 //
299 // We have a tie (this will not be all that 328 // We have a tie (this will not be all that rare since our
300 // polygons are connected) 329 // polygons are connected)
301 // 330 //
302 // Check to see if there is a vertex in the 331 // Check to see if there is a vertex in the other polygon
303 // that is in front of this one (or vice ver 332 // that is in front of this one (or vice versa)
304 // 333 //
305 G4bool answer; 334 G4bool answer;
306 G4ThreeVector normalOther = other.GetNormal( 335 G4ThreeVector normalOther = other.GetNormal();
307 336
308 if (std::fabs(normalOther(axis)) > std::fabs 337 if (std::fabs(normalOther(axis)) > std::fabs(normal(axis)))
309 { 338 {
310 G4double minP, maxP; 339 G4double minP, maxP;
311 GetPlanerExtent( *maxPointOther, normalOth 340 GetPlanerExtent( *maxPointOther, normalOther, minP, maxP );
312 341
313 answer = (normalOther(axis) > 0) ? (maxP > 342 answer = (normalOther(axis) > 0) ? (maxP > +kCarTolerance)
314 : (minP < 343 : (minP < -kCarTolerance);
315 } 344 }
316 else 345 else
317 { 346 {
318 G4double minP, maxP; 347 G4double minP, maxP;
319 other.GetPlanerExtent( *maxPoint, normal, 348 other.GetPlanerExtent( *maxPoint, normal, minP, maxP );
320 349
321 answer = (normal(axis) > 0) ? (minP < -kCa 350 answer = (normal(axis) > 0) ? (minP < -kCarTolerance)
322 : (maxP > +kCa 351 : (maxP > +kCarTolerance);
323 } 352 }
324 return answer; 353 return answer;
325 } 354 }
326 355
>> 356
>> 357 //
327 // GetPlanerExtent 358 // GetPlanerExtent
328 // 359 //
329 // Get min/max distance in or out of a plane 360 // Get min/max distance in or out of a plane
330 // 361 //
331 G4bool G4ClippablePolygon::GetPlanerExtent( co << 362 G4bool G4ClippablePolygon::GetPlanerExtent( const G4ThreeVector &pointOnPlane,
332 co << 363 const G4ThreeVector &planeNormal,
333 << 364 G4double &min,
334 << 365 G4double &max ) const
335 { 366 {
336 // 367 //
337 // Okay, how many entries do we have? 368 // Okay, how many entries do we have?
338 // 369 //
339 std::size_t noLeft = vertices.size(); << 370 G4int noLeft = vertices.size();
340 371
341 // 372 //
342 // Return false if nothing is left 373 // Return false if nothing is left
343 // 374 //
344 if (noLeft == 0) return false; 375 if (noLeft == 0) return false;
345 376
346 // 377 //
347 // Initialize min and max to our first verte 378 // Initialize min and max to our first vertex
348 // 379 //
349 min = max = planeNormal.dot(vertices[0]-poin 380 min = max = planeNormal.dot(vertices[0]-pointOnPlane);
350 381
351 // 382 //
352 // Compare to the rest 383 // Compare to the rest
353 // 384 //
354 for( std::size_t i=1; i<noLeft; ++i ) << 385 G4int i;
>> 386 for( i=1; i<noLeft; i++ )
355 { 387 {
356 G4double component = planeNormal.dot(verti 388 G4double component = planeNormal.dot(vertices[i] - pointOnPlane);
357 if (component < min ) 389 if (component < min )
358 min = component; 390 min = component;
359 else if (component > max ) 391 else if (component > max )
360 max = component; 392 max = component;
361 } 393 }
362 394
363 return true; 395 return true;
364 } 396 }
365 397
366 // ClipAlongOneAxis << 398
367 // 399 //
368 // Clip along just one axis, as specified in v 400 // Clip along just one axis, as specified in voxelLimit
369 // 401 //
370 void G4ClippablePolygon::ClipAlongOneAxis( con << 402 void G4ClippablePolygon::ClipAlongOneAxis( const G4VoxelLimits &voxelLimit,
371 con 403 const EAxis axis )
372 { 404 {
373 if (!voxelLimit.IsLimited(axis)) return; 405 if (!voxelLimit.IsLimited(axis)) return;
374 406
375 G4ThreeVectorList tempPolygon; 407 G4ThreeVectorList tempPolygon;
376 408
377 // 409 //
378 // Build a "simple" voxelLimit that includes 410 // Build a "simple" voxelLimit that includes only the min extent
379 // and apply this to our vertices, producing 411 // and apply this to our vertices, producing result in tempPolygon
380 // 412 //
381 G4VoxelLimits simpleLimit1; 413 G4VoxelLimits simpleLimit1;
382 simpleLimit1.AddLimit( axis, voxelLimit.GetM 414 simpleLimit1.AddLimit( axis, voxelLimit.GetMinExtent(axis), kInfinity );
383 ClipToSimpleLimits( vertices, tempPolygon, s 415 ClipToSimpleLimits( vertices, tempPolygon, simpleLimit1 );
384 416
385 // 417 //
386 // If nothing is left from the above clip, w 418 // If nothing is left from the above clip, we might as well return now
387 // (but with an empty vertices) 419 // (but with an empty vertices)
388 // 420 //
389 if (tempPolygon.empty()) << 421 if (tempPolygon.size() == 0)
390 { 422 {
391 vertices.clear(); 423 vertices.clear();
392 return; 424 return;
393 } 425 }
394 426
395 // 427 //
396 // Now do the same, but using a "simple" lim 428 // Now do the same, but using a "simple" limit that includes only the max
397 // extent. Apply this to out tempPolygon, pr 429 // extent. Apply this to out tempPolygon, producing result in vertices.
398 // 430 //
399 G4VoxelLimits simpleLimit2; 431 G4VoxelLimits simpleLimit2;
400 simpleLimit2.AddLimit( axis, -kInfinity, vox 432 simpleLimit2.AddLimit( axis, -kInfinity, voxelLimit.GetMaxExtent(axis) );
401 ClipToSimpleLimits( tempPolygon, vertices, s 433 ClipToSimpleLimits( tempPolygon, vertices, simpleLimit2 );
402 434
403 // 435 //
404 // If nothing is left, return now 436 // If nothing is left, return now
405 // 437 //
406 if (vertices.empty()) return; << 438 if (vertices.size() == 0) return;
407 } 439 }
408 440
409 // ClipToSimpleLimits << 441
410 // 442 //
411 // pVoxelLimits must be only limited along one 443 // pVoxelLimits must be only limited along one axis, and either the maximum
412 // along the axis must be +kInfinity, or the m 444 // along the axis must be +kInfinity, or the minimum -kInfinity
413 // 445 //
414 void G4ClippablePolygon::ClipToSimpleLimits( G 446 void G4ClippablePolygon::ClipToSimpleLimits( G4ThreeVectorList& pPolygon,
415 G 447 G4ThreeVectorList& outputPolygon,
416 const G 448 const G4VoxelLimits& pVoxelLimit )
417 { 449 {
418 std::size_t noVertices = pPolygon.size(); << 450 G4int i;
>> 451 G4int noVertices=pPolygon.size();
419 G4ThreeVector vEnd,vStart; 452 G4ThreeVector vEnd,vStart;
420 453
421 outputPolygon.clear(); 454 outputPolygon.clear();
422 455
423 for (std::size_t i=0; i<noVertices; ++i) << 456 for (i=0;i<noVertices;i++)
424 { 457 {
425 vStart=pPolygon[i]; 458 vStart=pPolygon[i];
426 if (i==noVertices-1) 459 if (i==noVertices-1)
427 { 460 {
428 vEnd=pPolygon[0]; 461 vEnd=pPolygon[0];
429 } 462 }
430 else 463 else
431 { 464 {
432 vEnd=pPolygon[i+1]; 465 vEnd=pPolygon[i+1];
433 } 466 }
434 467
435 if (pVoxelLimit.Inside(vStart)) 468 if (pVoxelLimit.Inside(vStart))
436 { 469 {
437 if (pVoxelLimit.Inside(vEnd)) 470 if (pVoxelLimit.Inside(vEnd))
438 { 471 {
439 // vStart and vEnd inside -> output en 472 // vStart and vEnd inside -> output end point
440 // 473 //
441 outputPolygon.push_back(vEnd); 474 outputPolygon.push_back(vEnd);
442 } 475 }
443 else 476 else
444 { 477 {
445 // vStart inside, vEnd outside -> outp 478 // vStart inside, vEnd outside -> output crossing point
446 // 479 //
447 pVoxelLimit.ClipToLimits(vStart,vEnd); 480 pVoxelLimit.ClipToLimits(vStart,vEnd);
448 outputPolygon.push_back(vEnd); 481 outputPolygon.push_back(vEnd);
449 } 482 }
450 } 483 }
451 else 484 else
452 { 485 {
453 if (pVoxelLimit.Inside(vEnd)) 486 if (pVoxelLimit.Inside(vEnd))
454 { 487 {
455 // vStart outside, vEnd inside -> outp 488 // vStart outside, vEnd inside -> output inside section
456 // 489 //
457 pVoxelLimit.ClipToLimits(vStart,vEnd); 490 pVoxelLimit.ClipToLimits(vStart,vEnd);
458 outputPolygon.push_back(vStart); 491 outputPolygon.push_back(vStart);
459 outputPolygon.push_back(vEnd); 492 outputPolygon.push_back(vEnd);
460 } 493 }
461 else // Both point outside -> no outp 494 else // Both point outside -> no output
462 { 495 {
463 } 496 }
464 } 497 }
465 } 498 }
466 } 499 }
467 500