| 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 // G4ReduciblePolygon implementation; a utilit 26 // G4ReduciblePolygon implementation; a utility class used to specify,
27 // test, reduce, and/or otherwise manipulate a 27 // test, reduce, and/or otherwise manipulate a 2D polygon.
28 // See G4ReduciblePolygon.hh for more info. 28 // See G4ReduciblePolygon.hh for more info.
29 // 29 //
30 // Author: David C. Williams (davidw@scipp.ucs 30 // Author: David C. Williams (davidw@scipp.ucsc.edu)
31 // ------------------------------------------- 31 // --------------------------------------------------------------------
32 32
33 #include "G4ReduciblePolygon.hh" 33 #include "G4ReduciblePolygon.hh"
34 #include "globals.hh" 34 #include "globals.hh"
35 35
36 // Constructor: with simple arrays 36 // Constructor: with simple arrays
37 // 37 //
38 G4ReduciblePolygon::G4ReduciblePolygon( const 38 G4ReduciblePolygon::G4ReduciblePolygon( const G4double a[],
39 const 39 const G4double b[],
40 40 G4int n )
41 : aMin(0.), aMax(0.), bMin(0.), bMax(0.) 41 : aMin(0.), aMax(0.), bMin(0.), bMax(0.)
42 { 42 {
43 // 43 //
44 // Do all of the real work in Create 44 // Do all of the real work in Create
45 // 45 //
46 Create( a, b, n ); 46 Create( a, b, n );
47 } 47 }
48 48
49 // Constructor: special PGON/PCON case 49 // Constructor: special PGON/PCON case
50 // 50 //
51 G4ReduciblePolygon::G4ReduciblePolygon( const 51 G4ReduciblePolygon::G4ReduciblePolygon( const G4double rmin[],
52 const 52 const G4double rmax[],
53 const 53 const G4double z[], G4int n )
54 : aMin(0.), aMax(0.), bMin(0.), bMax(0.) 54 : aMin(0.), aMax(0.), bMin(0.), bMax(0.)
55 { 55 {
56 // 56 //
57 // Translate 57 // Translate
58 // 58 //
59 auto a = new G4double[n*2]; << 59 G4double *a = new G4double[n*2];
60 auto b = new G4double[n*2]; << 60 G4double *b = new G4double[n*2];
61 61
62 G4double *rOut = a + n, 62 G4double *rOut = a + n,
63 *zOut = b + n, 63 *zOut = b + n,
64 *rIn = rOut-1, 64 *rIn = rOut-1,
65 *zIn = zOut-1; 65 *zIn = zOut-1;
66 66
67 for( G4int i=0; i < n; ++i, ++rOut, ++zOut, 67 for( G4int i=0; i < n; ++i, ++rOut, ++zOut, --rIn, --zIn )
68 { 68 {
69 *rOut = rmax[i]; 69 *rOut = rmax[i];
70 *rIn = rmin[i]; 70 *rIn = rmin[i];
71 *zOut = *zIn = z[i]; 71 *zOut = *zIn = z[i];
72 } 72 }
73 73
74 Create( a, b, n*2 ); 74 Create( a, b, n*2 );
75 75
76 delete [] a; 76 delete [] a;
77 delete [] b; 77 delete [] b;
78 } 78 }
79 79
80 // Create 80 // Create
81 // 81 //
82 // To be called by constructors, fill in the l 82 // To be called by constructors, fill in the list and statistics for a new
83 // polygon 83 // polygon
84 // 84 //
85 void G4ReduciblePolygon::Create( const G4doubl 85 void G4ReduciblePolygon::Create( const G4double a[],
86 const G4doubl 86 const G4double b[], G4int n )
87 { 87 {
88 if (n<3) 88 if (n<3)
89 G4Exception("G4ReduciblePolygon::Create()", 89 G4Exception("G4ReduciblePolygon::Create()", "GeomSolids0002",
90 FatalErrorInArgument, "Less tha 90 FatalErrorInArgument, "Less than 3 vertices specified.");
91 91
92 const G4double *anext = a, *bnext = b; 92 const G4double *anext = a, *bnext = b;
93 ABVertex* prev = nullptr; 93 ABVertex* prev = nullptr;
94 do // Loop checking, 13.08.2015, G.Cosmo 94 do // Loop checking, 13.08.2015, G.Cosmo
95 { 95 {
96 auto newVertex = new ABVertex; << 96 ABVertex *newVertex = new ABVertex;
97 newVertex->a = *anext; 97 newVertex->a = *anext;
98 newVertex->b = *bnext; 98 newVertex->b = *bnext;
99 newVertex->next = nullptr; 99 newVertex->next = nullptr;
100 if (prev==nullptr) 100 if (prev==nullptr)
101 { 101 {
102 vertexHead = newVertex; 102 vertexHead = newVertex;
103 } 103 }
104 else 104 else
105 { 105 {
106 prev->next = newVertex; 106 prev->next = newVertex;
107 } 107 }
108 108
109 prev = newVertex; 109 prev = newVertex;
110 } while( ++anext, ++bnext < b+n ); 110 } while( ++anext, ++bnext < b+n );
111 111
112 numVertices = n; 112 numVertices = n;
113 113
114 CalculateMaxMin(); 114 CalculateMaxMin();
115 } 115 }
116 116
117 // Fake default constructor - sets only member 117 // Fake default constructor - sets only member data and allocates memory
118 // for usage restri 118 // for usage restricted to object persistency.
119 // 119 //
120 G4ReduciblePolygon::G4ReduciblePolygon( __void 120 G4ReduciblePolygon::G4ReduciblePolygon( __void__& )
121 : aMin(0.), aMax(0.), bMin(0.), bMax(0.) 121 : aMin(0.), aMax(0.), bMin(0.), bMax(0.)
122 { 122 {
123 } 123 }
124 124
125 125
126 // 126 //
127 // Destructor 127 // Destructor
128 // 128 //
129 G4ReduciblePolygon::~G4ReduciblePolygon() 129 G4ReduciblePolygon::~G4ReduciblePolygon()
130 { 130 {
131 ABVertex* curr = vertexHead; 131 ABVertex* curr = vertexHead;
132 while( curr != nullptr ) // Loop checking 132 while( curr != nullptr ) // Loop checking, 13.08.2015, G.Cosmo
133 { 133 {
134 ABVertex* toDelete = curr; 134 ABVertex* toDelete = curr;
135 curr = curr->next; 135 curr = curr->next;
136 delete toDelete; 136 delete toDelete;
137 } 137 }
138 } 138 }
139 139
140 // CopyVertices 140 // CopyVertices
141 // 141 //
142 // Copy contents into simple linear arrays. 142 // Copy contents into simple linear arrays.
143 // ***** CAUTION ***** Be care to declare the 143 // ***** CAUTION ***** Be care to declare the arrays to a large
144 // enough size! 144 // enough size!
145 // 145 //
146 void G4ReduciblePolygon::CopyVertices( G4doubl 146 void G4ReduciblePolygon::CopyVertices( G4double a[], G4double b[] ) const
147 { 147 {
148 G4double *anext = a, *bnext = b; 148 G4double *anext = a, *bnext = b;
149 ABVertex *curr = vertexHead; 149 ABVertex *curr = vertexHead;
150 while( curr != nullptr ) // Loop checking 150 while( curr != nullptr ) // Loop checking, 13.08.2015, G.Cosmo
151 { 151 {
152 *anext++ = curr->a; 152 *anext++ = curr->a;
153 *bnext++ = curr->b; 153 *bnext++ = curr->b;
154 curr = curr->next; 154 curr = curr->next;
155 } 155 }
156 } 156 }
157 157
158 // ScaleA 158 // ScaleA
159 // 159 //
160 // Multiply all a values by a common scale 160 // Multiply all a values by a common scale
161 // 161 //
162 void G4ReduciblePolygon::ScaleA( G4double scal 162 void G4ReduciblePolygon::ScaleA( G4double scale )
163 { 163 {
164 ABVertex* curr = vertexHead; 164 ABVertex* curr = vertexHead;
165 while( curr != nullptr ) // Loop checking 165 while( curr != nullptr ) // Loop checking, 13.08.2015, G.Cosmo
166 { 166 {
167 curr->a *= scale; 167 curr->a *= scale;
168 curr = curr->next; 168 curr = curr->next;
169 } 169 }
170 } 170 }
171 171
172 // ScaleB 172 // ScaleB
173 // 173 //
174 // Multiply all b values by a common scale 174 // Multiply all b values by a common scale
175 // 175 //
176 void G4ReduciblePolygon::ScaleB( G4double scal 176 void G4ReduciblePolygon::ScaleB( G4double scale )
177 { 177 {
178 ABVertex* curr = vertexHead; 178 ABVertex* curr = vertexHead;
179 while( curr != nullptr ) // Loop checking 179 while( curr != nullptr ) // Loop checking, 13.08.2015, G.Cosmo
180 { 180 {
181 curr->b *= scale; 181 curr->b *= scale;
182 curr = curr->next; 182 curr = curr->next;
183 } 183 }
184 } 184 }
185 185
186 // RemoveDuplicateVertices 186 // RemoveDuplicateVertices
187 // 187 //
188 // Remove adjacent vertices that are equal. Re 188 // Remove adjacent vertices that are equal. Returns "false" if there
189 // is a problem (too few vertices remaining). 189 // is a problem (too few vertices remaining).
190 // 190 //
191 G4bool G4ReduciblePolygon::RemoveDuplicateVert 191 G4bool G4ReduciblePolygon::RemoveDuplicateVertices( G4double tolerance )
192 { 192 {
193 ABVertex *curr = vertexHead, 193 ABVertex *curr = vertexHead,
194 *prev = nullptr, *next = nullptr; 194 *prev = nullptr, *next = nullptr;
195 while( curr != nullptr ) // Loop checking 195 while( curr != nullptr ) // Loop checking, 13.08.2015, G.Cosmo
196 { 196 {
197 next = curr->next; 197 next = curr->next;
198 if (next == nullptr) next = vertexHead; 198 if (next == nullptr) next = vertexHead;
199 199
200 if (std::fabs(curr->a-next->a) < tolerance 200 if (std::fabs(curr->a-next->a) < tolerance &&
201 std::fabs(curr->b-next->b) < tolerance 201 std::fabs(curr->b-next->b) < tolerance )
202 { 202 {
203 // 203 //
204 // Duplicate found: do we have > 3 verti 204 // Duplicate found: do we have > 3 vertices?
205 // 205 //
206 if (numVertices <= 3) 206 if (numVertices <= 3)
207 { 207 {
208 CalculateMaxMin(); 208 CalculateMaxMin();
209 return false; 209 return false;
210 } 210 }
211 211
212 // 212 //
213 // Delete 213 // Delete
214 // 214 //
215 ABVertex* toDelete = curr; 215 ABVertex* toDelete = curr;
216 curr = curr->next; 216 curr = curr->next;
217 delete toDelete; 217 delete toDelete;
218 218
219 numVertices--; 219 numVertices--;
220 220
221 if (prev != nullptr) 221 if (prev != nullptr)
222 prev->next = curr; 222 prev->next = curr;
223 else 223 else
224 vertexHead = curr; 224 vertexHead = curr;
225 } 225 }
226 else 226 else
227 { 227 {
228 prev = curr; 228 prev = curr;
229 curr = curr->next; 229 curr = curr->next;
230 } 230 }
231 } 231 }
232 232
233 // 233 //
234 // In principle, this is not needed, but why 234 // In principle, this is not needed, but why not just play it safe?
235 // 235 //
236 CalculateMaxMin(); 236 CalculateMaxMin();
237 237
238 return true; 238 return true;
239 } 239 }
240 240
241 // RemoveRedundantVertices 241 // RemoveRedundantVertices
242 // 242 //
243 // Remove any unneeded vertices, i.e. those ve 243 // Remove any unneeded vertices, i.e. those vertices which
244 // are on the line connecting the previous and 244 // are on the line connecting the previous and next vertices.
245 // 245 //
246 G4bool G4ReduciblePolygon::RemoveRedundantVert 246 G4bool G4ReduciblePolygon::RemoveRedundantVertices( G4double tolerance )
247 { 247 {
248 // 248 //
249 // Under these circumstances, we can quit no 249 // Under these circumstances, we can quit now!
250 // 250 //
251 if (numVertices <= 2) return false; 251 if (numVertices <= 2) return false;
252 252
253 G4double tolerance2 = tolerance*tolerance; 253 G4double tolerance2 = tolerance*tolerance;
254 254
255 // 255 //
256 // Loop over all vertices 256 // Loop over all vertices
257 // 257 //
258 ABVertex *curr = vertexHead, *next = nullptr 258 ABVertex *curr = vertexHead, *next = nullptr;
259 while( curr != nullptr ) // Loop checking 259 while( curr != nullptr ) // Loop checking, 13.08.2015, G.Cosmo
260 { 260 {
261 next = curr->next; 261 next = curr->next;
262 if (next == nullptr) next = vertexHead; 262 if (next == nullptr) next = vertexHead;
263 263
264 G4double da = next->a - curr->a, 264 G4double da = next->a - curr->a,
265 db = next->b - curr->b; 265 db = next->b - curr->b;
266 266
267 // 267 //
268 // Loop over all subsequent vertices, up t 268 // Loop over all subsequent vertices, up to curr
269 // 269 //
270 for(;;) 270 for(;;)
271 { 271 {
272 // 272 //
273 // Get vertex after next 273 // Get vertex after next
274 // 274 //
275 ABVertex* test = next->next; 275 ABVertex* test = next->next;
276 if (test == nullptr) test = vertexHead; 276 if (test == nullptr) test = vertexHead;
277 277
278 // 278 //
279 // If we are back to the original vertex 279 // If we are back to the original vertex, stop
280 // 280 //
281 if (test==curr) break; 281 if (test==curr) break;
282 282
283 // 283 //
284 // Test for parallel line segments 284 // Test for parallel line segments
285 // 285 //
286 G4double dat = test->a - curr->a, 286 G4double dat = test->a - curr->a,
287 dbt = test->b - curr->b; 287 dbt = test->b - curr->b;
288 288
289 if (std::fabs(dat*db-dbt*da)>tolerance2) 289 if (std::fabs(dat*db-dbt*da)>tolerance2) break;
290 290
291 // 291 //
292 // Redundant vertex found: do we have > 292 // Redundant vertex found: do we have > 3 vertices?
293 // 293 //
294 if (numVertices <= 3) 294 if (numVertices <= 3)
295 { 295 {
296 CalculateMaxMin(); 296 CalculateMaxMin();
297 return false; 297 return false;
298 } 298 }
299 299
300 // 300 //
301 // Delete vertex pointed to by next. Car 301 // Delete vertex pointed to by next. Carefully!
302 // 302 //
303 if (curr->next != nullptr) 303 if (curr->next != nullptr)
304 { // next is not head 304 { // next is not head
305 if (next->next != nullptr) 305 if (next->next != nullptr)
306 curr->next = test; // next is not t 306 curr->next = test; // next is not tail
307 else 307 else
308 curr->next = nullptr; // New tail 308 curr->next = nullptr; // New tail
309 } 309 }
310 else 310 else
311 vertexHead = test; // New head 311 vertexHead = test; // New head
312 312
313 if ((curr != next) && (next != test)) de 313 if ((curr != next) && (next != test)) delete next;
314 314
315 --numVertices; 315 --numVertices;
316 316
317 // 317 //
318 // Replace next by the vertex we just te 318 // Replace next by the vertex we just tested,
319 // and keep on going... 319 // and keep on going...
320 // 320 //
321 next = test; 321 next = test;
322 da = dat; db = dbt; 322 da = dat; db = dbt;
323 } 323 }
324 curr = curr->next; 324 curr = curr->next;
325 } 325 }
326 326
327 // 327 //
328 // In principle, this is not needed, but why 328 // In principle, this is not needed, but why not just play it safe?
329 // 329 //
330 CalculateMaxMin(); 330 CalculateMaxMin();
331 331
332 return true; 332 return true;
333 } 333 }
334 334
335 // ReverseOrder 335 // ReverseOrder
336 // 336 //
337 // Reverse the order of the vertices 337 // Reverse the order of the vertices
338 // 338 //
339 void G4ReduciblePolygon::ReverseOrder() 339 void G4ReduciblePolygon::ReverseOrder()
340 { 340 {
341 // 341 //
342 // Loop over all vertices 342 // Loop over all vertices
343 // 343 //
344 ABVertex* prev = vertexHead; 344 ABVertex* prev = vertexHead;
345 if (prev==nullptr) return; // No vertices 345 if (prev==nullptr) return; // No vertices
346 346
347 ABVertex* curr = prev->next; 347 ABVertex* curr = prev->next;
348 if (curr==nullptr) return; // Just one ve 348 if (curr==nullptr) return; // Just one vertex
349 349
350 // 350 //
351 // Our new tail 351 // Our new tail
352 // 352 //
353 vertexHead->next = nullptr; 353 vertexHead->next = nullptr;
354 354
355 for(;;) 355 for(;;)
356 { 356 {
357 // 357 //
358 // Save pointer to next vertex (in origina 358 // Save pointer to next vertex (in original order)
359 // 359 //
360 ABVertex *save = curr->next; 360 ABVertex *save = curr->next;
361 361
362 // 362 //
363 // Replace it with a pointer to the previo 363 // Replace it with a pointer to the previous one
364 // (in original order) 364 // (in original order)
365 // 365 //
366 curr->next = prev; 366 curr->next = prev;
367 367
368 // 368 //
369 // Last vertex? 369 // Last vertex?
370 // 370 //
371 if (save == nullptr) break; 371 if (save == nullptr) break;
372 372
373 // 373 //
374 // Next vertex 374 // Next vertex
375 // 375 //
376 prev = curr; 376 prev = curr;
377 curr = save; 377 curr = save;
378 } 378 }
379 379
380 // 380 //
381 // Our new head 381 // Our new head
382 // 382 //
383 vertexHead = curr; 383 vertexHead = curr;
384 } 384 }
385 385
386 386
387 // StartWithZMin 387 // StartWithZMin
388 // 388 //
389 // Starting alway with Zmin=bMin 389 // Starting alway with Zmin=bMin
390 // This method is used for GenericPolycone 390 // This method is used for GenericPolycone
391 // 391 //
392 void G4ReduciblePolygon::StartWithZMin() 392 void G4ReduciblePolygon::StartWithZMin()
393 { 393 {
394 ABVertex* curr = vertexHead; 394 ABVertex* curr = vertexHead;
395 G4double bcurr = curr->b; 395 G4double bcurr = curr->b;
396 ABVertex* prev = curr; 396 ABVertex* prev = curr;
397 while( curr != nullptr) // Loop checking, 397 while( curr != nullptr) // Loop checking, 13.08.2015, G.Cosmo
398 { 398 {
399 if(curr->b < bcurr) 399 if(curr->b < bcurr)
400 { 400 {
401 bcurr = curr->b; 401 bcurr = curr->b;
402 ABVertex* curr1 = curr; 402 ABVertex* curr1 = curr;
403 while( curr1 != nullptr ) // Loop che 403 while( curr1 != nullptr ) // Loop checking, 13.08.2015, G.Cosmo
404 { 404 {
405 if(curr1->next == nullptr) { curr1->ne 405 if(curr1->next == nullptr) { curr1->next = vertexHead; break; }
406 curr1 = curr1->next; 406 curr1 = curr1->next;
407 } 407 }
408 vertexHead = curr; 408 vertexHead = curr;
409 prev->next = nullptr; 409 prev->next = nullptr;
410 } 410 }
411 prev = curr; 411 prev = curr;
412 curr = curr->next; 412 curr = curr->next;
413 } 413 }
414 } 414 }
415 415
416 // CrossesItself 416 // CrossesItself
417 // 417 //
418 // Return "true" if the polygon crosses itself 418 // Return "true" if the polygon crosses itself
419 // 419 //
420 // Warning: this routine is not very fast (run 420 // Warning: this routine is not very fast (runs as N**2)
421 // 421 //
422 G4bool G4ReduciblePolygon::CrossesItself( G4do 422 G4bool G4ReduciblePolygon::CrossesItself( G4double tolerance )
423 { 423 {
424 G4double tolerance2 = tolerance*tolerance; 424 G4double tolerance2 = tolerance*tolerance;
425 G4double one = 1.0-tolerance, 425 G4double one = 1.0-tolerance,
426 zero = tolerance; 426 zero = tolerance;
427 // 427 //
428 // Top loop over line segments. By the time 428 // Top loop over line segments. By the time we finish
429 // with the second to last segment, we're do 429 // with the second to last segment, we're done.
430 // 430 //
431 ABVertex *curr1 = vertexHead, *next1 = nullp 431 ABVertex *curr1 = vertexHead, *next1 = nullptr;
432 while (curr1->next != nullptr) // Loop ch 432 while (curr1->next != nullptr) // Loop checking, 13.08.2015, G.Cosmo
433 { 433 {
434 next1 = curr1->next; 434 next1 = curr1->next;
435 G4double da1 = next1->a-curr1->a, 435 G4double da1 = next1->a-curr1->a,
436 db1 = next1->b-curr1->b; 436 db1 = next1->b-curr1->b;
437 437
438 // 438 //
439 // Inner loop over subsequent line segment 439 // Inner loop over subsequent line segments
440 // 440 //
441 ABVertex* curr2 = next1->next; 441 ABVertex* curr2 = next1->next;
442 while( curr2 != nullptr ) // Loop check 442 while( curr2 != nullptr ) // Loop checking, 13.08.2015, G.Cosmo
443 { 443 {
444 ABVertex* next2 = curr2->next; 444 ABVertex* next2 = curr2->next;
445 if (next2==nullptr) next2 = vertexHead; 445 if (next2==nullptr) next2 = vertexHead;
446 G4double da2 = next2->a-curr2->a, 446 G4double da2 = next2->a-curr2->a,
447 db2 = next2->b-curr2->b; 447 db2 = next2->b-curr2->b;
448 G4double a12 = curr2->a-curr1->a, 448 G4double a12 = curr2->a-curr1->a,
449 b12 = curr2->b-curr1->b; 449 b12 = curr2->b-curr1->b;
450 450
451 // 451 //
452 // Calculate intersection of the two lin 452 // Calculate intersection of the two lines
453 // 453 //
454 G4double deter = da1*db2 - db1*da2; 454 G4double deter = da1*db2 - db1*da2;
455 if (std::fabs(deter) > tolerance2) 455 if (std::fabs(deter) > tolerance2)
456 { 456 {
457 G4double s1, s2; 457 G4double s1, s2;
458 s1 = (a12*db2-b12*da2)/deter; 458 s1 = (a12*db2-b12*da2)/deter;
459 459
460 if (s1 >= zero && s1 < one) 460 if (s1 >= zero && s1 < one)
461 { 461 {
462 s2 = -(da1*b12-db1*a12)/deter; 462 s2 = -(da1*b12-db1*a12)/deter;
463 if (s2 >= zero && s2 < one) return t 463 if (s2 >= zero && s2 < one) return true;
464 } 464 }
465 } 465 }
466 curr2 = curr2->next; 466 curr2 = curr2->next;
467 } 467 }
468 curr1 = next1; 468 curr1 = next1;
469 } 469 }
470 return false; 470 return false;
471 } 471 }
472 472
473 // BisectedBy 473 // BisectedBy
474 // 474 //
475 // Decide if a line through two points crosses 475 // Decide if a line through two points crosses the polygon, within tolerance
476 // 476 //
477 G4bool G4ReduciblePolygon::BisectedBy( G4doubl 477 G4bool G4ReduciblePolygon::BisectedBy( G4double a1, G4double b1,
478 G4doubl 478 G4double a2, G4double b2,
479 G4doubl 479 G4double tolerance )
480 { 480 {
481 G4int nNeg = 0, nPos = 0; 481 G4int nNeg = 0, nPos = 0;
482 482
483 G4double a12 = a2-a1, b12 = b2-b1; 483 G4double a12 = a2-a1, b12 = b2-b1;
484 G4double len12 = std::sqrt( a12*a12 + b12*b1 484 G4double len12 = std::sqrt( a12*a12 + b12*b12 );
485 a12 /= len12; b12 /= len12; 485 a12 /= len12; b12 /= len12;
486 486
487 ABVertex* curr = vertexHead; 487 ABVertex* curr = vertexHead;
488 do // Loop checking, 13.08.2015, G.Cosmo 488 do // Loop checking, 13.08.2015, G.Cosmo
489 { 489 {
490 G4double av = curr->a - a1, 490 G4double av = curr->a - a1,
491 bv = curr->b - b1; 491 bv = curr->b - b1;
492 492
493 G4double cross = av*b12 - bv*a12; 493 G4double cross = av*b12 - bv*a12;
494 494
495 if (cross < -tolerance) 495 if (cross < -tolerance)
496 { 496 {
497 if (nPos != 0) return true; << 497 if (nPos) return true;
498 ++nNeg; 498 ++nNeg;
499 } 499 }
500 else if (cross > tolerance) 500 else if (cross > tolerance)
501 { 501 {
502 if (nNeg != 0) return true; << 502 if (nNeg) return true;
503 ++nPos; 503 ++nPos;
504 } 504 }
505 curr = curr->next; 505 curr = curr->next;
506 } while( curr != nullptr ); 506 } while( curr != nullptr );
507 507
508 return false; 508 return false;
509 } 509 }
510 510
511 // Area 511 // Area
512 // 512 //
513 // Calculated signed polygon area, where polyg 513 // Calculated signed polygon area, where polygons specified in a
514 // clockwise manner (where x==a, y==b) have ne 514 // clockwise manner (where x==a, y==b) have negative area
515 // 515 //
516 // References: [O' Rourke (C)] pp. 18-27; [ 516 // References: [O' Rourke (C)] pp. 18-27; [Gems II] pp. 5-6:
517 // "The Area of a Simple Polygon", Jon Rokn 517 // "The Area of a Simple Polygon", Jon Rokne.
518 // 518 //
519 G4double G4ReduciblePolygon::Area() 519 G4double G4ReduciblePolygon::Area()
520 { 520 {
521 G4double answer = 0; 521 G4double answer = 0;
522 522
523 ABVertex *curr = vertexHead, *next = nullptr 523 ABVertex *curr = vertexHead, *next = nullptr;
524 do // Loop checking, 13.08.2015, G.Cosmo 524 do // Loop checking, 13.08.2015, G.Cosmo
525 { 525 {
526 next = curr->next; 526 next = curr->next;
527 if (next==nullptr) next = vertexHead; << 527 if (next==0) next = vertexHead;
528 528
529 answer += curr->a*next->b - curr->b*next-> 529 answer += curr->a*next->b - curr->b*next->a;
530 curr = curr->next; 530 curr = curr->next;
531 } while( curr != nullptr ); 531 } while( curr != nullptr );
532 532
533 return 0.5*answer; 533 return 0.5*answer;
534 } 534 }
535 535
536 // Print 536 // Print
537 // 537 //
538 void G4ReduciblePolygon::Print() 538 void G4ReduciblePolygon::Print()
539 { 539 {
540 ABVertex* curr = vertexHead; 540 ABVertex* curr = vertexHead;
541 do // Loop checking, 13.08.2015, G.Cosmo 541 do // Loop checking, 13.08.2015, G.Cosmo
542 { 542 {
543 G4cerr << curr->a << " " << curr->b << G4e 543 G4cerr << curr->a << " " << curr->b << G4endl;
544 curr = curr->next; 544 curr = curr->next;
545 } while( curr != nullptr ); 545 } while( curr != nullptr );
546 } 546 }
547 547
548 // CalculateMaxMin 548 // CalculateMaxMin
549 // 549 //
550 // To be called when the vertices are changed, 550 // To be called when the vertices are changed, this
551 // routine re-calculates global values 551 // routine re-calculates global values
552 // 552 //
553 void G4ReduciblePolygon::CalculateMaxMin() 553 void G4ReduciblePolygon::CalculateMaxMin()
554 { 554 {
555 ABVertex* curr = vertexHead; 555 ABVertex* curr = vertexHead;
556 aMin = aMax = curr->a; 556 aMin = aMax = curr->a;
557 bMin = bMax = curr->b; 557 bMin = bMax = curr->b;
558 curr = curr->next; 558 curr = curr->next;
559 while( curr != nullptr ) // Loop checking 559 while( curr != nullptr ) // Loop checking, 13.08.2015, G.Cosmo
560 { 560 {
561 if (curr->a < aMin) 561 if (curr->a < aMin)
562 aMin = curr->a; 562 aMin = curr->a;
563 else if (curr->a > aMax) 563 else if (curr->a > aMax)
564 aMax = curr->a; 564 aMax = curr->a;
565 565
566 if (curr->b < bMin) 566 if (curr->b < bMin)
567 bMin = curr->b; 567 bMin = curr->b;
568 else if (curr->b > bMax) 568 else if (curr->b > bMax)
569 bMax = curr->b; 569 bMax = curr->b;
570 570
571 curr = curr->next; 571 curr = curr->next;
572 } 572 }
573 } 573 }
574 574