Branch data Line data Source code
1 : : //- Class: CubitBox
2 : : //- Description: This file defines the CubitBox class.
3 : : //- Owner: Greg Sjaardema
4 : : //- Checked by:
5 : :
6 : : #include <cstdio>
7 : : #include <cstdlib>
8 : : #include <cassert>
9 : :
10 : : #include "CubitBox.hpp"
11 : : #include "CubitVector.hpp"
12 : : #include "CubitDefines.h"
13 : :
14 : 200897 : CubitBox::~CubitBox()
15 : 200897 : {}
16 : :
17 : 12915 : CubitBox::CubitBox() :
18 : : minimum_(0.0, 0.0, 0.0),
19 : 12915 : maximum_(0.0, 0.0, 0.0)
20 : 12915 : {}
21 : :
22 : 9050 : CubitBox::CubitBox(const CubitVector &min, const CubitVector &max)
23 : : {
24 : 4525 : minimum_.set (CUBIT_MIN (min.x(), max.x()),
25 : 4525 : CUBIT_MIN (min.y(), max.y()),
26 [ + + ][ + + ]: 13575 : CUBIT_MIN (min.z(), max.z()));
[ + + ]
27 : 4525 : maximum_.set (CUBIT_MAX (min.x(), max.x()),
28 : 4525 : CUBIT_MAX (min.y(), max.y()),
29 [ - + ][ - + ]: 13575 : CUBIT_MAX (min.z(), max.z()));
[ - + ]
30 : 4525 : }
31 : :
32 : 1464 : CubitBox::CubitBox(const CubitVector &min_max) :
33 : : minimum_(min_max),
34 : 1464 : maximum_(min_max)
35 : 1464 : {}
36 : :
37 : 152672 : CubitBox::CubitBox(const CubitBox& copy_from):
38 : : minimum_(copy_from.minimum_),
39 : 152672 : maximum_(copy_from.maximum_)
40 : 152672 : {}
41 : :
42 : 0 : CubitBox::CubitBox(const std::vector<CubitVector> & pts)
43 : : {
44 : 0 : minimum_.set(0.0, 0.0, 0.0);
45 : 0 : maximum_.set(0.0, 0.0, 0.0);
46 [ # # ]: 0 : for ( size_t i=0; i<pts.size(); i++ )
47 : : {
48 : 0 : double x = pts[i].x();
49 : 0 : double y = pts[i].y();
50 : 0 : double z = pts[i].z();
51 : 0 : minimum_.set(CUBIT_MIN(minimum_.x(), x),
52 : 0 : CUBIT_MIN(minimum_.y(), y),
53 [ # # ][ # # ]: 0 : CUBIT_MIN(minimum_.z(), z));
[ # # ]
54 : 0 : maximum_.set(CUBIT_MAX(maximum_.x(), x),
55 : 0 : CUBIT_MAX(maximum_.y(), y),
56 [ # # ][ # # ]: 0 : CUBIT_MAX(maximum_.z(), z));
[ # # ]
57 : : }
58 : 0 : }
59 : :
60 : 0 : void CubitBox::reset(const CubitVector& vector)
61 : : {
62 : 0 : minimum_ = vector;
63 : 0 : maximum_ = vector;
64 : 0 : }
65 : :
66 : 2112 : void CubitBox::reset(const CubitVector &min, const CubitVector &max)
67 : : {
68 : 2112 : minimum_.set (CUBIT_MIN (min.x(), max.x()),
69 : 2112 : CUBIT_MIN (min.y(), max.y()),
70 [ + + ][ + + ]: 6336 : CUBIT_MIN (min.z(), max.z()));
[ + + ]
71 : 2112 : maximum_.set (CUBIT_MAX (min.x(), max.x()),
72 : 2112 : CUBIT_MAX (min.y(), max.y()),
73 [ - + ][ - + ]: 6336 : CUBIT_MAX (min.z(), max.z()));
[ - + ]
74 : 2112 : }
75 : :
76 : 0 : void CubitBox::reset(const CubitBox &box)
77 : : {
78 : 0 : minimum_ = box.minimum_;
79 : 0 : maximum_ = box.maximum_;
80 : 0 : }
81 : :
82 : 21620 : CubitVector CubitBox::minimum() const
83 : : {
84 : 21620 : return CubitVector(minimum_);
85 : : }
86 : :
87 : 21686 : CubitVector CubitBox::maximum() const
88 : : {
89 : 21686 : return CubitVector(maximum_);
90 : : }
91 : :
92 : 8922 : double CubitBox::max_x() const
93 : : {
94 : 8922 : return maximum_.x();
95 : : }
96 : :
97 : 5864 : double CubitBox::max_y() const
98 : : {
99 : 5864 : return maximum_.y();
100 : : }
101 : :
102 : 4511 : double CubitBox::max_z() const
103 : : {
104 : 4511 : return maximum_.z();
105 : : }
106 : :
107 : 14917 : double CubitBox::min_x() const
108 : : {
109 : 14917 : return minimum_.x();
110 : : }
111 : :
112 : 7690 : double CubitBox::min_y() const
113 : : {
114 : 7690 : return minimum_.y();
115 : : }
116 : :
117 : 5094 : double CubitBox::min_z() const
118 : : {
119 : 5094 : return minimum_.z();
120 : : }
121 : :
122 : 2741 : CubitVector CubitBox::center() const
123 : : {
124 [ + - ]: 2741 : return CubitVector(minimum_ + maximum_) / 2.0;
125 : : }
126 : :
127 : 33 : CubitVector CubitBox::diagonal() const
128 : : {
129 : 33 : return CubitVector(maximum_ - minimum_);
130 : : }
131 : :
132 : 0 : double CubitBox::minimum_range( void)
133 : : {
134 [ # # ][ # # ]: 0 : return CUBIT_MIN(CUBIT_MIN( x_range(), y_range()), z_range());
[ # # ]
135 : : }
136 : :
137 : :
138 : 0 : double CubitBox::maximum_range( void)
139 : : {
140 [ # # ][ # # ]: 0 : return CUBIT_MAX( CUBIT_MAX( x_range(), y_range()), z_range());
[ # # ]
141 : : }
142 : :
143 : 136901 : double CubitBox::x_range() const
144 : 136901 : { return (maximum_.x() - minimum_.x()); }
145 : :
146 : 136901 : double CubitBox::y_range() const
147 : 136901 : { return (maximum_.y() - minimum_.y()); }
148 : :
149 : 136945 : double CubitBox::z_range() const
150 : 136945 : { return (maximum_.z() - minimum_.z()); }
151 : :
152 : 60701 : CubitBox& CubitBox::operator=(const CubitBox &box)
153 : : {
154 [ + - ]: 60701 : if (this != &box)
155 : : {
156 : 60701 : minimum_ = box.minimum_;
157 : 60701 : maximum_ = box.maximum_;
158 : : }
159 : 60701 : return *this;
160 : : }
161 : :
162 : 71407 : bool CubitBox::overlap( double tolerance , const CubitBox& box ) const
163 : : {
164 : : // | - note the '!'. This condition checks that the boxes
165 : : // | do NOT intersect and negates the result.
166 [ + + ]: 132884 : return ! ( (box.minimum_.x() - maximum_.x() > tolerance) ||
167 [ + + ]: 115404 : (box.minimum_.y() - maximum_.y() > tolerance) ||
168 [ + + ]: 104593 : (box.minimum_.z() - maximum_.z() > tolerance) ||
169 [ + + ]: 93359 : (minimum_.x() - box.maximum_.x() > tolerance) ||
170 : 42693 : (minimum_.y() - box.maximum_.y() > tolerance) ||
171 [ + + ][ + + ]: 132884 : (minimum_.z() - box.maximum_.z() > tolerance) );
172 : : }
173 : :
174 : :
175 : :
176 : :
177 : : // Union of this and box
178 : 69928 : CubitBox& CubitBox::operator|=(const CubitBox& box)
179 : : {
180 [ + + ]: 69928 : minimum_.x(CUBIT_MIN(minimum_.x(), box.minimum_.x()));
181 [ + + ]: 69928 : minimum_.y(CUBIT_MIN(minimum_.y(), box.minimum_.y()));
182 [ + + ]: 69928 : minimum_.z(CUBIT_MIN(minimum_.z(), box.minimum_.z()));
183 : :
184 [ + + ]: 69928 : maximum_.x(CUBIT_MAX(maximum_.x(), box.maximum_.x()));
185 [ + + ]: 69928 : maximum_.y(CUBIT_MAX(maximum_.y(), box.maximum_.y()));
186 [ + + ]: 69928 : maximum_.z(CUBIT_MAX(maximum_.z(), box.maximum_.z()));
187 : 69928 : return *this;
188 : : }
189 : :
190 : : // Union of this and vector
191 : 748 : CubitBox& CubitBox::operator|=(const CubitVector& vector)
192 : : {
193 [ + + ]: 748 : minimum_.x(CUBIT_MIN(minimum_.x(), vector.x()));
194 [ + + ]: 748 : minimum_.y(CUBIT_MIN(minimum_.y(), vector.y()));
195 [ + + ]: 748 : minimum_.z(CUBIT_MIN(minimum_.z(), vector.z()));
196 : :
197 [ + + ]: 748 : maximum_.x(CUBIT_MAX(maximum_.x(), vector.x()));
198 [ + + ]: 748 : maximum_.y(CUBIT_MAX(maximum_.y(), vector.y()));
199 [ + + ]: 748 : maximum_.z(CUBIT_MAX(maximum_.z(), vector.z()));
200 : 748 : return *this;
201 : : }
202 : :
203 : : // Intersection of this and box
204 : 0 : CubitBox& CubitBox::operator&=(const CubitBox& box)
205 : : {
206 [ # # ]: 0 : minimum_.x(CUBIT_MAX(minimum_.x(), box.minimum_.x()));
207 [ # # ]: 0 : minimum_.y(CUBIT_MAX(minimum_.y(), box.minimum_.y()));
208 [ # # ]: 0 : minimum_.z(CUBIT_MAX(minimum_.z(), box.minimum_.z()));
209 : :
210 [ # # ]: 0 : maximum_.x(CUBIT_MIN(maximum_.x(), box.maximum_.x()));
211 [ # # ]: 0 : maximum_.y(CUBIT_MIN(maximum_.y(), box.maximum_.y()));
212 [ # # ]: 0 : maximum_.z(CUBIT_MIN(maximum_.z(), box.maximum_.z()));
213 : :
214 [ # # ][ # # ]: 0 : if (minimum_.x() > maximum_.x() ||
215 [ # # ][ # # ]: 0 : minimum_.y() > maximum_.y() ||
216 : 0 : minimum_.z() > maximum_.z())
217 : : {
218 : 0 : minimum_.set(0.0, 0.0, 0.0);
219 : 0 : maximum_.set(0.0, 0.0, 0.0);
220 : : }
221 : 0 : return *this;
222 : : }
223 : :
224 : 44 : CubitBox& CubitBox::operator*=(double scale)
225 : : {
226 [ + - ]: 44 : CubitVector center_vec = center();
227 [ + - ]: 44 : *this -= center_vec;
228 [ + - ]: 44 : minimum_ *= scale;
229 [ + - ]: 44 : maximum_ *= scale;
230 [ + - ]: 44 : *this += center_vec;
231 : 44 : return *this;
232 : : }
233 : :
234 : 0 : CubitBox& CubitBox::operator/=(double scale)
235 : : {
236 [ # # ]: 0 : if(scale == 0.0)
237 : 0 : throw ("Cannot Divide by Zero");
238 : : //assert(scale != 0.0);
239 : 0 : *this *= 1/scale;
240 : 0 : return *this;
241 : : }
242 : :
243 : 44 : CubitBox& CubitBox::operator+=(const CubitVector& offset)
244 : : {
245 : 44 : minimum_ += offset;
246 : 44 : maximum_ += offset;
247 : 44 : return *this;
248 : : }
249 : :
250 : 44 : CubitBox& CubitBox::operator-=(const CubitVector& offset)
251 : : {
252 : 44 : minimum_ -= offset;
253 : 44 : maximum_ -= offset;
254 : 44 : return *this;
255 : : }
256 : :
257 : 33 : int CubitBox::operator<(const CubitBox& box) const
258 : : {
259 [ # # ]: 33 : return (box.minimum_.x() < minimum_.x() &&
260 [ # # ]: 0 : box.minimum_.y() < minimum_.y() &&
261 [ # # ]: 0 : box.minimum_.z() < minimum_.z() &&
262 [ # # ]: 0 : box.maximum_.x() > maximum_.x() &&
263 [ - + ][ # # ]: 33 : box.maximum_.y() > maximum_.y() &&
264 : 33 : box.maximum_.z() > maximum_.z());
265 : : }
266 : :
267 : 66 : int CubitBox::operator<=(const CubitBox& box) const
268 : : {
269 [ + + ]: 132 : return (box.minimum_.x() <= minimum_.x() &&
270 [ + + ]: 110 : box.minimum_.y() <= minimum_.y() &&
271 [ + - ]: 77 : box.minimum_.z() <= minimum_.z() &&
272 [ + + ]: 66 : box.maximum_.x() >= maximum_.x() &&
273 [ + - ][ - + ]: 165 : box.maximum_.y() >= maximum_.y() &&
274 : 77 : box.maximum_.z() >= maximum_.z());
275 : : }
276 : :
277 : 33 : int CubitBox::operator>(const CubitBox& box) const
278 : : {
279 [ # # ]: 33 : return (box.minimum_.x() > minimum_.x() &&
280 [ # # ]: 0 : box.minimum_.y() > minimum_.y() &&
281 [ # # ]: 0 : box.minimum_.z() > minimum_.z() &&
282 [ # # ]: 0 : box.maximum_.x() < maximum_.x() &&
283 [ - + ][ # # ]: 33 : box.maximum_.y() < maximum_.y() &&
284 : 33 : box.maximum_.z() < maximum_.z());
285 : : }
286 : :
287 : 0 : int CubitBox::operator>=(const CubitBox& box) const
288 : : {
289 [ # # ]: 0 : return (box.minimum_.x() >= minimum_.x() &&
290 [ # # ]: 0 : box.minimum_.y() >= minimum_.y() &&
291 [ # # ]: 0 : box.minimum_.z() >= minimum_.z() &&
292 [ # # ]: 0 : box.maximum_.x() <= maximum_.x() &&
293 [ # # ][ # # ]: 0 : box.maximum_.y() <= maximum_.y() &&
294 : 0 : box.maximum_.z() <= maximum_.z());
295 : : }
296 : :
297 : 0 : int CubitBox::operator>(const CubitVector& vect) const
298 : : {
299 [ # # # # ]: 0 : return (vect.x() > minimum_.x() && vect.x() < maximum_.x() &&
300 [ # # # # ]: 0 : vect.y() > minimum_.y() && vect.y() < maximum_.y() &&
301 [ # # ][ # # ]: 0 : vect.z() > minimum_.z() && vect.z() < maximum_.z() );
302 : : }
303 : :
304 : 0 : int CubitBox::operator>=(const CubitVector& vect) const
305 : : {
306 [ # # ]: 0 : return (vect.x() >= minimum_.x() &&
307 [ # # ]: 0 : vect.x() <= maximum_.x() &&
308 [ # # ]: 0 : vect.y() >= minimum_.y() &&
309 [ # # ]: 0 : vect.y() <= maximum_.y() &&
310 [ # # ][ # # ]: 0 : vect.z() >= minimum_.z() &&
311 : 0 : vect.z() <= maximum_.z() );
312 : : }
313 : :
314 : 0 : CubitBox operator|(const CubitBox& lhs, const CubitBox& rhs)
315 : : {
316 [ # # ][ # # ]: 0 : return CubitBox(lhs) |= rhs;
317 : : }
318 : :
319 : 0 : CubitBox operator&(const CubitBox& lhs, const CubitBox& rhs)
320 : : {
321 [ # # ][ # # ]: 0 : return CubitBox(lhs) &= rhs;
322 : : }
323 : :
324 : 11 : CubitBox operator*(double lhs, const CubitBox& rhs)
325 : : {
326 [ + - ][ + - ]: 11 : return CubitBox(rhs) *= lhs;
327 : : }
328 : :
329 : 33 : CubitBox operator*(const CubitBox& lhs, double rhs)
330 : : {
331 [ + - ][ + - ]: 33 : return CubitBox(lhs) *= rhs;
332 : : }
333 : :
334 : 0 : CubitBox operator/(const CubitBox& lhs, double rhs)
335 : : {
336 [ # # ][ # # ]: 0 : return CubitBox(lhs) /= rhs;
337 : : }
338 : :
339 : 0 : CubitBox operator+(const CubitBox& lhs, const CubitVector& rhs)
340 : : {
341 [ # # ][ # # ]: 0 : return CubitBox(lhs) += rhs;
342 : : }
343 : :
344 : 0 : CubitBox operator-(const CubitBox& lhs, const CubitVector& rhs)
345 : : {
346 [ # # ][ # # ]: 0 : return CubitBox(lhs) -= rhs;
347 : : }
348 : :
349 : 0 : double CubitBox::distance_squared( const CubitVector& point ) const
350 : : {
351 [ # # ][ # # ]: 0 : return (point - closest_point(point)).length_squared();
352 : : }
353 : :
354 : :
355 : :
356 : : //-------------------------------------------------------------------------
357 : : // Purpose : Find the closest point on the CubitBox
358 : : //
359 : : // Special Notes :
360 : : //
361 : : // Creator : Jason Kraftcheck
362 : : //
363 : : // Creation Date : 03/12/98
364 : : //-------------------------------------------------------------------------
365 : 0 : CubitVector CubitBox::closest_point( const CubitVector& point ) const
366 : : {
367 : 0 : CubitVector result;
368 : :
369 [ # # ]: 0 : if( point.x() < minimum_.x() )
370 : 0 : result.x( minimum_.x() );
371 [ # # ]: 0 : else if( point.x() > maximum_.x() )
372 : 0 : result.x( maximum_.x() );
373 : : else
374 : 0 : result.x( point.x() );
375 : :
376 [ # # ]: 0 : if( point.y() < minimum_.y() )
377 : 0 : result.y( minimum_.y() );
378 [ # # ]: 0 : else if( point.y() > maximum_.y() )
379 : 0 : result.y( maximum_.y() );
380 : : else
381 : 0 : result.y( point.y() );
382 : :
383 [ # # ]: 0 : if( point.z() < minimum_.z() )
384 : 0 : result.z( minimum_.z() );
385 [ # # ]: 0 : else if( point.z() > maximum_.z() )
386 : 0 : result.z( maximum_.z() );
387 : : else
388 : 0 : result.z( point.z() );
389 : :
390 : 0 : return result;
391 : : }
392 : :
393 : 66674 : CubitBox::CubitBox(const double min[3], const double max[3])
394 : : {
395 : 33337 : minimum_.set (CUBIT_MIN (min[0], max[0]),
396 : 33337 : CUBIT_MIN (min[1], max[1]),
397 [ + - ][ + - ]: 33337 : CUBIT_MIN (min[2], max[2]));
[ + - ]
398 : 33337 : maximum_.set (CUBIT_MAX (min[0], max[0]),
399 : 33337 : CUBIT_MAX (min[1], max[1]),
400 [ - + ][ - + ]: 33337 : CUBIT_MAX (min[2], max[2]));
[ - + ]
401 : 33337 : }
402 : :
403 : 4138 : void CubitBox::reset(const double min[3], const double max[3])
404 : : {
405 : 4138 : minimum_.set (CUBIT_MIN (min[0], max[0]),
406 : 4138 : CUBIT_MIN (min[1], max[1]),
407 [ + - ][ + - ]: 4138 : CUBIT_MIN (min[2], max[2]));
[ + - ]
408 : 4138 : maximum_.set (CUBIT_MAX (min[0], max[0]),
409 : 4138 : CUBIT_MAX (min[1], max[1]),
410 [ - + ][ - + ]: 4138 : CUBIT_MAX (min[2], max[2]));
[ - + ]
411 : 4138 : }
412 : :
413 : 0 : void CubitBox::get_corners( CubitVector vectors[8] ) const
414 : : {
415 : 0 : vectors[0] = minimum_;
416 [ # # ]: 0 : vectors[1] = CubitVector (maximum_.x(), minimum_.y(), minimum_.z());
417 [ # # ]: 0 : vectors[2] = CubitVector (maximum_.x(), maximum_.y(), minimum_.z());
418 [ # # ]: 0 : vectors[3] = CubitVector (minimum_.x(), maximum_.y(), minimum_.z());
419 : :
420 [ # # ]: 0 : vectors[4] = CubitVector (minimum_.x(), minimum_.y(), maximum_.z());
421 [ # # ]: 0 : vectors[5] = CubitVector (maximum_.x(), minimum_.y(), maximum_.z());
422 : 0 : vectors[6] = maximum_;
423 [ # # ]: 0 : vectors[7] = CubitVector (minimum_.x(), maximum_.y(), maximum_.z());
424 : 0 : }
425 : :
426 : 0 : int CubitBox::operator&&(const CubitBox& box) const
427 : : {
428 : : // Return false if there is no overlap
429 : : // along at least one of the 3 axes.
430 [ # # ][ # # ]: 0 : if (minimum_.x() > box.maximum_.x() ||
431 [ # # ]: 0 : maximum_.x() < box.minimum_.x() ||
432 [ # # ]: 0 : minimum_.y() > box.maximum_.y() ||
433 [ # # ]: 0 : maximum_.y() < box.minimum_.y() ||
434 [ # # ][ # # ]: 0 : minimum_.z() > box.maximum_.z() ||
435 : 0 : maximum_.z() < box.minimum_.z() )
436 : 0 : return CUBIT_FALSE;
437 : :
438 : : // If you didn't return false...
439 : 0 : return CUBIT_TRUE;
440 : : }
441 : :
442 : 0 : int CubitBox::operator||(const CubitBox& box) const
443 : : {
444 : : // Return false if there is no overlap
445 : : // along at least one of the 3 axes.
446 [ # # ][ # # ]: 0 : if (minimum_.x() >= box.maximum_.x() ||
447 [ # # ]: 0 : maximum_.x() <= box.minimum_.x() ||
448 [ # # ]: 0 : minimum_.y() >= box.maximum_.y() ||
449 [ # # ]: 0 : maximum_.y() <= box.minimum_.y() ||
450 [ # # ][ # # ]: 0 : minimum_.z() >= box.maximum_.z() ||
451 : 0 : maximum_.z() <= box.minimum_.z() )
452 : 0 : return CUBIT_FALSE;
453 : :
454 : : // If you didn't return false...
455 : 0 : return CUBIT_TRUE;
456 : : }
457 : :
458 : 0 : int CubitBox::operator<=(const CubitVector& vect) const
459 : : {
460 [ # # ]: 0 : return (vect.x() <= minimum_.x() ||
461 [ # # ]: 0 : vect.x() >= maximum_.x() ||
462 [ # # ]: 0 : vect.y() <= minimum_.y() ||
463 [ # # ]: 0 : vect.y() >= maximum_.y() ||
464 [ # # ][ # # ]: 0 : vect.z() <= minimum_.z() ||
465 : 0 : vect.z() >= maximum_.z() );
466 : : }
467 : :
468 : : /*
469 : : Ray-axis Aligned box intersection by
470 : : KAY, T. L., AND KAJIYA, J. T.
471 : : In Computer Graphics (SIGGRAPH '86 Proceedings) (Aug. 1986), D. C. Evans and R. J. Athay, Eds., vol. 20, pp. 269-278.
472 : :
473 : : Determines if there is an intersection between a ray and box but doesn't calculate the intersection.
474 : :
475 : : */
476 : 0 : bool CubitBox::intersect(const CubitVector& ray_origin, const CubitVector& ray_direction)
477 : : {
478 : 0 : double tNear=CUBIT_DBL_MIN;
479 : 0 : double tFar=CUBIT_DBL_MAX;
480 : :
481 [ # # ]: 0 : for(int i=0;i<3;i++)
482 : : {
483 : : //X plane
484 [ # # ]: 0 : if(fabs(ray_direction[i])<=CUBIT_DBL_MIN)
485 : : {
486 : : //Ray parallel to x plane
487 [ # # ][ # # ]: 0 : if(ray_origin[i]<this->minimum_[i] || ray_origin[i]>this->maximum_[i])
[ # # ]
488 : : {
489 : : //Not between
490 : 0 : return false;
491 : : }
492 : : else
493 : : {
494 : 0 : return true;
495 : : }
496 : : }
497 : :
498 : 0 : double t1 = (this->minimum_[i] - ray_origin[i]) / ray_direction[i];
499 : 0 : double t2 = (this->maximum_[i] - ray_origin[i]) / ray_direction[i];
500 : :
501 [ # # ]: 0 : if(t1>t2)
502 : : {
503 : 0 : double temp=t1;
504 : 0 : t1=t2;
505 : 0 : t2=temp;
506 : : }
507 [ # # ]: 0 : if(t1>tNear)
508 : : {
509 : 0 : tNear=t1;
510 : : }
511 : :
512 [ # # ]: 0 : if(t2<tFar)
513 : : {
514 : 0 : tFar=t2;
515 : : }
516 : :
517 [ # # ]: 0 : if(tNear>tFar)
518 : : {
519 : 0 : return false;
520 : : }
521 : :
522 [ # # ]: 0 : if(tFar<0)
523 : : {
524 : 0 : return false;
525 : : }
526 : :
527 : : }
528 : :
529 : 0 : return true;
530 : : }
531 : :
532 : : /*
533 : : Fast Ray-Box Intersection
534 : : by Andrew Woo
535 : : from "Graphics Gems", Academic Press, 1990
536 : : */
537 : :
538 : : #define NUMDIM 3
539 : : #define RIGHT 0
540 : : #define LEFT 1
541 : : #define MIDDLE 2
542 : :
543 : : //char HitBoundingBox(minB,maxB, origin, dir,coord)
544 : : //double minB[NUMDIM], maxB[NUMDIM]; /*box */
545 : : //double origin[NUMDIM], dir[NUMDIM]; /*ray */
546 : : //double coord[NUMDIM]; /* hit point */
547 : 0 : bool CubitBox::intersect
548 : : (const CubitVector& ray_origin,
549 : : const CubitVector& ray_direction,
550 : : CubitVector& intersection_pt)
551 : : {
552 : 0 : bool inside = true;
553 : : int quadrant[NUMDIM];
554 : : register int i;
555 : : int whichPlane;
556 : : double maxT[NUMDIM];
557 : : double candidatePlane[NUMDIM];
558 : :
559 : : /* Find candidate planes; this loop can be avoided if
560 : : rays cast all from the eye(assume perpsective view) */
561 [ # # ]: 0 : for (i=0; i<NUMDIM; i++)
562 : : {
563 [ # # ][ # # ]: 0 : if((ray_origin)[i] < (this->minimum())[i])
[ # # ][ # # ]
564 : : {
565 : 0 : quadrant[i] = LEFT;
566 [ # # ][ # # ]: 0 : candidatePlane[i] = (this->minimum())[i];
567 : 0 : inside = false;
568 : : }
569 [ # # ][ # # ]: 0 : else if ( (ray_origin)[i] > (this->maximum())[i])
[ # # ][ # # ]
570 : : {
571 : 0 : quadrant[i] = RIGHT;
572 [ # # ][ # # ]: 0 : candidatePlane[i] = (this->maximum())[i];
573 : 0 : inside = false;
574 : : }
575 : : else
576 : : {
577 : 0 : quadrant[i] = MIDDLE;
578 : : }
579 : : }
580 : :
581 : : /* Ray origin inside bounding box */
582 [ # # ]: 0 : if(inside)
583 : : {
584 [ # # ]: 0 : intersection_pt = ray_origin;
585 : 0 : return true;
586 : : }
587 : :
588 : : /* Calculate T distances to candidate planes */
589 [ # # ]: 0 : for (i = 0; i < NUMDIM; i++)
590 : : {
591 [ # # ][ # # ]: 0 : if (quadrant[i] != MIDDLE && (ray_direction)[i] !=0.)
[ # # ][ # # ]
592 [ # # ][ # # ]: 0 : maxT[i] = ( candidatePlane[i]-(ray_origin)[i]) / ((ray_direction)[i]);
593 : : else
594 : 0 : maxT[i] = -1.;
595 : : }
596 : :
597 : : /* Get largest of the maxT's for final choice of intersection */
598 : 0 : whichPlane = 0;
599 [ # # ]: 0 : for (i = 1; i < NUMDIM; i++)
600 : : {
601 [ # # ]: 0 : if (maxT[whichPlane] < maxT[i])
602 : 0 : whichPlane = i;
603 : : }
604 : :
605 : : /* Check final candidate actually inside box */
606 : : double intersection_coords[3];
607 : :
608 [ # # ]: 0 : if (maxT[whichPlane] < 0.)
609 : 0 : return false;
610 : :
611 [ # # ]: 0 : for (i = 0; i < NUMDIM; i++)
612 : : {
613 [ # # ]: 0 : if (whichPlane != i)
614 : : {
615 [ # # ][ # # ]: 0 : intersection_coords[i] = (ray_origin)[i] + maxT[whichPlane] * (ray_direction)[i];
616 [ # # ][ # # ]: 0 : if (intersection_coords[i] < (this->minimum())[i] ||
[ # # ][ # # ]
[ # # ]
[ # # # # ]
617 [ # # ][ # # ]: 0 : intersection_coords[i] > (this->maximum())[i])
[ # # ][ # # ]
618 : 0 : return false;
619 : : }
620 : : else
621 : : {
622 : 0 : intersection_coords[i] = candidatePlane[i];
623 : : }
624 : : }
625 : :
626 : 0 : return true; /* ray hits box */
627 : : }
|
