MOAB: Mesh Oriented datABase  (version 5.5.0)
Macros | Functions | Variables
oriented_box_test.cpp File Reference
#include "moab/OrientedBox.hpp"
#include "moab/CartVect.hpp"
#include "moab/Core.hpp"
#include "moab/Range.hpp"
#include <cassert>
#include <iostream>
+ Include dependency graph for oriented_box_test.cpp:

Go to the source code of this file.

Macros

#define ASSERT_VECTOR_ELEMENT(A, B)   assert_vector_element( ( A ), ( B ), #A, #B, __LINE__ )
 
#define ASSERT_VECTORS_EQUAL(A, B)   assert_vectors_equal( ( A ), ( B ), #A, #B, __LINE__ )
 
#define ASSERT_DOUBLES_EQUAL(A, B)   assert_doubles_equal( ( A ), ( B ), #A, #B, __LINE__ )
 
#define ASSERT(B)   assert_bool( ( B ), #B, __LINE__ )
 

Functions

static void test_basic ()
 
static void test_contained ()
 
static void test_ray_intersect ()
 
static void test_closest_point ()
 
static void test_build_from_tri ()
 
static void test_build_from_pts ()
 
static void test_save ()
 
static void assert_vector_element (const CartVect &a, const Matrix3 &b, const char *sa, const char *sb, int lineno)
 
static void assert_vectors_equal (const CartVect &a, const CartVect &b, const char *sa, const char *sb, int lineno)
 
static void assert_doubles_equal (double a, double b, const char *sa, const char *sb, int lineno)
 
static void assert_bool (bool b, const char *sb, int lineno)
 
int main ()
 
const Matrix3 origaxes (5 *unitaxes.col(0), 10 *unitaxes.col(1), 0.1 *unitaxes.col(2), true)
 
static CartVect scaled_corner (const OrientedBox &box, int corner, double factor)
 
static CartVect scaled_face (const OrientedBox &box, int face, double factor)
 
static void axis_dims (const Matrix3 &axis, CartVect &dims)
 

Variables

const double TOL = 1e-6
 
int error_count = 0
 
const CartVect origin (0.0, 0.0, 0.0)
 
const Matrix3 unitaxes (0.5, 0.0, 0.0, 0.0, 0.5, 0.0, 0.0, 0.0, 0.5)
 
const OrientedBox unitbox (unitaxes, origin)
 
const CartVect unitcenter (10, 20, 30)
 
const OrientedBox offsetbox (unitaxes, unitcenter)
 
const OrientedBox oblongbox (origaxes, origin)
 
const CartVect rotax0 = CartVect( 1.0, 1.0, 0.0 )
 
const CartVect rotax1 = CartVect( 1.0, -1.0, 1.0 )
 
const CartVect rotax2 = CartVect( 1.0, 1.0, 0.0 ) * CartVect( 1.0, -1.0, 1.0 )
 
const CartVect rotax [3] = { rotax0, rotax1, rotax2 }
 
const OrientedBox rotbox_cv (rotax, origin)
 
const Matrix3 rotaxes (rotax0, rotax1, rotax2, false)
 
const OrientedBox rotbox (rotaxes, origin)
 

Macro Definition Documentation

◆ ASSERT

#define ASSERT (   B)    assert_bool( ( B ), #B, __LINE__ )

Definition at line 25 of file oriented_box_test.cpp.

◆ ASSERT_DOUBLES_EQUAL

#define ASSERT_DOUBLES_EQUAL (   A,
  B 
)    assert_doubles_equal( ( A ), ( B ), #A, #B, __LINE__ )

Definition at line 24 of file oriented_box_test.cpp.

◆ ASSERT_VECTOR_ELEMENT

#define ASSERT_VECTOR_ELEMENT (   A,
  B 
)    assert_vector_element( ( A ), ( B ), #A, #B, __LINE__ )

Definition at line 22 of file oriented_box_test.cpp.

◆ ASSERT_VECTORS_EQUAL

#define ASSERT_VECTORS_EQUAL (   A,
  B 
)    assert_vectors_equal( ( A ), ( B ), #A, #B, __LINE__ )

Definition at line 23 of file oriented_box_test.cpp.

Function Documentation

◆ assert_bool()

static void assert_bool ( bool  b,
const char *  sb,
int  lineno 
)
static

Definition at line 1678 of file oriented_box_test.cpp.

1679 {
1680  if( !b )
1681  {
1682  std::cerr << "Assertion failed at line " << lineno << std::endl << "\t" << sb << std::endl;
1683  ++error_count;
1684  }
1685 }

References error_count.

◆ assert_doubles_equal()

static void assert_doubles_equal ( double  a,
double  b,
const char *  sa,
const char *  sb,
int  lineno 
)
static

Definition at line 1667 of file oriented_box_test.cpp.

1668 {
1669  if( fabs( a - b ) > TOL )
1670  {
1671  std::cerr << "Assertion failed at line " << lineno << std::endl
1672  << "\t" << sa << " == " << sb << std::endl
1673  << "\t" << a << " == " << b << std::endl;
1674  ++error_count;
1675  }
1676 }

References error_count, and TOL.

◆ assert_vector_element()

static void assert_vector_element ( const CartVect &  a,
const Matrix3 &  b,
const char *  sa,
const char *  sb,
int  lineno 
)
static

Definition at line 1632 of file oriented_box_test.cpp.

1633 {
1634  int i;
1635  bool ismatch = false;
1636  for( i = 0; i < 3; ++i )
1637  {
1638  if( fabs( a[0] - b( 0, i ) ) <= TOL && fabs( a[1] - b( 1, i ) ) <= TOL && fabs( a[2] - b( 2, i ) ) <= TOL )
1639  {
1640  ismatch = true;
1641  break;
1642  }
1643  }
1644  if( !ismatch )
1645  {
1646  ++error_count;
1647  std::cerr << "Assertion failed at line " << lineno << std::endl
1648  << "\t" << sa << " in " << sb << std::endl
1649  << "\t" << sa << " = " << a << std::endl
1650  << "\t" << sb << " = " << b << std::endl;
1651  }
1652  return;
1653 }

References error_count, and TOL.

◆ assert_vectors_equal()

static void assert_vectors_equal ( const CartVect &  a,
const CartVect &  b,
const char *  sa,
const char *  sb,
int  lineno 
)
static

Definition at line 1655 of file oriented_box_test.cpp.

1656 {
1657  if( fabs( a[0] - b[0] ) > TOL || fabs( a[1] - b[1] ) > TOL || fabs( a[2] - b[2] ) > TOL )
1658  {
1659  std::cerr << "Assertion failed at line " << lineno << std::endl
1660  << "\t" << sa << " == " << sb << std::endl
1661  << "\t[" << a[0] << ", " << a[1] << ", " << a[2] << "] == [" << b[0] << ", " << b[1] << ", " << b[2]
1662  << "]" << std::endl;
1663  ++error_count;
1664  }
1665 }

References error_count, and TOL.

◆ axis_dims()

static void axis_dims ( const Matrix3 &  axis,
CartVect &  dims 
)
static

Definition at line 93 of file oriented_box_test.cpp.

94 {
95  dims = CartVect( axis.col( 0 ).length(), axis.col( 1 ).length(), axis.col( 2 ).length() );
96  if( dims[0] > dims[1] ) std::swap( dims[0], dims[1] );
97  if( dims[1] > dims[2] ) std::swap( dims[1], dims[2] );
98  if( dims[0] > dims[1] ) std::swap( dims[0], dims[1] );
99 }

References moab::Matrix3::col(), moab::CartVect::length(), and swap().

Referenced by test_basic().

◆ main()

int main ( )

Definition at line 32 of file oriented_box_test.cpp.

33 {
34  test_basic();
35  test_contained();
36  test_ray_intersect();
37  test_closest_point();
38  test_build_from_tri();
39  test_build_from_pts();
40  test_save();
41  return error_count;
42 }

References error_count, test_basic(), test_build_from_pts(), test_build_from_tri(), test_closest_point(), test_contained(), test_ray_intersect(), and test_save().

◆ origaxes()

const Matrix3 origaxes ( 5 *unitaxes.  col0,
10 *unitaxes.  col1,
0.1 *unitaxes.  col2,
true   
)

Referenced by test_basic().

◆ scaled_corner()

static CartVect scaled_corner ( const OrientedBox &  box,
int  corner,
double  factor 
)
static

Definition at line 76 of file oriented_box_test.cpp.

77 {
78  static const int signs[][3] = { { 1, 1, -1 }, { -1, 1, -1 }, { -1, -1, -1 }, { 1, -1, -1 },
79  { 1, 1, 1 }, { -1, 1, 1 }, { -1, -1, 1 }, { 1, -1, 1 } };
80  return box.center + signs[corner][0] * factor * box.scaled_axis( 0 ) +
81  signs[corner][1] * factor * box.scaled_axis( 1 ) + signs[corner][2] * factor * box.scaled_axis( 2 );
82 }

References box().

Referenced by test_closest_point(), test_contained(), and test_ray_intersect().

◆ scaled_face()

static CartVect scaled_face ( const OrientedBox &  box,
int  face,
double  factor 
)
static

Definition at line 85 of file oriented_box_test.cpp.

86 {
87  assert( face >= 0 && face <= 6 );
88  int sign = face % 2 ? -1 : 1;
89  return box.center + factor * sign * box.scaled_axis( face / 2 );
90 }

References box().

Referenced by test_closest_point(), test_contained(), and test_ray_intersect().

◆ test_basic()

static void test_basic ( )
static

Definition at line 103 of file oriented_box_test.cpp.

104 {
105  CartVect dims;
106 
107  axis_dims( unitaxes, dims );
108  ASSERT_VECTORS_EQUAL( unitbox.center, origin );
109  ASSERT_VECTOR_ELEMENT( unitbox.scaled_axis( 0 ), unitaxes );
110  ASSERT_VECTOR_ELEMENT( unitbox.scaled_axis( 1 ), unitaxes );
111  ASSERT_VECTOR_ELEMENT( unitbox.scaled_axis( 2 ), unitaxes );
112  ASSERT_DOUBLES_EQUAL( unitbox.inner_radius(), dims[0] );
113  ASSERT_DOUBLES_EQUAL( unitbox.outer_radius(), dims.length() );
114  ASSERT_DOUBLES_EQUAL( unitbox.volume(), 8.0 * dims[0] * dims[1] * dims[2] );
115  ASSERT_VECTORS_EQUAL( unitbox.dimensions(), 2 * dims );
116 
117  axis_dims( unitaxes, dims );
118  ASSERT_VECTORS_EQUAL( offsetbox.center, unitcenter );
119  ASSERT_VECTOR_ELEMENT( offsetbox.scaled_axis( 0 ), unitaxes );
120  ASSERT_VECTOR_ELEMENT( offsetbox.scaled_axis( 1 ), unitaxes );
121  ASSERT_VECTOR_ELEMENT( offsetbox.scaled_axis( 2 ), unitaxes );
122  ASSERT_DOUBLES_EQUAL( offsetbox.inner_radius(), dims[0] );
123  ASSERT_DOUBLES_EQUAL( offsetbox.outer_radius(), dims.length() );
124  ASSERT_DOUBLES_EQUAL( offsetbox.volume(), 8.0 * dims[0] * dims[1] * dims[2] );
125  ASSERT_VECTORS_EQUAL( offsetbox.dimensions(), 2 * dims );
126 
127  axis_dims( origaxes, dims );
128  ASSERT_VECTORS_EQUAL( oblongbox.center, origin );
129  ASSERT_VECTOR_ELEMENT( oblongbox.scaled_axis( 0 ), origaxes );
130  ASSERT_VECTOR_ELEMENT( oblongbox.scaled_axis( 1 ), origaxes );
131  ASSERT_VECTOR_ELEMENT( oblongbox.scaled_axis( 2 ), origaxes );
132  ASSERT_DOUBLES_EQUAL( oblongbox.inner_radius(), dims[0] );
133  ASSERT_DOUBLES_EQUAL( oblongbox.outer_radius(), dims.length() );
134  ASSERT_DOUBLES_EQUAL( oblongbox.volume(), 8.0 * dims[0] * dims[1] * dims[2] );
135  ASSERT_VECTORS_EQUAL( oblongbox.dimensions(), 2 * dims );
136 
137  // test matrix constructor
138  axis_dims( rotaxes, dims );
139  ASSERT_VECTORS_EQUAL( rotbox.center, origin );
140  ASSERT_VECTOR_ELEMENT( rotbox.scaled_axis( 0 ), rotaxes );
141  ASSERT_VECTOR_ELEMENT( rotbox.scaled_axis( 1 ), rotaxes );
142  ASSERT_VECTOR_ELEMENT( rotbox.scaled_axis( 2 ), rotaxes );
143  ASSERT_DOUBLES_EQUAL( rotbox.inner_radius(), dims[0] );
144  ASSERT_DOUBLES_EQUAL( rotbox.outer_radius(), dims.length() );
145  ASSERT_DOUBLES_EQUAL( rotbox.volume(), 8.0 * dims[0] * dims[1] * dims[2] );
146  ASSERT_VECTORS_EQUAL( rotbox.dimensions(), 2 * dims );
147 
148  // test cartvect constructor; ordering of the axes by length happens in the constructor
149  ASSERT_VECTORS_EQUAL( rotbox_cv.center, origin );
150  ASSERT_VECTORS_EQUAL( rotbox_cv.scaled_axis( 0 ), rotax0 );
151  ASSERT_VECTORS_EQUAL( rotbox_cv.scaled_axis( 1 ), rotax1 );
152  ASSERT_VECTORS_EQUAL( rotbox_cv.scaled_axis( 2 ), rotax2 );
153  ASSERT_DOUBLES_EQUAL( rotbox_cv.inner_radius(), dims[0] );
154  ASSERT_DOUBLES_EQUAL( rotbox_cv.outer_radius(), dims.length() );
155  ASSERT_DOUBLES_EQUAL( rotbox_cv.volume(), 8.0 * dims[0] * dims[1] * dims[2] );
156  ASSERT_VECTORS_EQUAL( rotbox_cv.dimensions(), 2 * dims );
157 }

References ASSERT_DOUBLES_EQUAL, ASSERT_VECTOR_ELEMENT, ASSERT_VECTORS_EQUAL, axis_dims(), moab::OrientedBox::center, moab::OrientedBox::dimensions(), moab::OrientedBox::inner_radius(), moab::CartVect::length(), oblongbox, offsetbox, origaxes(), origin, moab::OrientedBox::outer_radius(), rotax0, rotax1, rotax2, rotaxes, rotbox, rotbox_cv, moab::OrientedBox::scaled_axis(), unitaxes, unitbox, unitcenter, and moab::OrientedBox::volume().

Referenced by main().

◆ test_build_from_pts()

void test_build_from_pts ( )
static

Definition at line 1559 of file oriented_box_test.cpp.

1560 {
1561  ErrorCode rval;
1562  Core moab;
1563  Interface* const gMB = &moab;
1564 
1565  const double vertex_coords[] = { 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1 };
1566  const int num_double = sizeof( vertex_coords ) / ( sizeof( double ) );
1567  const int num_vertex = num_double / 3;
1568  assert( 0 == num_double % 3 );
1569 
1570  // create some vertices
1571  Range vertices;
1572  double min[3] = { HUGE_VAL, HUGE_VAL, HUGE_VAL };
1573  double max[3] = { -HUGE_VAL, -HUGE_VAL, -HUGE_VAL };
1574  for( int i = 0; i < num_vertex; ++i )
1575  {
1576  EntityHandle h;
1577  rval = gMB->create_vertex( vertex_coords + 3 * i, h );
1578  ASSERT( MB_SUCCESS == rval );
1579  vertices.insert( h );
1580  for( int j = 0; j < 3; ++j )
1581  {
1582  const double c = vertex_coords[3 * i + j];
1583  if( c < min[j] ) min[j] = c;
1584  if( c > max[j] ) max[j] = c;
1585  }
1586  }
1587 
1588  // create box containing vertices
1589  OrientedBox box;
1590  rval = OrientedBox::compute_from_vertices( box, gMB, vertices );
1591  ASSERT( MB_SUCCESS == rval );
1592 
1593  for( int i = 0; i < num_vertex; ++i )
1594  {
1595  ASSERT( box.contained( CartVect( vertex_coords[3 * i] ), 1e-6 ) );
1596  }
1597 
1598  // define a set of points otside of the box to test
1599  double center[3] = { 0.5 * ( max[0] + min[0] ), 0.5 * ( max[1] + min[1] ), 0.5 * ( max[2] + min[2] ) };
1600  double diag[3] = { max[0] - min[0], max[1] - min[1], max[2] - min[2] };
1601  double outside1[3] = { center[0] + diag[0], center[1] + diag[1], center[2] + diag[2] };
1602  double outside2[3] = { center[0] + diag[0], center[1] + diag[1], center[2] };
1603  double outside3[3] = { center[0] + diag[0], center[1], center[2] };
1604  double* outside[3] = { outside1, outside2, outside3 };
1605  // test 'contained' method for all points
1606  for( int i = 0; i < 3; ++i )
1607  {
1608  ASSERT( !box.contained( CartVect( outside[i] ), 1e-6 ) );
1609  }
1610 }

References ASSERT, box(), center(), moab::OrientedBox::compute_from_vertices(), moab::Interface::create_vertex(), ErrorCode, gMB, moab::Range::insert(), MB_SUCCESS, and vertex_coords().

Referenced by main().

◆ test_build_from_tri()

void test_build_from_tri ( )
static
Test:
Construct OBB Box from triangles
  • Check building OBB box from triangles

Definition at line 1483 of file oriented_box_test.cpp.

1484 {
1485  ErrorCode rval;
1486  Core moab;
1487  int i;
1488 
1489  // define a planar patch of triangles
1490  const double coords[] = { 0, 0, 0, 5, 0, 0, 5, 5, 0, 0, 5, 0, -5, 5, 0, -5, 0, 0, -5, -5, 0,
1491  0, -5, 0, 5, -5, 0, 10, 0, 0, 8, 5, 0, 5, 8, 0, 0, 10, 0, -5, 8, 0,
1492  -8, 5, 0, -10, 0, 0, -8, -5, 0, -5, -8, 0, 0, -10, 0, 5, -8, 0, 8, -5, 0 };
1493  const int conn[] = { 3, 12, 13, 3, 11, 12, 4, 13, 14, 4, 3, 13, 3, 2, 11, 2, 10, 11,
1494 
1495  5, 14, 15, 5, 4, 14, 3, 4, 5, 0, 3, 5, 0, 1, 3, 1, 2, 3, 2, 1, 10, 1, 9, 10,
1496 
1497  5, 15, 16, 6, 5, 16, 5, 6, 7, 0, 5, 7, 1, 0, 7, 1, 7, 8, 1, 8, 20, 9, 1, 20,
1498 
1499  6, 16, 17, 7, 6, 17, 7, 17, 18, 7, 18, 19, 8, 7, 19, 8, 19, 20 };
1500 
1501  // build triangle mesh
1502  std::vector< EntityHandle > vertices( 21 );
1503  for( i = 0; i < 21; ++i )
1504  {
1505  rval = moab.create_vertex( coords + 3 * i, vertices[i] );
1506  ASSERT( MB_SUCCESS == rval );
1507  }
1508  Range tris;
1509  for( i = 0; i < 28; ++i )
1510  {
1511  EntityHandle tri;
1512  EntityHandle c[3] = { vertices[conn[3 * i]], vertices[conn[3 * i + 1]], vertices[conn[3 * i + 2]] };
1513  rval = moab.create_element( MBTRI, c, 3, tri );
1514  ASSERT( MB_SUCCESS == rval );
1515  tris.insert( tri );
1516  }
1517 
1518  // create box from triangles
1519  OrientedBox box;
1520  rval = OrientedBox::compute_from_2d_cells( box, &moab, tris );
1521  ASSERT( MB_SUCCESS == rval );
1522 
1523  // compute range along each box axis for input vertices
1524  const Matrix3 axis( box.scaled_axis( 0 ), box.scaled_axis( 1 ), box.scaled_axis( 2 ), false );
1525  double min[3], max[3];
1526  CartVect v = CartVect( coords ) - box.center;
1527  min[0] = max[0] = box.scaled_axis( 0 ) % v;
1528  min[1] = max[1] = box.scaled_axis( 1 ) % v;
1529  min[2] = max[2] = box.scaled_axis( 2 ) % v;
1530  for( i = 1; i < 21; ++i )
1531  {
1532  CartVect vi( coords + 3 * i );
1533  CartVect vLocal = vi - box.center;
1534  for( int j = 0; j < 3; ++j )
1535  {
1536  double d = ( axis.col( j ) % vLocal ) / ( axis.col( j ) % axis.col( j ) );
1537  if( d < min[j] ) min[j] = d;
1538  if( d > max[j] ) max[j] = d;
1539  }
1540  }
1541 
1542  // Vrify that all points are contained in box
1543  // and that box fits points tightly.
1544  // Triangles line in xy plane, so assuming axes are
1545  // sorted by length, first axis should be zero.
1546  ASSERT_DOUBLES_EQUAL( min[1], -1 );
1547  ASSERT_DOUBLES_EQUAL( min[2], -1 );
1548  ASSERT_DOUBLES_EQUAL( max[1], 1 );
1549  ASSERT_DOUBLES_EQUAL( max[2], 1 );
1550 
1551  // verify that the box is flat along first axis
1552  ASSERT( box.dimensions()[0] <= TOL );
1553  // verify that other two axes are in XY plane
1554  const CartVect z_axis( 0.0, 0.0, 1.0 );
1555  ASSERT( fabs( box.axis( 1 ) % z_axis ) <= TOL );
1556  ASSERT( fabs( box.axis( 2 ) % z_axis ) <= TOL );
1557 }

References ASSERT, ASSERT_DOUBLES_EQUAL, box(), moab::Matrix3::col(), moab::OrientedBox::compute_from_2d_cells(), ErrorCode, moab::Range::insert(), MB_SUCCESS, MBTRI, and TOL.

Referenced by main().

◆ test_closest_point()

static void test_closest_point ( )
static

Definition at line 409 of file oriented_box_test.cpp.

410 {
411  CartVect result;
412 
413  // start with unit box
414 
415  // test locations inside box
416  unitbox.closest_location_in_box( unitbox.center, result );
417  ASSERT_VECTORS_EQUAL( result, unitbox.center );
418  double f = 0.5;
419  unitbox.closest_location_in_box( scaled_corner( unitbox, 0, f ), result );
420  ASSERT_VECTORS_EQUAL( result, scaled_corner( unitbox, 0, f ) );
421  unitbox.closest_location_in_box( scaled_corner( unitbox, 1, f ), result );
422  ASSERT_VECTORS_EQUAL( result, scaled_corner( unitbox, 1, f ) );
423  unitbox.closest_location_in_box( scaled_corner( unitbox, 2, f ), result );
424  ASSERT_VECTORS_EQUAL( result, scaled_corner( unitbox, 2, f ) );
425  unitbox.closest_location_in_box( scaled_corner( unitbox, 3, f ), result );
426  ASSERT_VECTORS_EQUAL( result, scaled_corner( unitbox, 3, f ) );
427  unitbox.closest_location_in_box( scaled_corner( unitbox, 4, f ), result );
428  ASSERT_VECTORS_EQUAL( result, scaled_corner( unitbox, 4, f ) );
429  unitbox.closest_location_in_box( scaled_corner( unitbox, 5, f ), result );
430  ASSERT_VECTORS_EQUAL( result, scaled_corner( unitbox, 5, f ) );
431  unitbox.closest_location_in_box( scaled_corner( unitbox, 6, f ), result );
432  ASSERT_VECTORS_EQUAL( result, scaled_corner( unitbox, 6, f ) );
433  unitbox.closest_location_in_box( scaled_corner( unitbox, 7, f ), result );
434  ASSERT_VECTORS_EQUAL( result, scaled_corner( unitbox, 7, f ) );
435 
436  // test each corner
437  f = 1.0;
438  unitbox.closest_location_in_box( scaled_corner( unitbox, 0, f ), result );
439  ASSERT_VECTORS_EQUAL( result, scaled_corner( unitbox, 0, f ) );
440  unitbox.closest_location_in_box( scaled_corner( unitbox, 1, f ), result );
441  ASSERT_VECTORS_EQUAL( result, scaled_corner( unitbox, 1, f ) );
442  unitbox.closest_location_in_box( scaled_corner( unitbox, 2, f ), result );
443  ASSERT_VECTORS_EQUAL( result, scaled_corner( unitbox, 2, f ) );
444  unitbox.closest_location_in_box( scaled_corner( unitbox, 3, f ), result );
445  ASSERT_VECTORS_EQUAL( result, scaled_corner( unitbox, 3, f ) );
446  unitbox.closest_location_in_box( scaled_corner( unitbox, 4, f ), result );
447  ASSERT_VECTORS_EQUAL( result, scaled_corner( unitbox, 4, f ) );
448  unitbox.closest_location_in_box( scaled_corner( unitbox, 5, f ), result );
449  ASSERT_VECTORS_EQUAL( result, scaled_corner( unitbox, 5, f ) );
450  unitbox.closest_location_in_box( scaled_corner( unitbox, 6, f ), result );
451  ASSERT_VECTORS_EQUAL( result, scaled_corner( unitbox, 6, f ) );
452  unitbox.closest_location_in_box( scaled_corner( unitbox, 7, f ), result );
453  ASSERT_VECTORS_EQUAL( result, scaled_corner( unitbox, 7, f ) );
454 
455  // test outside each corner
456  f = 1.5;
457  unitbox.closest_location_in_box( scaled_corner( unitbox, 0, f ), result );
458  ASSERT_VECTORS_EQUAL( result, scaled_corner( unitbox, 0, 1 ) );
459  unitbox.closest_location_in_box( scaled_corner( unitbox, 1, f ), result );
460  ASSERT_VECTORS_EQUAL( result, scaled_corner( unitbox, 1, 1 ) );
461  unitbox.closest_location_in_box( scaled_corner( unitbox, 2, f ), result );
462  ASSERT_VECTORS_EQUAL( result, scaled_corner( unitbox, 2, 1 ) );
463  unitbox.closest_location_in_box( scaled_corner( unitbox, 3, f ), result );
464  ASSERT_VECTORS_EQUAL( result, scaled_corner( unitbox, 3, 1 ) );
465  unitbox.closest_location_in_box( scaled_corner( unitbox, 4, f ), result );
466  ASSERT_VECTORS_EQUAL( result, scaled_corner( unitbox, 4, 1 ) );
467  unitbox.closest_location_in_box( scaled_corner( unitbox, 5, f ), result );
468  ASSERT_VECTORS_EQUAL( result, scaled_corner( unitbox, 5, 1 ) );
469  unitbox.closest_location_in_box( scaled_corner( unitbox, 6, f ), result );
470  ASSERT_VECTORS_EQUAL( result, scaled_corner( unitbox, 6, 1 ) );
471  unitbox.closest_location_in_box( scaled_corner( unitbox, 7, f ), result );
472  ASSERT_VECTORS_EQUAL( result, scaled_corner( unitbox, 7, 1 ) );
473 
474  // test on each face
475  f = 1.0;
476  unitbox.closest_location_in_box( scaled_face( unitbox, 0, f ), result );
477  ASSERT_VECTORS_EQUAL( result, scaled_face( unitbox, 0, f ) );
478  unitbox.closest_location_in_box( scaled_face( unitbox, 1, f ), result );
479  ASSERT_VECTORS_EQUAL( result, scaled_face( unitbox, 1, f ) );
480  unitbox.closest_location_in_box( scaled_face( unitbox, 2, f ), result );
481  ASSERT_VECTORS_EQUAL( result, scaled_face( unitbox, 2, f ) );
482  unitbox.closest_location_in_box( scaled_face( unitbox, 3, f ), result );
483  ASSERT_VECTORS_EQUAL( result, scaled_face( unitbox, 3, f ) );
484  unitbox.closest_location_in_box( scaled_face( unitbox, 4, f ), result );
485  ASSERT_VECTORS_EQUAL( result, scaled_face( unitbox, 4, f ) );
486  unitbox.closest_location_in_box( scaled_face( unitbox, 5, f ), result );
487  ASSERT_VECTORS_EQUAL( result, scaled_face( unitbox, 5, f ) );
488 
489  // test outside each face
490  f = 1.5;
491  unitbox.closest_location_in_box( scaled_face( unitbox, 0, f ), result );
492  ASSERT_VECTORS_EQUAL( result, scaled_face( unitbox, 0, 1 ) );
493  unitbox.closest_location_in_box( scaled_face( unitbox, 1, f ), result );
494  ASSERT_VECTORS_EQUAL( result, scaled_face( unitbox, 1, 1 ) );
495  unitbox.closest_location_in_box( scaled_face( unitbox, 2, f ), result );
496  ASSERT_VECTORS_EQUAL( result, scaled_face( unitbox, 2, 1 ) );
497  unitbox.closest_location_in_box( scaled_face( unitbox, 3, f ), result );
498  ASSERT_VECTORS_EQUAL( result, scaled_face( unitbox, 3, 1 ) );
499  unitbox.closest_location_in_box( scaled_face( unitbox, 4, f ), result );
500  ASSERT_VECTORS_EQUAL( result, scaled_face( unitbox, 4, 1 ) );
501  unitbox.closest_location_in_box( scaled_face( unitbox, 5, f ), result );
502  ASSERT_VECTORS_EQUAL( result, scaled_face( unitbox, 5, 1 ) );
503 
504  // next offset box
505 
506  // test locations inside box
507  offsetbox.closest_location_in_box( offsetbox.center, result );
508  ASSERT_VECTORS_EQUAL( result, offsetbox.center );
509  f = 0.5;
510  offsetbox.closest_location_in_box( scaled_corner( offsetbox, 0, f ), result );
511  ASSERT_VECTORS_EQUAL( result, scaled_corner( offsetbox, 0, f ) );
512  offsetbox.closest_location_in_box( scaled_corner( offsetbox, 1, f ), result );
513  ASSERT_VECTORS_EQUAL( result, scaled_corner( offsetbox, 1, f ) );
514  offsetbox.closest_location_in_box( scaled_corner( offsetbox, 2, f ), result );
515  ASSERT_VECTORS_EQUAL( result, scaled_corner( offsetbox, 2, f ) );
516  offsetbox.closest_location_in_box( scaled_corner( offsetbox, 3, f ), result );
517  ASSERT_VECTORS_EQUAL( result, scaled_corner( offsetbox, 3, f ) );
518  offsetbox.closest_location_in_box( scaled_corner( offsetbox, 4, f ), result );
519  ASSERT_VECTORS_EQUAL( result, scaled_corner( offsetbox, 4, f ) );
520  offsetbox.closest_location_in_box( scaled_corner( offsetbox, 5, f ), result );
521  ASSERT_VECTORS_EQUAL( result, scaled_corner( offsetbox, 5, f ) );
522  offsetbox.closest_location_in_box( scaled_corner( offsetbox, 6, f ), result );
523  ASSERT_VECTORS_EQUAL( result, scaled_corner( offsetbox, 6, f ) );
524  offsetbox.closest_location_in_box( scaled_corner( offsetbox, 7, f ), result );
525  ASSERT_VECTORS_EQUAL( result, scaled_corner( offsetbox, 7, f ) );
526 
527  // test each corner
528  f = 1.0;
529  offsetbox.closest_location_in_box( scaled_corner( offsetbox, 0, f ), result );
530  ASSERT_VECTORS_EQUAL( result, scaled_corner( offsetbox, 0, f ) );
531  offsetbox.closest_location_in_box( scaled_corner( offsetbox, 1, f ), result );
532  ASSERT_VECTORS_EQUAL( result, scaled_corner( offsetbox, 1, f ) );
533  offsetbox.closest_location_in_box( scaled_corner( offsetbox, 2, f ), result );
534  ASSERT_VECTORS_EQUAL( result, scaled_corner( offsetbox, 2, f ) );
535  offsetbox.closest_location_in_box( scaled_corner( offsetbox, 3, f ), result );
536  ASSERT_VECTORS_EQUAL( result, scaled_corner( offsetbox, 3, f ) );
537  offsetbox.closest_location_in_box( scaled_corner( offsetbox, 4, f ), result );
538  ASSERT_VECTORS_EQUAL( result, scaled_corner( offsetbox, 4, f ) );
539  offsetbox.closest_location_in_box( scaled_corner( offsetbox, 5, f ), result );
540  ASSERT_VECTORS_EQUAL( result, scaled_corner( offsetbox, 5, f ) );
541  offsetbox.closest_location_in_box( scaled_corner( offsetbox, 6, f ), result );
542  ASSERT_VECTORS_EQUAL( result, scaled_corner( offsetbox, 6, f ) );
543  offsetbox.closest_location_in_box( scaled_corner( offsetbox, 7, f ), result );
544  ASSERT_VECTORS_EQUAL( result, scaled_corner( offsetbox, 7, f ) );
545 
546  // test outside each corner
547  f = 1.5;
548  offsetbox.closest_location_in_box( scaled_corner( offsetbox, 0, f ), result );
549  ASSERT_VECTORS_EQUAL( result, scaled_corner( offsetbox, 0, 1 ) );
550  offsetbox.closest_location_in_box( scaled_corner( offsetbox, 1, f ), result );
551  ASSERT_VECTORS_EQUAL( result, scaled_corner( offsetbox, 1, 1 ) );
552  offsetbox.closest_location_in_box( scaled_corner( offsetbox, 2, f ), result );
553  ASSERT_VECTORS_EQUAL( result, scaled_corner( offsetbox, 2, 1 ) );
554  offsetbox.closest_location_in_box( scaled_corner( offsetbox, 3, f ), result );
555  ASSERT_VECTORS_EQUAL( result, scaled_corner( offsetbox, 3, 1 ) );
556  offsetbox.closest_location_in_box( scaled_corner( offsetbox, 4, f ), result );
557  ASSERT_VECTORS_EQUAL( result, scaled_corner( offsetbox, 4, 1 ) );
558  offsetbox.closest_location_in_box( scaled_corner( offsetbox, 5, f ), result );
559  ASSERT_VECTORS_EQUAL( result, scaled_corner( offsetbox, 5, 1 ) );
560  offsetbox.closest_location_in_box( scaled_corner( offsetbox, 6, f ), result );
561  ASSERT_VECTORS_EQUAL( result, scaled_corner( offsetbox, 6, 1 ) );
562  offsetbox.closest_location_in_box( scaled_corner( offsetbox, 7, f ), result );
563  ASSERT_VECTORS_EQUAL( result, scaled_corner( offsetbox, 7, 1 ) );
564 
565  // test on each face
566  f = 1.0;
567  offsetbox.closest_location_in_box( scaled_face( offsetbox, 0, f ), result );
568  ASSERT_VECTORS_EQUAL( result, scaled_face( offsetbox, 0, f ) );
569  offsetbox.closest_location_in_box( scaled_face( offsetbox, 1, f ), result );
570  ASSERT_VECTORS_EQUAL( result, scaled_face( offsetbox, 1, f ) );
571  offsetbox.closest_location_in_box( scaled_face( offsetbox, 2, f ), result );
572  ASSERT_VECTORS_EQUAL( result, scaled_face( offsetbox, 2, f ) );
573  offsetbox.closest_location_in_box( scaled_face( offsetbox, 3, f ), result );
574  ASSERT_VECTORS_EQUAL( result, scaled_face( offsetbox, 3, f ) );
575  offsetbox.closest_location_in_box( scaled_face( offsetbox, 4, f ), result );
576  ASSERT_VECTORS_EQUAL( result, scaled_face( offsetbox, 4, f ) );
577  offsetbox.closest_location_in_box( scaled_face( offsetbox, 5, f ), result );
578  ASSERT_VECTORS_EQUAL( result, scaled_face( offsetbox, 5, f ) );
579 
580  // test outside each face
581  f = 1.5;
582  offsetbox.closest_location_in_box( scaled_face( offsetbox, 0, f ), result );
583  ASSERT_VECTORS_EQUAL( result, scaled_face( offsetbox, 0, 1 ) );
584  offsetbox.closest_location_in_box( scaled_face( offsetbox, 1, f ), result );
585  ASSERT_VECTORS_EQUAL( result, scaled_face( offsetbox, 1, 1 ) );
586  offsetbox.closest_location_in_box( scaled_face( offsetbox, 2, f ), result );
587  ASSERT_VECTORS_EQUAL( result, scaled_face( offsetbox, 2, 1 ) );
588  offsetbox.closest_location_in_box( scaled_face( offsetbox, 3, f ), result );
589  ASSERT_VECTORS_EQUAL( result, scaled_face( offsetbox, 3, 1 ) );
590  offsetbox.closest_location_in_box( scaled_face( offsetbox, 4, f ), result );
591  ASSERT_VECTORS_EQUAL( result, scaled_face( offsetbox, 4, 1 ) );
592  offsetbox.closest_location_in_box( scaled_face( offsetbox, 5, f ), result );
593  ASSERT_VECTORS_EQUAL( result, scaled_face( offsetbox, 5, 1 ) );
594 
595  // next oblong box
596 
597  // test locations inside box
598  oblongbox.closest_location_in_box( oblongbox.center, result );
599  ASSERT_VECTORS_EQUAL( result, oblongbox.center );
600  f = 0.5;
601  oblongbox.closest_location_in_box( scaled_corner( oblongbox, 0, f ), result );
602  ASSERT_VECTORS_EQUAL( result, scaled_corner( oblongbox, 0, f ) );
603  oblongbox.closest_location_in_box( scaled_corner( oblongbox, 1, f ), result );
604  ASSERT_VECTORS_EQUAL( result, scaled_corner( oblongbox, 1, f ) );
605  oblongbox.closest_location_in_box( scaled_corner( oblongbox, 2, f ), result );
606  ASSERT_VECTORS_EQUAL( result, scaled_corner( oblongbox, 2, f ) );
607  oblongbox.closest_location_in_box( scaled_corner( oblongbox, 3, f ), result );
608  ASSERT_VECTORS_EQUAL( result, scaled_corner( oblongbox, 3, f ) );
609  oblongbox.closest_location_in_box( scaled_corner( oblongbox, 4, f ), result );
610  ASSERT_VECTORS_EQUAL( result, scaled_corner( oblongbox, 4, f ) );
611  oblongbox.closest_location_in_box( scaled_corner( oblongbox, 5, f ), result );
612  ASSERT_VECTORS_EQUAL( result, scaled_corner( oblongbox, 5, f ) );
613  oblongbox.closest_location_in_box( scaled_corner( oblongbox, 6, f ), result );
614  ASSERT_VECTORS_EQUAL( result, scaled_corner( oblongbox, 6, f ) );
615  oblongbox.closest_location_in_box( scaled_corner( oblongbox, 7, f ), result );
616  ASSERT_VECTORS_EQUAL( result, scaled_corner( oblongbox, 7, f ) );
617 
618  // test each corner
619  f = 1.0;
620  oblongbox.closest_location_in_box( scaled_corner( oblongbox, 0, f ), result );
621  ASSERT_VECTORS_EQUAL( result, scaled_corner( oblongbox, 0, f ) );
622  oblongbox.closest_location_in_box( scaled_corner( oblongbox, 1, f ), result );
623  ASSERT_VECTORS_EQUAL( result, scaled_corner( oblongbox, 1, f ) );
624  oblongbox.closest_location_in_box( scaled_corner( oblongbox, 2, f ), result );
625  ASSERT_VECTORS_EQUAL( result, scaled_corner( oblongbox, 2, f ) );
626  oblongbox.closest_location_in_box( scaled_corner( oblongbox, 3, f ), result );
627  ASSERT_VECTORS_EQUAL( result, scaled_corner( oblongbox, 3, f ) );
628  oblongbox.closest_location_in_box( scaled_corner( oblongbox, 4, f ), result );
629  ASSERT_VECTORS_EQUAL( result, scaled_corner( oblongbox, 4, f ) );
630  oblongbox.closest_location_in_box( scaled_corner( oblongbox, 5, f ), result );
631  ASSERT_VECTORS_EQUAL( result, scaled_corner( oblongbox, 5, f ) );
632  oblongbox.closest_location_in_box( scaled_corner( oblongbox, 6, f ), result );
633  ASSERT_VECTORS_EQUAL( result, scaled_corner( oblongbox, 6, f ) );
634  oblongbox.closest_location_in_box( scaled_corner( oblongbox, 7, f ), result );
635  ASSERT_VECTORS_EQUAL( result, scaled_corner( oblongbox, 7, f ) );
636 
637  // test outside each corner
638  f = 1.5;
639  oblongbox.closest_location_in_box( scaled_corner( oblongbox, 0, f ), result );
640  ASSERT_VECTORS_EQUAL( result, scaled_corner( oblongbox, 0, 1 ) );
641  oblongbox.closest_location_in_box( scaled_corner( oblongbox, 1, f ), result );
642  ASSERT_VECTORS_EQUAL( result, scaled_corner( oblongbox, 1, 1 ) );
643  oblongbox.closest_location_in_box( scaled_corner( oblongbox, 2, f ), result );
644  ASSERT_VECTORS_EQUAL( result, scaled_corner( oblongbox, 2, 1 ) );
645  oblongbox.closest_location_in_box( scaled_corner( oblongbox, 3, f ), result );
646  ASSERT_VECTORS_EQUAL( result, scaled_corner( oblongbox, 3, 1 ) );
647  oblongbox.closest_location_in_box( scaled_corner( oblongbox, 4, f ), result );
648  ASSERT_VECTORS_EQUAL( result, scaled_corner( oblongbox, 4, 1 ) );
649  oblongbox.closest_location_in_box( scaled_corner( oblongbox, 5, f ), result );
650  ASSERT_VECTORS_EQUAL( result, scaled_corner( oblongbox, 5, 1 ) );
651  oblongbox.closest_location_in_box( scaled_corner( oblongbox, 6, f ), result );
652  ASSERT_VECTORS_EQUAL( result, scaled_corner( oblongbox, 6, 1 ) );
653  oblongbox.closest_location_in_box( scaled_corner( oblongbox, 7, f ), result );
654  ASSERT_VECTORS_EQUAL( result, scaled_corner( oblongbox, 7, 1 ) );
655 
656  // test on each face
657  f = 1.0;
658  oblongbox.closest_location_in_box( scaled_face( oblongbox, 0, f ), result );
659  ASSERT_VECTORS_EQUAL( result, scaled_face( oblongbox, 0, f ) );
660  oblongbox.closest_location_in_box( scaled_face( oblongbox, 1, f ), result );
661  ASSERT_VECTORS_EQUAL( result, scaled_face( oblongbox, 1, f ) );
662  oblongbox.closest_location_in_box( scaled_face( oblongbox, 2, f ), result );
663  ASSERT_VECTORS_EQUAL( result, scaled_face( oblongbox, 2, f ) );
664  oblongbox.closest_location_in_box( scaled_face( oblongbox, 3, f ), result );
665  ASSERT_VECTORS_EQUAL( result, scaled_face( oblongbox, 3, f ) );
666  oblongbox.closest_location_in_box( scaled_face( oblongbox, 4, f ), result );
667  ASSERT_VECTORS_EQUAL( result, scaled_face( oblongbox, 4, f ) );
668  oblongbox.closest_location_in_box( scaled_face( oblongbox, 5, f ), result );
669  ASSERT_VECTORS_EQUAL( result, scaled_face( oblongbox, 5, f ) );
670 
671  // test outside each face
672  f = 1.5;
673  oblongbox.closest_location_in_box( scaled_face( oblongbox, 0, f ), result );
674  ASSERT_VECTORS_EQUAL( result, scaled_face( oblongbox, 0, 1 ) );
675  oblongbox.closest_location_in_box( scaled_face( oblongbox, 1, f ), result );
676  ASSERT_VECTORS_EQUAL( result, scaled_face( oblongbox, 1, 1 ) );
677  oblongbox.closest_location_in_box( scaled_face( oblongbox, 2, f ), result );
678  ASSERT_VECTORS_EQUAL( result, scaled_face( oblongbox, 2, 1 ) );
679  oblongbox.closest_location_in_box( scaled_face( oblongbox, 3, f ), result );
680  ASSERT_VECTORS_EQUAL( result, scaled_face( oblongbox, 3, 1 ) );
681  oblongbox.closest_location_in_box( scaled_face( oblongbox, 4, f ), result );
682  ASSERT_VECTORS_EQUAL( result, scaled_face( oblongbox, 4, 1 ) );
683  oblongbox.closest_location_in_box( scaled_face( oblongbox, 5, f ), result );
684  ASSERT_VECTORS_EQUAL( result, scaled_face( oblongbox, 5, 1 ) );
685 
686  // next rotated box
687 
688  // test locations inside box
689  rotbox.closest_location_in_box( rotbox.center, result );
690  ASSERT_VECTORS_EQUAL( result, rotbox.center );
691  f = 0.5;
692  rotbox.closest_location_in_box( scaled_corner( rotbox, 0, f ), result );
693  ASSERT_VECTORS_EQUAL( result, scaled_corner( rotbox, 0, f ) );
694  rotbox.closest_location_in_box( scaled_corner( rotbox, 1, f ), result );
695  ASSERT_VECTORS_EQUAL( result, scaled_corner( rotbox, 1, f ) );
696  rotbox.closest_location_in_box( scaled_corner( rotbox, 2, f ), result );
697  ASSERT_VECTORS_EQUAL( result, scaled_corner( rotbox, 2, f ) );
698  rotbox.closest_location_in_box( scaled_corner( rotbox, 3, f ), result );
699  ASSERT_VECTORS_EQUAL( result, scaled_corner( rotbox, 3, f ) );
700  rotbox.closest_location_in_box( scaled_corner( rotbox, 4, f ), result );
701  ASSERT_VECTORS_EQUAL( result, scaled_corner( rotbox, 4, f ) );
702  rotbox.closest_location_in_box( scaled_corner( rotbox, 5, f ), result );
703  ASSERT_VECTORS_EQUAL( result, scaled_corner( rotbox, 5, f ) );
704  rotbox.closest_location_in_box( scaled_corner( rotbox, 6, f ), result );
705  ASSERT_VECTORS_EQUAL( result, scaled_corner( rotbox, 6, f ) );
706  rotbox.closest_location_in_box( scaled_corner( rotbox, 7, f ), result );
707  ASSERT_VECTORS_EQUAL( result, scaled_corner( rotbox, 7, f ) );
708 
709  // test each corner
710  f = 1.0;
711  rotbox.closest_location_in_box( scaled_corner( rotbox, 0, f ), result );
712  ASSERT_VECTORS_EQUAL( result, scaled_corner( rotbox, 0, f ) );
713  rotbox.closest_location_in_box( scaled_corner( rotbox, 1, f ), result );
714  ASSERT_VECTORS_EQUAL( result, scaled_corner( rotbox, 1, f ) );
715  rotbox.closest_location_in_box( scaled_corner( rotbox, 2, f ), result );
716  ASSERT_VECTORS_EQUAL( result, scaled_corner( rotbox, 2, f ) );
717  rotbox.closest_location_in_box( scaled_corner( rotbox, 3, f ), result );
718  ASSERT_VECTORS_EQUAL( result, scaled_corner( rotbox, 3, f ) );
719  rotbox.closest_location_in_box( scaled_corner( rotbox, 4, f ), result );
720  ASSERT_VECTORS_EQUAL( result, scaled_corner( rotbox, 4, f ) );
721  rotbox.closest_location_in_box( scaled_corner( rotbox, 5, f ), result );
722  ASSERT_VECTORS_EQUAL( result, scaled_corner( rotbox, 5, f ) );
723  rotbox.closest_location_in_box( scaled_corner( rotbox, 6, f ), result );
724  ASSERT_VECTORS_EQUAL( result, scaled_corner( rotbox, 6, f ) );
725  rotbox.closest_location_in_box( scaled_corner( rotbox, 7, f ), result );
726  ASSERT_VECTORS_EQUAL( result, scaled_corner( rotbox, 7, f ) );
727 
728  // test outside each corner
729  f = 1.5;
730  rotbox.closest_location_in_box( scaled_corner( rotbox, 0, f ), result );
731  ASSERT_VECTORS_EQUAL( result, scaled_corner( rotbox, 0, 1 ) );
732  rotbox.closest_location_in_box( scaled_corner( rotbox, 1, f ), result );
733  ASSERT_VECTORS_EQUAL( result, scaled_corner( rotbox, 1, 1 ) );
734  rotbox.closest_location_in_box( scaled_corner( rotbox, 2, f ), result );
735  ASSERT_VECTORS_EQUAL( result, scaled_corner( rotbox, 2, 1 ) );
736  rotbox.closest_location_in_box( scaled_corner( rotbox, 3, f ), result );
737  ASSERT_VECTORS_EQUAL( result, scaled_corner( rotbox, 3, 1 ) );
738  rotbox.closest_location_in_box( scaled_corner( rotbox, 4, f ), result );
739  ASSERT_VECTORS_EQUAL( result, scaled_corner( rotbox, 4, 1 ) );
740  rotbox.closest_location_in_box( scaled_corner( rotbox, 5, f ), result );
741  ASSERT_VECTORS_EQUAL( result, scaled_corner( rotbox, 5, 1 ) );
742  rotbox.closest_location_in_box( scaled_corner( rotbox, 6, f ), result );
743  ASSERT_VECTORS_EQUAL( result, scaled_corner( rotbox, 6, 1 ) );
744  rotbox.closest_location_in_box( scaled_corner( rotbox, 7, f ), result );
745  ASSERT_VECTORS_EQUAL( result, scaled_corner( rotbox, 7, 1 ) );
746 
747  // test on each face
748  f = 1.0;
749  rotbox.closest_location_in_box( scaled_face( rotbox, 0, f ), result );
750  ASSERT_VECTORS_EQUAL( result, scaled_face( rotbox, 0, f ) );
751  rotbox.closest_location_in_box( scaled_face( rotbox, 1, f ), result );
752  ASSERT_VECTORS_EQUAL( result, scaled_face( rotbox, 1, f ) );
753  rotbox.closest_location_in_box( scaled_face( rotbox, 2, f ), result );
754  ASSERT_VECTORS_EQUAL( result, scaled_face( rotbox, 2, f ) );
755  rotbox.closest_location_in_box( scaled_face( rotbox, 3, f ), result );
756  ASSERT_VECTORS_EQUAL( result, scaled_face( rotbox, 3, f ) );
757  rotbox.closest_location_in_box( scaled_face( rotbox, 4, f ), result );
758  ASSERT_VECTORS_EQUAL( result, scaled_face( rotbox, 4, f ) );
759  rotbox.closest_location_in_box( scaled_face( rotbox, 5, f ), result );
760  ASSERT_VECTORS_EQUAL( result, scaled_face( rotbox, 5, f ) );
761 
762  // test outside each face
763  f = 1.5;
764  rotbox.closest_location_in_box( scaled_face( rotbox, 0, f ), result );
765  ASSERT_VECTORS_EQUAL( result, scaled_face( rotbox, 0, 1 ) );
766  rotbox.closest_location_in_box( scaled_face( rotbox, 1, f ), result );
767  ASSERT_VECTORS_EQUAL( result, scaled_face( rotbox, 1, 1 ) );
768  rotbox.closest_location_in_box( scaled_face( rotbox, 2, f ), result );
769  ASSERT_VECTORS_EQUAL( result, scaled_face( rotbox, 2, 1 ) );
770  rotbox.closest_location_in_box( scaled_face( rotbox, 3, f ), result );
771  ASSERT_VECTORS_EQUAL( result, scaled_face( rotbox, 3, 1 ) );
772  rotbox.closest_location_in_box( scaled_face( rotbox, 4, f ), result );
773  ASSERT_VECTORS_EQUAL( result, scaled_face( rotbox, 4, 1 ) );
774  rotbox.closest_location_in_box( scaled_face( rotbox, 5, f ), result );
775  ASSERT_VECTORS_EQUAL( result, scaled_face( rotbox, 5, 1 ) );
776 }

References ASSERT_VECTORS_EQUAL, moab::OrientedBox::center, moab::OrientedBox::closest_location_in_box(), oblongbox, offsetbox, rotbox, scaled_corner(), scaled_face(), and unitbox.

Referenced by main().

◆ test_contained()

static void test_contained ( )
static

Definition at line 160 of file oriented_box_test.cpp.

161 {
162  // first do tests of unit box
163 
164  // test points inside box
165  ASSERT( unitbox.contained( unitbox.center, TOL ) );
166  ASSERT( unitbox.contained( scaled_corner( unitbox, 0, 0.6 ), TOL ) );
167  ASSERT( unitbox.contained( scaled_corner( unitbox, 1, 0.6 ), TOL ) );
168  ASSERT( unitbox.contained( scaled_corner( unitbox, 2, 0.6 ), TOL ) );
169  ASSERT( unitbox.contained( scaled_corner( unitbox, 3, 0.6 ), TOL ) );
170  ASSERT( unitbox.contained( scaled_corner( unitbox, 4, 0.6 ), TOL ) );
171  ASSERT( unitbox.contained( scaled_corner( unitbox, 5, 0.6 ), TOL ) );
172  ASSERT( unitbox.contained( scaled_corner( unitbox, 6, 0.6 ), TOL ) );
173  ASSERT( unitbox.contained( scaled_corner( unitbox, 7, 0.6 ), TOL ) );
174 
175  // test points at box corners
176  ASSERT( unitbox.contained( scaled_corner( unitbox, 0, 1.0 ), TOL ) );
177  ASSERT( unitbox.contained( scaled_corner( unitbox, 1, 1.0 ), TOL ) );
178  ASSERT( unitbox.contained( scaled_corner( unitbox, 2, 1.0 ), TOL ) );
179  ASSERT( unitbox.contained( scaled_corner( unitbox, 3, 1.0 ), TOL ) );
180  ASSERT( unitbox.contained( scaled_corner( unitbox, 4, 1.0 ), TOL ) );
181  ASSERT( unitbox.contained( scaled_corner( unitbox, 5, 1.0 ), TOL ) );
182  ASSERT( unitbox.contained( scaled_corner( unitbox, 6, 1.0 ), TOL ) );
183  ASSERT( unitbox.contained( scaled_corner( unitbox, 7, 1.0 ), TOL ) );
184 
185  // test points at center of each face
186  ASSERT( unitbox.contained( scaled_face( unitbox, 0, 1.0 ), TOL ) );
187  ASSERT( unitbox.contained( scaled_face( unitbox, 1, 1.0 ), TOL ) );
188  ASSERT( unitbox.contained( scaled_face( unitbox, 2, 1.0 ), TOL ) );
189  ASSERT( unitbox.contained( scaled_face( unitbox, 3, 1.0 ), TOL ) );
190  ASSERT( unitbox.contained( scaled_face( unitbox, 4, 1.0 ), TOL ) );
191  ASSERT( unitbox.contained( scaled_face( unitbox, 5, 1.0 ), TOL ) );
192 
193  // test points beyond each corner
194  ASSERT( !unitbox.contained( scaled_corner( unitbox, 0, 1.2 ), TOL ) );
195  ASSERT( !unitbox.contained( scaled_corner( unitbox, 1, 1.2 ), TOL ) );
196  ASSERT( !unitbox.contained( scaled_corner( unitbox, 2, 1.2 ), TOL ) );
197  ASSERT( !unitbox.contained( scaled_corner( unitbox, 3, 1.2 ), TOL ) );
198  ASSERT( !unitbox.contained( scaled_corner( unitbox, 4, 1.2 ), TOL ) );
199  ASSERT( !unitbox.contained( scaled_corner( unitbox, 5, 1.2 ), TOL ) );
200  ASSERT( !unitbox.contained( scaled_corner( unitbox, 6, 1.2 ), TOL ) );
201  ASSERT( !unitbox.contained( scaled_corner( unitbox, 7, 1.2 ), TOL ) );
202 
203  // test points beyond the center of each face
204  ASSERT( !unitbox.contained( scaled_face( unitbox, 0, 1.3 ), TOL ) );
205  ASSERT( !unitbox.contained( scaled_face( unitbox, 1, 1.3 ), TOL ) );
206  ASSERT( !unitbox.contained( scaled_face( unitbox, 2, 1.3 ), TOL ) );
207  ASSERT( !unitbox.contained( scaled_face( unitbox, 3, 1.3 ), TOL ) );
208  ASSERT( !unitbox.contained( scaled_face( unitbox, 4, 1.3 ), TOL ) );
209  ASSERT( !unitbox.contained( scaled_face( unitbox, 5, 1.3 ), TOL ) );
210 
211  // now do offset box
212 
213  // test points inside box
214  ASSERT( offsetbox.contained( offsetbox.center, TOL ) );
215  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 0, 0.6 ), TOL ) );
216  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 1, 0.6 ), TOL ) );
217  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 2, 0.6 ), TOL ) );
218  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 3, 0.6 ), TOL ) );
219  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 4, 0.6 ), TOL ) );
220  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 5, 0.6 ), TOL ) );
221  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 6, 0.6 ), TOL ) );
222  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 7, 0.6 ), TOL ) );
223 
224  // test points at box corners
225  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 0, 1.0 ), TOL ) );
226  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 1, 1.0 ), TOL ) );
227  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 2, 1.0 ), TOL ) );
228  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 3, 1.0 ), TOL ) );
229  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 4, 1.0 ), TOL ) );
230  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 5, 1.0 ), TOL ) );
231  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 6, 1.0 ), TOL ) );
232  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 7, 1.0 ), TOL ) );
233 
234  // test points at center of each face
235  ASSERT( offsetbox.contained( scaled_face( offsetbox, 0, 1.0 ), TOL ) );
236  ASSERT( offsetbox.contained( scaled_face( offsetbox, 1, 1.0 ), TOL ) );
237  ASSERT( offsetbox.contained( scaled_face( offsetbox, 2, 1.0 ), TOL ) );
238  ASSERT( offsetbox.contained( scaled_face( offsetbox, 3, 1.0 ), TOL ) );
239  ASSERT( offsetbox.contained( scaled_face( offsetbox, 4, 1.0 ), TOL ) );
240  ASSERT( offsetbox.contained( scaled_face( offsetbox, 5, 1.0 ), TOL ) );
241 
242  // test points beyond each corner
243  ASSERT( !offsetbox.contained( scaled_corner( offsetbox, 0, 1.2 ), TOL ) );
244  ASSERT( !offsetbox.contained( scaled_corner( offsetbox, 1, 1.2 ), TOL ) );
245  ASSERT( !offsetbox.contained( scaled_corner( offsetbox, 2, 1.2 ), TOL ) );
246  ASSERT( !offsetbox.contained( scaled_corner( offsetbox, 3, 1.2 ), TOL ) );
247  ASSERT( !offsetbox.contained( scaled_corner( offsetbox, 4, 1.2 ), TOL ) );
248  ASSERT( !offsetbox.contained( scaled_corner( offsetbox, 5, 1.2 ), TOL ) );
249  ASSERT( !offsetbox.contained( scaled_corner( offsetbox, 6, 1.2 ), TOL ) );
250  ASSERT( !offsetbox.contained( scaled_corner( offsetbox, 7, 1.2 ), TOL ) );
251 
252  // test points beyond the center of each face
253  ASSERT( !offsetbox.contained( scaled_face( offsetbox, 0, 1.3 ), TOL ) );
254  ASSERT( !offsetbox.contained( scaled_face( offsetbox, 1, 1.3 ), TOL ) );
255  ASSERT( !offsetbox.contained( scaled_face( offsetbox, 2, 1.3 ), TOL ) );
256  ASSERT( !offsetbox.contained( scaled_face( offsetbox, 3, 1.3 ), TOL ) );
257  ASSERT( !offsetbox.contained( scaled_face( offsetbox, 4, 1.3 ), TOL ) );
258  ASSERT( !offsetbox.contained( scaled_face( offsetbox, 5, 1.3 ), TOL ) );
259 
260  // now do oblong box
261 
262  // test points inside box
263  ASSERT( oblongbox.contained( oblongbox.center, TOL ) );
264  ASSERT( oblongbox.contained( scaled_corner( oblongbox, 0, 0.6 ), TOL ) );
265  ASSERT( oblongbox.contained( scaled_corner( oblongbox, 1, 0.6 ), TOL ) );
266  ASSERT( oblongbox.contained( scaled_corner( oblongbox, 2, 0.6 ), TOL ) );
267  ASSERT( oblongbox.contained( scaled_corner( oblongbox, 3, 0.6 ), TOL ) );
268  ASSERT( oblongbox.contained( scaled_corner( oblongbox, 4, 0.6 ), TOL ) );
269  ASSERT( oblongbox.contained( scaled_corner( oblongbox, 5, 0.6 ), TOL ) );
270  ASSERT( oblongbox.contained( scaled_corner( oblongbox, 6, 0.6 ), TOL ) );
271  ASSERT( oblongbox.contained( scaled_corner( oblongbox, 7, 0.6 ), TOL ) );
272 
273  // test points at box corners
274  ASSERT( oblongbox.contained( scaled_corner( oblongbox, 0, 1.0 ), TOL ) );
275  ASSERT( oblongbox.contained( scaled_corner( oblongbox, 1, 1.0 ), TOL ) );
276  ASSERT( oblongbox.contained( scaled_corner( oblongbox, 2, 1.0 ), TOL ) );
277  ASSERT( oblongbox.contained( scaled_corner( oblongbox, 3, 1.0 ), TOL ) );
278  ASSERT( oblongbox.contained( scaled_corner( oblongbox, 4, 1.0 ), TOL ) );
279  ASSERT( oblongbox.contained( scaled_corner( oblongbox, 5, 1.0 ), TOL ) );
280  ASSERT( oblongbox.contained( scaled_corner( oblongbox, 6, 1.0 ), TOL ) );
281  ASSERT( oblongbox.contained( scaled_corner( oblongbox, 7, 1.0 ), TOL ) );
282 
283  // test points at center of each face
284  ASSERT( oblongbox.contained( scaled_face( oblongbox, 0, 1.0 ), TOL ) );
285  ASSERT( oblongbox.contained( scaled_face( oblongbox, 1, 1.0 ), TOL ) );
286  ASSERT( oblongbox.contained( scaled_face( oblongbox, 2, 1.0 ), TOL ) );
287  ASSERT( oblongbox.contained( scaled_face( oblongbox, 3, 1.0 ), TOL ) );
288  ASSERT( oblongbox.contained( scaled_face( oblongbox, 4, 1.0 ), TOL ) );
289  ASSERT( oblongbox.contained( scaled_face( oblongbox, 5, 1.0 ), TOL ) );
290 
291  // test points beyond each corner
292  ASSERT( !oblongbox.contained( scaled_corner( oblongbox, 0, 1.2 ), TOL ) );
293  ASSERT( !oblongbox.contained( scaled_corner( oblongbox, 1, 1.2 ), TOL ) );
294  ASSERT( !oblongbox.contained( scaled_corner( oblongbox, 2, 1.2 ), TOL ) );
295  ASSERT( !oblongbox.contained( scaled_corner( oblongbox, 3, 1.2 ), TOL ) );
296  ASSERT( !oblongbox.contained( scaled_corner( oblongbox, 4, 1.2 ), TOL ) );
297  ASSERT( !oblongbox.contained( scaled_corner( oblongbox, 5, 1.2 ), TOL ) );
298  ASSERT( !oblongbox.contained( scaled_corner( oblongbox, 6, 1.2 ), TOL ) );
299  ASSERT( !oblongbox.contained( scaled_corner( oblongbox, 7, 1.2 ), TOL ) );
300 
301  // test points beyond the center of each face
302  ASSERT( !oblongbox.contained( scaled_face( oblongbox, 0, 1.3 ), TOL ) );
303  ASSERT( !oblongbox.contained( scaled_face( oblongbox, 1, 1.3 ), TOL ) );
304  ASSERT( !oblongbox.contained( scaled_face( oblongbox, 2, 1.3 ), TOL ) );
305  ASSERT( !oblongbox.contained( scaled_face( oblongbox, 3, 1.3 ), TOL ) );
306  ASSERT( !oblongbox.contained( scaled_face( oblongbox, 4, 1.3 ), TOL ) );
307  ASSERT( !oblongbox.contained( scaled_face( oblongbox, 5, 1.3 ), TOL ) );
308 
309  // now do offset box
310 
311  // test points inside box
312  ASSERT( offsetbox.contained( offsetbox.center, TOL ) );
313  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 0, 0.6 ), TOL ) );
314  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 1, 0.6 ), TOL ) );
315  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 2, 0.6 ), TOL ) );
316  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 3, 0.6 ), TOL ) );
317  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 4, 0.6 ), TOL ) );
318  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 5, 0.6 ), TOL ) );
319  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 6, 0.6 ), TOL ) );
320  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 7, 0.6 ), TOL ) );
321 
322  // test points at box corners
323  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 0, 1.0 ), TOL ) );
324  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 1, 1.0 ), TOL ) );
325  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 2, 1.0 ), TOL ) );
326  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 3, 1.0 ), TOL ) );
327  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 4, 1.0 ), TOL ) );
328  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 5, 1.0 ), TOL ) );
329  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 6, 1.0 ), TOL ) );
330  ASSERT( offsetbox.contained( scaled_corner( offsetbox, 7, 1.0 ), TOL ) );
331 
332  // test points at center of each face
333  ASSERT( offsetbox.contained( scaled_face( offsetbox, 0, 1.0 ), TOL ) );
334  ASSERT( offsetbox.contained( scaled_face( offsetbox, 1, 1.0 ), TOL ) );
335  ASSERT( offsetbox.contained( scaled_face( offsetbox, 2, 1.0 ), TOL ) );
336  ASSERT( offsetbox.contained( scaled_face( offsetbox, 3, 1.0 ), TOL ) );
337  ASSERT( offsetbox.contained( scaled_face( offsetbox, 4, 1.0 ), TOL ) );
338  ASSERT( offsetbox.contained( scaled_face( offsetbox, 5, 1.0 ), TOL ) );
339 
340  // test points beyond each corner
341  ASSERT( !offsetbox.contained( scaled_corner( offsetbox, 0, 1.2 ), TOL ) );
342  ASSERT( !offsetbox.contained( scaled_corner( offsetbox, 1, 1.2 ), TOL ) );
343  ASSERT( !offsetbox.contained( scaled_corner( offsetbox, 2, 1.2 ), TOL ) );
344  ASSERT( !offsetbox.contained( scaled_corner( offsetbox, 3, 1.2 ), TOL ) );
345  ASSERT( !offsetbox.contained( scaled_corner( offsetbox, 4, 1.2 ), TOL ) );
346  ASSERT( !offsetbox.contained( scaled_corner( offsetbox, 5, 1.2 ), TOL ) );
347  ASSERT( !offsetbox.contained( scaled_corner( offsetbox, 6, 1.2 ), TOL ) );
348  ASSERT( !offsetbox.contained( scaled_corner( offsetbox, 7, 1.2 ), TOL ) );
349 
350  // test points beyond the center of each face
351  ASSERT( !offsetbox.contained( scaled_face( offsetbox, 0, 1.3 ), TOL ) );
352  ASSERT( !offsetbox.contained( scaled_face( offsetbox, 1, 1.3 ), TOL ) );
353  ASSERT( !offsetbox.contained( scaled_face( offsetbox, 2, 1.3 ), TOL ) );
354  ASSERT( !offsetbox.contained( scaled_face( offsetbox, 3, 1.3 ), TOL ) );
355  ASSERT( !offsetbox.contained( scaled_face( offsetbox, 4, 1.3 ), TOL ) );
356  ASSERT( !offsetbox.contained( scaled_face( offsetbox, 5, 1.3 ), TOL ) );
357 
358  // now do rotated box
359 
360  // test points inside box
361  ASSERT( rotbox.contained( rotbox.center, TOL ) );
362  ASSERT( rotbox.contained( scaled_corner( rotbox, 0, 0.6 ), TOL ) );
363  ASSERT( rotbox.contained( scaled_corner( rotbox, 1, 0.6 ), TOL ) );
364  ASSERT( rotbox.contained( scaled_corner( rotbox, 2, 0.6 ), TOL ) );
365  ASSERT( rotbox.contained( scaled_corner( rotbox, 3, 0.6 ), TOL ) );
366  ASSERT( rotbox.contained( scaled_corner( rotbox, 4, 0.6 ), TOL ) );
367  ASSERT( rotbox.contained( scaled_corner( rotbox, 5, 0.6 ), TOL ) );
368  ASSERT( rotbox.contained( scaled_corner( rotbox, 6, 0.6 ), TOL ) );
369  ASSERT( rotbox.contained( scaled_corner( rotbox, 7, 0.6 ), TOL ) );
370 
371  // test points at box corners
372  ASSERT( rotbox.contained( scaled_corner( rotbox, 0, 1.0 ), TOL ) );
373  ASSERT( rotbox.contained( scaled_corner( rotbox, 1, 1.0 ), TOL ) );
374  ASSERT( rotbox.contained( scaled_corner( rotbox, 2, 1.0 ), TOL ) );
375  ASSERT( rotbox.contained( scaled_corner( rotbox, 3, 1.0 ), TOL ) );
376  ASSERT( rotbox.contained( scaled_corner( rotbox, 4, 1.0 ), TOL ) );
377  ASSERT( rotbox.contained( scaled_corner( rotbox, 5, 1.0 ), TOL ) );
378  ASSERT( rotbox.contained( scaled_corner( rotbox, 6, 1.0 ), TOL ) );
379  ASSERT( rotbox.contained( scaled_corner( rotbox, 7, 1.0 ), TOL ) );
380 
381  // test points at center of each face
382  ASSERT( rotbox.contained( scaled_face( rotbox, 0, 1.0 ), TOL ) );
383  ASSERT( rotbox.contained( scaled_face( rotbox, 1, 1.0 ), TOL ) );
384  ASSERT( rotbox.contained( scaled_face( rotbox, 2, 1.0 ), TOL ) );
385  ASSERT( rotbox.contained( scaled_face( rotbox, 3, 1.0 ), TOL ) );
386  ASSERT( rotbox.contained( scaled_face( rotbox, 4, 1.0 ), TOL ) );
387  ASSERT( rotbox.contained( scaled_face( rotbox, 5, 1.0 ), TOL ) );
388 
389  // test points beyond each corner
390  ASSERT( !rotbox.contained( scaled_corner( rotbox, 0, 1.2 ), TOL ) );
391  ASSERT( !rotbox.contained( scaled_corner( rotbox, 1, 1.2 ), TOL ) );
392  ASSERT( !rotbox.contained( scaled_corner( rotbox, 2, 1.2 ), TOL ) );
393  ASSERT( !rotbox.contained( scaled_corner( rotbox, 3, 1.2 ), TOL ) );
394  ASSERT( !rotbox.contained( scaled_corner( rotbox, 4, 1.2 ), TOL ) );
395  ASSERT( !rotbox.contained( scaled_corner( rotbox, 5, 1.2 ), TOL ) );
396  ASSERT( !rotbox.contained( scaled_corner( rotbox, 6, 1.2 ), TOL ) );
397  ASSERT( !rotbox.contained( scaled_corner( rotbox, 7, 1.2 ), TOL ) );
398 
399  // test points beyond the center of each face
400  ASSERT( !rotbox.contained( scaled_face( rotbox, 0, 1.3 ), TOL ) );
401  ASSERT( !rotbox.contained( scaled_face( rotbox, 1, 1.3 ), TOL ) );
402  ASSERT( !rotbox.contained( scaled_face( rotbox, 2, 1.3 ), TOL ) );
403  ASSERT( !rotbox.contained( scaled_face( rotbox, 3, 1.3 ), TOL ) );
404  ASSERT( !rotbox.contained( scaled_face( rotbox, 4, 1.3 ), TOL ) );
405  ASSERT( !rotbox.contained( scaled_face( rotbox, 5, 1.3 ), TOL ) );
406 }

References ASSERT, moab::OrientedBox::center, moab::OrientedBox::contained(), oblongbox, offsetbox, rotbox, scaled_corner(), scaled_face(), TOL, and unitbox.

Referenced by main().

◆ test_ray_intersect()

void test_ray_intersect ( )
static

Definition at line 779 of file oriented_box_test.cpp.

780 {
781  CartVect dir, pt;
782 
783  // start with unit box
784 
785  // test ray from box center towards each face
786  dir = scaled_face( unitbox, 0, 1.0 ) - unitbox.center;
787  dir.normalize();
788  ASSERT( unitbox.intersect_ray( unitbox.center, dir, TOL ) );
789  dir = scaled_face( unitbox, 1, 1.0 ) - unitbox.center;
790  dir.normalize();
791  ASSERT( unitbox.intersect_ray( unitbox.center, dir, TOL ) );
792  dir = scaled_face( unitbox, 2, 1.0 ) - unitbox.center;
793  dir.normalize();
794  ASSERT( unitbox.intersect_ray( unitbox.center, dir, TOL ) );
795  dir = scaled_face( unitbox, 3, 1.0 ) - unitbox.center;
796  dir.normalize();
797  ASSERT( unitbox.intersect_ray( unitbox.center, dir, TOL ) );
798  dir = scaled_face( unitbox, 4, 1.0 ) - unitbox.center;
799  dir.normalize();
800  ASSERT( unitbox.intersect_ray( unitbox.center, dir, TOL ) );
801  dir = scaled_face( unitbox, 5, 1.0 ) - unitbox.center;
802  dir.normalize();
803  ASSERT( unitbox.intersect_ray( unitbox.center, dir, TOL ) );
804 
805  // test ray starting outside each face and pointing towards box center
806  pt = scaled_face( unitbox, 0, 3.0 );
807  dir = unitbox.center - pt;
808  dir.normalize();
809  ASSERT( unitbox.intersect_ray( pt, dir, TOL ) );
810  pt = scaled_face( unitbox, 1, 3.0 );
811  dir = unitbox.center - pt;
812  dir.normalize();
813  ASSERT( unitbox.intersect_ray( pt, dir, TOL ) );
814  pt = scaled_face( unitbox, 2, 3.0 );
815  dir = unitbox.center - pt;
816  dir.normalize();
817  ASSERT( unitbox.intersect_ray( pt, dir, TOL ) );
818  pt = scaled_face( unitbox, 3, 3.0 );
819  dir = unitbox.center - pt;
820  dir.normalize();
821  ASSERT( unitbox.intersect_ray( pt, dir, TOL ) );
822  pt = scaled_face( unitbox, 4, 3.0 );
823  dir = unitbox.center - pt;
824  dir.normalize();
825  ASSERT( unitbox.intersect_ray( pt, dir, TOL ) );
826  pt = scaled_face( unitbox, 5, 3.0 );
827  dir = unitbox.center - pt;
828  dir.normalize();
829  ASSERT( unitbox.intersect_ray( pt, dir, TOL ) );
830 
831  // test ray from outside first face toward box center, with nonnegative ray length
832  pt = scaled_face( unitbox, 0, 3.0 );
833  dir = unitbox.center - pt;
834  dir.normalize();
835  const double short_pos = 0.99;
836  const double short_neg = -0.99;
837  const double long_pos = 1.01;
838  const double long_neg = -1.01;
839  ASSERT( unitbox.intersect_ray( pt, dir, TOL, &long_pos ) );
840  ASSERT( !unitbox.intersect_ray( pt, dir, TOL, &short_pos ) );
841 
842  // test ray from outside first face away from box center, with negative ray length
843  ASSERT( unitbox.intersect_ray( pt, -dir, TOL, NULL, &long_neg ) );
844  ASSERT( !unitbox.intersect_ray( pt, -dir, TOL, NULL, &short_neg ) );
845 
846  // test ray from outside first face toward box center, with both ray lengths
847  // Note that box.intersect_ray requires neg_ray_len<0 and -neg_ray_len<=nonneg_ray_len
848  ASSERT( unitbox.intersect_ray( pt, dir, TOL, &long_pos, &long_neg ) );
849  ASSERT( !unitbox.intersect_ray( pt, dir, TOL, &short_pos, &long_neg ) );
850  ASSERT( unitbox.intersect_ray( pt, dir, TOL, &long_pos, &short_neg ) );
851  ASSERT( !unitbox.intersect_ray( pt, dir, TOL, &short_pos, &short_neg ) );
852 
853  // test ray starting inside box and passing through a corner
854  pt = scaled_corner( unitbox, 0, 0.3 );
855  dir = pt - unitbox.center;
856  dir.normalize();
857  ASSERT( unitbox.intersect_ray( pt, dir, TOL ) );
858  pt = scaled_corner( unitbox, 1, 0.3 );
859  dir = pt - unitbox.center;
860  dir.normalize();
861  ASSERT( unitbox.intersect_ray( pt, dir, TOL ) );
862  pt = scaled_corner( unitbox, 2, 0.3 );
863  dir = pt - unitbox.center;
864  dir.normalize();
865  ASSERT( unitbox.intersect_ray( pt, dir, TOL ) );
866  pt = scaled_corner( unitbox, 3, 0.3 );
867  dir = pt - unitbox.center;
868  dir.normalize();
869  ASSERT( unitbox.intersect_ray( pt, dir, TOL ) );
870  pt = scaled_corner( unitbox, 4, 0.3 );
871  dir = pt - unitbox.center;
872  dir.normalize();
873  ASSERT( unitbox.intersect_ray( pt, dir, TOL ) );
874  pt = scaled_corner( unitbox, 5, 0.3 );
875  dir = pt - unitbox.center;
876  dir.normalize();
877  ASSERT( unitbox.intersect_ray( pt, dir, TOL ) );
878  pt = scaled_corner( unitbox, 6, 0.3 );
879  dir = pt - unitbox.center;
880  dir.normalize();
881  ASSERT( unitbox.intersect_ray( pt, dir, TOL ) );
882  pt = scaled_corner( unitbox, 7, 0.3 );
883  dir = pt - unitbox.center;
884  dir.normalize();
885  ASSERT( unitbox.intersect_ray( pt, dir, TOL ) );
886 
887  // test ray starting outside box and passing through opposite corners
888  pt = scaled_corner( unitbox, 0, 3.0 );
889  dir = unitbox.center - pt;
890  dir.normalize();
891  ASSERT( unitbox.intersect_ray( pt, dir, TOL ) );
892  pt = scaled_corner( unitbox, 1, 3.0 );
893  dir = unitbox.center - pt;
894  dir.normalize();
895  ASSERT( unitbox.intersect_ray( pt, dir, TOL ) );
896  pt = scaled_corner( unitbox, 2, 3.0 );
897  dir = unitbox.center - pt;
898  dir.normalize();
899  ASSERT( unitbox.intersect_ray( pt, dir, TOL ) );
900  pt = scaled_corner( unitbox, 3, 3.0 );
901  dir = unitbox.center - pt;
902  dir.normalize();
903  ASSERT( unitbox.intersect_ray( pt, dir, TOL ) );
904  pt = scaled_corner( unitbox, 4, 3.0 );
905  dir = unitbox.center - pt;
906  dir.normalize();
907  ASSERT( unitbox.intersect_ray( pt, dir, TOL ) );
908  pt = scaled_corner( unitbox, 5, 3.0 );
909  dir = unitbox.center - pt;
910  dir.normalize();
911  ASSERT( unitbox.intersect_ray( pt, dir, TOL ) );
912  pt = scaled_corner( unitbox, 6, 3.0 );
913  dir = unitbox.center - pt;
914  dir.normalize();
915  ASSERT( unitbox.intersect_ray( pt, dir, TOL ) );
916  pt = scaled_corner( unitbox, 7, 3.0 );
917  dir = unitbox.center - pt;
918  dir.normalize();
919  ASSERT( unitbox.intersect_ray( pt, dir, TOL ) );
920 
921  // test ray starting outside face and pointing away from box
922  pt = scaled_face( unitbox, 0, 3.0 );
923  dir = pt - unitbox.center;
924  dir.normalize();
925  ASSERT( !unitbox.intersect_ray( pt, dir, TOL ) );
926  pt = scaled_face( unitbox, 1, 3.0 );
927  dir = pt - unitbox.center;
928  dir.normalize();
929  ASSERT( !unitbox.intersect_ray( pt, dir, TOL ) );
930  pt = scaled_face( unitbox, 2, 3.0 );
931  dir = pt - unitbox.center;
932  dir.normalize();
933  ASSERT( !unitbox.intersect_ray( pt, dir, TOL ) );
934  pt = scaled_face( unitbox, 3, 3.0 );
935  dir = pt - unitbox.center;
936  dir.normalize();
937  ASSERT( !unitbox.intersect_ray( pt, dir, TOL ) );
938  pt = scaled_face( unitbox, 4, 3.0 );
939  dir = pt - unitbox.center;
940  dir.normalize();
941  ASSERT( !unitbox.intersect_ray( pt, dir, TOL ) );
942  pt = scaled_face( unitbox, 5, 3.0 );
943  dir = pt - unitbox.center;
944  dir.normalize();
945  ASSERT( !unitbox.intersect_ray( pt, dir, TOL ) );
946 
947  // test ray starting outside face and parallel to face
948  pt = scaled_face( unitbox, 0, 3.0 );
949  dir = unitbox.scaled_axis( 1 );
950  dir.normalize();
951  ASSERT( !unitbox.intersect_ray( pt, dir, TOL ) );
952  pt = scaled_face( unitbox, 1, 3.0 );
953  dir = unitbox.scaled_axis( 2 );
954  dir.normalize();
955  ASSERT( !unitbox.intersect_ray( pt, dir, TOL ) );
956  pt = scaled_face( unitbox, 2, 3.0 );
957  dir = unitbox.scaled_axis( 0 );
958  dir.normalize();
959  ASSERT( !unitbox.intersect_ray( pt, dir, TOL ) );
960  pt = scaled_face( unitbox, 3, 3.0 );
961  dir = unitbox.scaled_axis( 2 );
962  dir.normalize();
963  ASSERT( !unitbox.intersect_ray( pt, dir, TOL ) );
964  pt = scaled_face( unitbox, 4, 3.0 );
965  dir = unitbox.scaled_axis( 0 );
966  dir.normalize();
967  ASSERT( !unitbox.intersect_ray( pt, dir, TOL ) );
968  pt = scaled_face( unitbox, 5, 3.0 );
969  dir = unitbox.scaled_axis( 1 );
970  dir.normalize();
971  ASSERT( !unitbox.intersect_ray( pt, dir, TOL ) );
972 
973  // next do offset box
974 
975  // test ray from box center towards each face
976  dir = scaled_face( offsetbox, 0, 1.0 ) - offsetbox.center;
977  dir.normalize();
978  ASSERT( offsetbox.intersect_ray( offsetbox.center, dir, TOL ) );
979  dir = scaled_face( offsetbox, 1, 1.0 ) - offsetbox.center;
980  dir.normalize();
981  ASSERT( offsetbox.intersect_ray( offsetbox.center, dir, TOL ) );
982  dir = scaled_face( offsetbox, 2, 1.0 ) - offsetbox.center;
983  dir.normalize();
984  ASSERT( offsetbox.intersect_ray( offsetbox.center, dir, TOL ) );
985  dir = scaled_face( offsetbox, 3, 1.0 ) - offsetbox.center;
986  dir.normalize();
987  ASSERT( offsetbox.intersect_ray( offsetbox.center, dir, TOL ) );
988  dir = scaled_face( offsetbox, 4, 1.0 ) - offsetbox.center;
989  dir.normalize();
990  ASSERT( offsetbox.intersect_ray( offsetbox.center, dir, TOL ) );
991  dir = scaled_face( offsetbox, 5, 1.0 ) - offsetbox.center;
992  dir.normalize();
993  ASSERT( offsetbox.intersect_ray( offsetbox.center, dir, TOL ) );
994 
995  // test ray starting outside each face and pointing towards box center
996  pt = scaled_face( offsetbox, 0, 3.0 );
997  dir = offsetbox.center - pt;
998  dir.normalize();
999  ASSERT( offsetbox.intersect_ray( pt, dir, TOL ) );
1000  pt = scaled_face( offsetbox, 1, 3.0 );
1001  dir = offsetbox.center - pt;
1002  dir.normalize();
1003  ASSERT( offsetbox.intersect_ray( pt, dir, TOL ) );
1004  pt = scaled_face( offsetbox, 2, 3.0 );
1005  dir = offsetbox.center - pt;
1006  dir.normalize();
1007  ASSERT( offsetbox.intersect_ray( pt, dir, TOL ) );
1008  pt = scaled_face( offsetbox, 3, 3.0 );
1009  dir = offsetbox.center - pt;
1010  dir.normalize();
1011  ASSERT( offsetbox.intersect_ray( pt, dir, TOL ) );
1012  pt = scaled_face( offsetbox, 4, 3.0 );
1013  dir = offsetbox.center - pt;
1014  dir.normalize();
1015  ASSERT( offsetbox.intersect_ray( pt, dir, TOL ) );
1016  pt = scaled_face( offsetbox, 5, 3.0 );
1017  dir = offsetbox.center - pt;
1018  dir.normalize();
1019  ASSERT( offsetbox.intersect_ray( pt, dir, TOL ) );
1020 
1021  // test ray starting inside box and passing through a corner
1022  pt = scaled_corner( offsetbox, 0, 0.3 );
1023  dir = pt - offsetbox.center;
1024  dir.normalize();
1025  ASSERT( offsetbox.intersect_ray( pt, dir, TOL ) );
1026  pt = scaled_corner( offsetbox, 1, 0.3 );
1027  dir = pt - offsetbox.center;
1028  dir.normalize();
1029  ASSERT( offsetbox.intersect_ray( pt, dir, TOL ) );
1030  pt = scaled_corner( offsetbox, 2, 0.3 );
1031  dir = pt - offsetbox.center;
1032  dir.normalize();
1033  ASSERT( offsetbox.intersect_ray( pt, dir, TOL ) );
1034  pt = scaled_corner( offsetbox, 3, 0.3 );
1035  dir = pt - offsetbox.center;
1036  dir.normalize();
1037  ASSERT( offsetbox.intersect_ray( pt, dir, TOL ) );
1038  pt = scaled_corner( offsetbox, 4, 0.3 );
1039  dir = pt - offsetbox.center;
1040  dir.normalize();
1041  ASSERT( offsetbox.intersect_ray( pt, dir, TOL ) );
1042  pt = scaled_corner( offsetbox, 5, 0.3 );
1043  dir = pt - offsetbox.center;
1044  dir.normalize();
1045  ASSERT( offsetbox.intersect_ray( pt, dir, TOL ) );
1046  pt = scaled_corner( offsetbox, 6, 0.3 );
1047  dir = pt - offsetbox.center;
1048  dir.normalize();
1049  ASSERT( offsetbox.intersect_ray( pt, dir, TOL ) );
1050  pt = scaled_corner( offsetbox, 7, 0.3 );
1051  dir = pt - offsetbox.center;
1052  dir.normalize();
1053  ASSERT( offsetbox.intersect_ray( pt, dir, TOL ) );
1054 
1055  // test ray starting outside box and passing through opposite corners
1056  pt = scaled_corner( offsetbox, 0, 3.0 );
1057  dir = offsetbox.center - pt;
1058  dir.normalize();
1059  ASSERT( offsetbox.intersect_ray( pt, dir, TOL ) );
1060  pt = scaled_corner( offsetbox, 1, 3.0 );
1061  dir = offsetbox.center - pt;
1062  dir.normalize();
1063  ASSERT( offsetbox.intersect_ray( pt, dir, TOL ) );
1064  pt = scaled_corner( offsetbox, 2, 3.0 );
1065  dir = offsetbox.center - pt;
1066  dir.normalize();
1067  ASSERT( offsetbox.intersect_ray( pt, dir, TOL ) );
1068  pt = scaled_corner( offsetbox, 3, 3.0 );
1069  dir = offsetbox.center - pt;
1070  dir.normalize();
1071  ASSERT( offsetbox.intersect_ray( pt, dir, TOL ) );
1072  pt = scaled_corner( offsetbox, 4, 3.0 );
1073  dir = offsetbox.center - pt;
1074  dir.normalize();
1075  ASSERT( offsetbox.intersect_ray( pt, dir, TOL ) );
1076  pt = scaled_corner( offsetbox, 5, 3.0 );
1077  dir = offsetbox.center - pt;
1078  dir.normalize();
1079  ASSERT( offsetbox.intersect_ray( pt, dir, TOL ) );
1080  pt = scaled_corner( offsetbox, 6, 3.0 );
1081  dir = offsetbox.center - pt;
1082  dir.normalize();
1083  ASSERT( offsetbox.intersect_ray( pt, dir, TOL ) );
1084  pt = scaled_corner( offsetbox, 7, 3.0 );
1085  dir = offsetbox.center - pt;
1086  dir.normalize();
1087  ASSERT( offsetbox.intersect_ray( pt, dir, TOL ) );
1088 
1089  // test ray starting outside face and pointing away from box
1090  pt = scaled_face( offsetbox, 0, 3.0 );
1091  dir = pt - offsetbox.center;
1092  dir.normalize();
1093  ASSERT( !offsetbox.intersect_ray( pt, dir, TOL ) );
1094  pt = scaled_face( offsetbox, 1, 3.0 );
1095  dir = pt - offsetbox.center;
1096  dir.normalize();
1097  ASSERT( !offsetbox.intersect_ray( pt, dir, TOL ) );
1098  pt = scaled_face( offsetbox, 2, 3.0 );
1099  dir = pt - offsetbox.center;
1100  dir.normalize();
1101  ASSERT( !offsetbox.intersect_ray( pt, dir, TOL ) );
1102  pt = scaled_face( offsetbox, 3, 3.0 );
1103  dir = pt - offsetbox.center;
1104  dir.normalize();
1105  ASSERT( !offsetbox.intersect_ray( pt, dir, TOL ) );
1106  pt = scaled_face( offsetbox, 4, 3.0 );
1107  dir = pt - offsetbox.center;
1108  dir.normalize();
1109  ASSERT( !offsetbox.intersect_ray( pt, dir, TOL ) );
1110  pt = scaled_face( offsetbox, 5, 3.0 );
1111  dir = pt - offsetbox.center;
1112  dir.normalize();
1113  ASSERT( !offsetbox.intersect_ray( pt, dir, TOL ) );
1114 
1115  // test ray starting outside face and parallel to face
1116  pt = scaled_face( offsetbox, 0, 3.0 );
1117  dir = offsetbox.scaled_axis( 1 );
1118  dir.normalize();
1119  ASSERT( !offsetbox.intersect_ray( pt, dir, TOL ) );
1120  pt = scaled_face( offsetbox, 1, 3.0 );
1121  dir = offsetbox.scaled_axis( 2 );
1122  dir.normalize();
1123  ASSERT( !offsetbox.intersect_ray( pt, dir, TOL ) );
1124  pt = scaled_face( offsetbox, 2, 3.0 );
1125  dir = offsetbox.scaled_axis( 0 );
1126  dir.normalize();
1127  ASSERT( !offsetbox.intersect_ray( pt, dir, TOL ) );
1128  pt = scaled_face( offsetbox, 3, 3.0 );
1129  dir = offsetbox.scaled_axis( 2 );
1130  dir.normalize();
1131  ASSERT( !offsetbox.intersect_ray( pt, dir, TOL ) );
1132  pt = scaled_face( offsetbox, 4, 3.0 );
1133  dir = offsetbox.scaled_axis( 0 );
1134  dir.normalize();
1135  ASSERT( !offsetbox.intersect_ray( pt, dir, TOL ) );
1136  pt = scaled_face( offsetbox, 5, 3.0 );
1137  dir = offsetbox.scaled_axis( 1 );
1138  dir.normalize();
1139  ASSERT( !offsetbox.intersect_ray( pt, dir, TOL ) );
1140 
1141  // next do oblong box
1142 
1143  // test ray from box center towards each face
1144  dir = scaled_face( oblongbox, 0, 1.0 ) - oblongbox.center;
1145  dir.normalize();
1146  ASSERT( oblongbox.intersect_ray( oblongbox.center, dir, TOL ) );
1147  dir = scaled_face( oblongbox, 1, 1.0 ) - oblongbox.center;
1148  dir.normalize();
1149  ASSERT( oblongbox.intersect_ray( oblongbox.center, dir, TOL ) );
1150  dir = scaled_face( oblongbox, 2, 1.0 ) - oblongbox.center;
1151  dir.normalize();
1152  ASSERT( oblongbox.intersect_ray( oblongbox.center, dir, TOL ) );
1153  dir = scaled_face( oblongbox, 3, 1.0 ) - oblongbox.center;
1154  dir.normalize();
1155  ASSERT( oblongbox.intersect_ray( oblongbox.center, dir, TOL ) );
1156  dir = scaled_face( oblongbox, 4, 1.0 ) - oblongbox.center;
1157  dir.normalize();
1158  ASSERT( oblongbox.intersect_ray( oblongbox.center, dir, TOL ) );
1159  dir = scaled_face( oblongbox, 5, 1.0 ) - oblongbox.center;
1160  dir.normalize();
1161  ASSERT( oblongbox.intersect_ray( oblongbox.center, dir, TOL ) );
1162 
1163  // test ray starting outside each face and pointing towards box center
1164  pt = scaled_face( oblongbox, 0, 3.0 );
1165  dir = oblongbox.center - pt;
1166  dir.normalize();
1167  ASSERT( oblongbox.intersect_ray( pt, dir, TOL ) );
1168  pt = scaled_face( oblongbox, 1, 3.0 );
1169  dir = oblongbox.center - pt;
1170  dir.normalize();
1171  ASSERT( oblongbox.intersect_ray( pt, dir, TOL ) );
1172  pt = scaled_face( oblongbox, 2, 3.0 );
1173  dir = oblongbox.center - pt;
1174  dir.normalize();
1175  ASSERT( oblongbox.intersect_ray( pt, dir, TOL ) );
1176  pt = scaled_face( oblongbox, 3, 3.0 );
1177  dir = oblongbox.center - pt;
1178  dir.normalize();
1179  ASSERT( oblongbox.intersect_ray( pt, dir, TOL ) );
1180  pt = scaled_face( oblongbox, 4, 3.0 );
1181  dir = oblongbox.center - pt;
1182  dir.normalize();
1183  ASSERT( oblongbox.intersect_ray( pt, dir, TOL ) );
1184  pt = scaled_face( oblongbox, 5, 3.0 );
1185  dir = oblongbox.center - pt;
1186  dir.normalize();
1187  ASSERT( oblongbox.intersect_ray( pt, dir, TOL ) );
1188 
1189  // test ray starting inside box and passing through a corner
1190  pt = scaled_corner( oblongbox, 0, 0.3 );
1191  dir = pt - oblongbox.center;
1192  dir.normalize();
1193  ASSERT( oblongbox.intersect_ray( pt, dir, TOL ) );
1194  pt = scaled_corner( oblongbox, 1, 0.3 );
1195  dir = pt - oblongbox.center;
1196  dir.normalize();
1197  ASSERT( oblongbox.intersect_ray( pt, dir, TOL ) );
1198  pt = scaled_corner( oblongbox, 2, 0.3 );
1199  dir = pt - oblongbox.center;
1200  dir.normalize();
1201  ASSERT( oblongbox.intersect_ray( pt, dir, TOL ) );
1202  pt = scaled_corner( oblongbox, 3, 0.3 );
1203  dir = pt - oblongbox.center;
1204  dir.normalize();
1205  ASSERT( oblongbox.intersect_ray( pt, dir, TOL ) );
1206  pt = scaled_corner( oblongbox, 4, 0.3 );
1207  dir = pt - oblongbox.center;
1208  dir.normalize();
1209  ASSERT( oblongbox.intersect_ray( pt, dir, TOL ) );
1210  pt = scaled_corner( oblongbox, 5, 0.3 );
1211  dir = pt - oblongbox.center;
1212  dir.normalize();
1213  ASSERT( oblongbox.intersect_ray( pt, dir, TOL ) );
1214  pt = scaled_corner( oblongbox, 6, 0.3 );
1215  dir = pt - oblongbox.center;
1216  dir.normalize();
1217  ASSERT( oblongbox.intersect_ray( pt, dir, TOL ) );
1218  pt = scaled_corner( oblongbox, 7, 0.3 );
1219  dir = pt - oblongbox.center;
1220  dir.normalize();
1221  ASSERT( oblongbox.intersect_ray( pt, dir, TOL ) );
1222 
1223  // test ray starting outside box and passing through opposite corners
1224  pt = scaled_corner( oblongbox, 0, 3.0 );
1225  dir = oblongbox.center - pt;
1226  dir.normalize();
1227  ASSERT( oblongbox.intersect_ray( pt, dir, TOL ) );
1228  pt = scaled_corner( oblongbox, 1, 3.0 );
1229  dir = oblongbox.center - pt;
1230  dir.normalize();
1231  ASSERT( oblongbox.intersect_ray( pt, dir, TOL ) );
1232  pt = scaled_corner( oblongbox, 2, 3.0 );
1233  dir = oblongbox.center - pt;
1234  dir.normalize();
1235  ASSERT( oblongbox.intersect_ray( pt, dir, TOL ) );
1236  pt = scaled_corner( oblongbox, 3, 3.0 );
1237  dir = oblongbox.center - pt;
1238  dir.normalize();
1239  ASSERT( oblongbox.intersect_ray( pt, dir, TOL ) );
1240  pt = scaled_corner( oblongbox, 4, 3.0 );
1241  dir = oblongbox.center - pt;
1242  dir.normalize();
1243  ASSERT( oblongbox.intersect_ray( pt, dir, TOL ) );
1244  pt = scaled_corner( oblongbox, 5, 3.0 );
1245  dir = oblongbox.center - pt;
1246  dir.normalize();
1247  ASSERT( oblongbox.intersect_ray( pt, dir, TOL ) );
1248  pt = scaled_corner( oblongbox, 6, 3.0 );
1249  dir = oblongbox.center - pt;
1250  dir.normalize();
1251  ASSERT( oblongbox.intersect_ray( pt, dir, TOL ) );
1252  pt = scaled_corner( oblongbox, 7, 3.0 );
1253  dir = oblongbox.center - pt;
1254  dir.normalize();
1255  ASSERT( oblongbox.intersect_ray( pt, dir, TOL ) );
1256 
1257  // test ray starting outside face and pointing away from box
1258  pt = scaled_face( oblongbox, 0, 3.0 );
1259  dir = pt - oblongbox.center;
1260  dir.normalize();
1261  ASSERT( !oblongbox.intersect_ray( pt, dir, TOL ) );
1262  pt = scaled_face( oblongbox, 1, 3.0 );
1263  dir = pt - oblongbox.center;
1264  dir.normalize();
1265  ASSERT( !oblongbox.intersect_ray( pt, dir, TOL ) );
1266  pt = scaled_face( oblongbox, 2, 3.0 );
1267  dir = pt - oblongbox.center;
1268  dir.normalize();
1269  ASSERT( !oblongbox.intersect_ray( pt, dir, TOL ) );
1270  pt = scaled_face( oblongbox, 3, 3.0 );
1271  dir = pt - oblongbox.center;
1272  dir.normalize();
1273  ASSERT( !oblongbox.intersect_ray( pt, dir, TOL ) );
1274  pt = scaled_face( oblongbox, 4, 3.0 );
1275  dir = pt - oblongbox.center;
1276  dir.normalize();
1277  ASSERT( !oblongbox.intersect_ray( pt, dir, TOL ) );
1278  pt = scaled_face( oblongbox, 5, 3.0 );
1279  dir = pt - oblongbox.center;
1280  dir.normalize();
1281  ASSERT( !oblongbox.intersect_ray( pt, dir, TOL ) );
1282 
1283  // test ray starting outside face and parallel to face
1284  pt = scaled_face( oblongbox, 0, 3.0 );
1285  dir = oblongbox.scaled_axis( 1 );
1286  dir.normalize();
1287  ASSERT( !oblongbox.intersect_ray( pt, dir, TOL ) );
1288  pt = scaled_face( oblongbox, 1, 3.0 );
1289  dir = oblongbox.scaled_axis( 2 );
1290  dir.normalize();
1291  ASSERT( !oblongbox.intersect_ray( pt, dir, TOL ) );
1292  pt = scaled_face( oblongbox, 2, 3.0 );
1293  dir = oblongbox.scaled_axis( 0 );
1294  dir.normalize();
1295  ASSERT( !oblongbox.intersect_ray( pt, dir, TOL ) );
1296  pt = scaled_face( oblongbox, 3, 3.0 );
1297  dir = oblongbox.scaled_axis( 2 );
1298  dir.normalize();
1299  ASSERT( !oblongbox.intersect_ray( pt, dir, TOL ) );
1300  pt = scaled_face( oblongbox, 4, 3.0 );
1301  dir = oblongbox.scaled_axis( 0 );
1302  dir.normalize();
1303  ASSERT( !oblongbox.intersect_ray( pt, dir, TOL ) );
1304  pt = scaled_face( oblongbox, 5, 3.0 );
1305  dir = oblongbox.scaled_axis( 1 );
1306  dir.normalize();
1307  ASSERT( !oblongbox.intersect_ray( pt, dir, TOL ) );
1308 
1309  // next do rotated box
1310 
1311  // test ray from box center towards each face
1312  dir = scaled_face( rotbox, 0, 1.0 ) - rotbox.center;
1313  dir.normalize();
1314  ASSERT( rotbox.intersect_ray( rotbox.center, dir, TOL ) );
1315  dir = scaled_face( rotbox, 1, 1.0 ) - rotbox.center;
1316  dir.normalize();
1317  ASSERT( rotbox.intersect_ray( rotbox.center, dir, TOL ) );
1318  dir = scaled_face( rotbox, 2, 1.0 ) - rotbox.center;
1319  dir.normalize();
1320  ASSERT( rotbox.intersect_ray( rotbox.center, dir, TOL ) );
1321  dir = scaled_face( rotbox, 3, 1.0 ) - rotbox.center;
1322  dir.normalize();
1323  ASSERT( rotbox.intersect_ray( rotbox.center, dir, TOL ) );
1324  dir = scaled_face( rotbox, 4, 1.0 ) - rotbox.center;
1325  dir.normalize();
1326  ASSERT( rotbox.intersect_ray( rotbox.center, dir, TOL ) );
1327  dir = scaled_face( rotbox, 5, 1.0 ) - rotbox.center;
1328  dir.normalize();
1329  ASSERT( rotbox.intersect_ray( rotbox.center, dir, TOL ) );
1330 
1331  // test ray starting outside each face and pointing towards box center
1332  pt = scaled_face( rotbox, 0, 3.0 );
1333  dir = rotbox.center - pt;
1334  dir.normalize();
1335  ASSERT( rotbox.intersect_ray( pt, dir, TOL ) );
1336  pt = scaled_face( rotbox, 1, 3.0 );
1337  dir = rotbox.center - pt;
1338  dir.normalize();
1339  ASSERT( rotbox.intersect_ray( pt, dir, TOL ) );
1340  pt = scaled_face( rotbox, 2, 3.0 );
1341  dir = rotbox.center - pt;
1342  dir.normalize();
1343  ASSERT( rotbox.intersect_ray( pt, dir, TOL ) );
1344  pt = scaled_face( rotbox, 3, 3.0 );
1345  dir = rotbox.center - pt;
1346  dir.normalize();
1347  ASSERT( rotbox.intersect_ray( pt, dir, TOL ) );
1348  pt = scaled_face( rotbox, 4, 3.0 );
1349  dir = rotbox.center - pt;
1350  dir.normalize();
1351  ASSERT( rotbox.intersect_ray( pt, dir, TOL ) );
1352  pt = scaled_face( rotbox, 5, 3.0 );
1353  dir = rotbox.center - pt;
1354  dir.normalize();
1355  ASSERT( rotbox.intersect_ray( pt, dir, TOL ) );
1356 
1357  // test ray starting inside box and passing through a corner
1358  pt = scaled_corner( rotbox, 0, 0.3 );
1359  dir = pt - rotbox.center;
1360  dir.normalize();
1361  ASSERT( rotbox.intersect_ray( pt, dir, TOL ) );
1362  pt = scaled_corner( rotbox, 1, 0.3 );
1363  dir = pt - rotbox.center;
1364  dir.normalize();
1365  ASSERT( rotbox.intersect_ray( pt, dir, TOL ) );
1366  pt = scaled_corner( rotbox, 2, 0.3 );
1367  dir = pt - rotbox.center;
1368  dir.normalize();
1369  ASSERT( rotbox.intersect_ray( pt, dir, TOL ) );
1370  pt = scaled_corner( rotbox, 3, 0.3 );
1371  dir = pt - rotbox.center;
1372  dir.normalize();
1373  ASSERT( rotbox.intersect_ray( pt, dir, TOL ) );
1374  pt = scaled_corner( rotbox, 4, 0.3 );
1375  dir = pt - rotbox.center;
1376  dir.normalize();
1377  ASSERT( rotbox.intersect_ray( pt, dir, TOL ) );
1378  pt = scaled_corner( rotbox, 5, 0.3 );
1379  dir = pt - rotbox.center;
1380  dir.normalize();
1381  ASSERT( rotbox.intersect_ray( pt, dir, TOL ) );
1382  pt = scaled_corner( rotbox, 6, 0.3 );
1383  dir = pt - rotbox.center;
1384  dir.normalize();
1385  ASSERT( rotbox.intersect_ray( pt, dir, TOL ) );
1386  pt = scaled_corner( rotbox, 7, 0.3 );
1387  dir = pt - rotbox.center;
1388  dir.normalize();
1389  ASSERT( rotbox.intersect_ray( pt, dir, TOL ) );
1390 
1391  // test ray starting outside box and passing through opposite corners
1392  pt = scaled_corner( rotbox, 0, 3.0 );
1393  dir = rotbox.center - pt;
1394  dir.normalize();
1395  ASSERT( rotbox.intersect_ray( pt, dir, TOL ) );
1396  pt = scaled_corner( rotbox, 1, 3.0 );
1397  dir = rotbox.center - pt;
1398  dir.normalize();
1399  ASSERT( rotbox.intersect_ray( pt, dir, TOL ) );
1400  pt = scaled_corner( rotbox, 2, 3.0 );
1401  dir = rotbox.center - pt;
1402  dir.normalize();
1403  ASSERT( rotbox.intersect_ray( pt, dir, TOL ) );
1404  pt = scaled_corner( rotbox, 3, 3.0 );
1405  dir = rotbox.center - pt;
1406  dir.normalize();
1407  ASSERT( rotbox.intersect_ray( pt, dir, TOL ) );
1408  pt = scaled_corner( rotbox, 4, 3.0 );
1409  dir = rotbox.center - pt;
1410  dir.normalize();
1411  ASSERT( rotbox.intersect_ray( pt, dir, TOL ) );
1412  pt = scaled_corner( rotbox, 5, 3.0 );
1413  dir = rotbox.center - pt;
1414  dir.normalize();
1415  ASSERT( rotbox.intersect_ray( pt, dir, TOL ) );
1416  pt = scaled_corner( rotbox, 6, 3.0 );
1417  dir = rotbox.center - pt;
1418  dir.normalize();
1419  ASSERT( rotbox.intersect_ray( pt, dir, TOL ) );
1420  pt = scaled_corner( rotbox, 7, 3.0 );
1421  dir = rotbox.center - pt;
1422  dir.normalize();
1423  ASSERT( rotbox.intersect_ray( pt, dir, TOL ) );
1424 
1425  // test ray starting outside face and pointing away from box
1426  pt = scaled_face( rotbox, 0, 3.0 );
1427  dir = pt - rotbox.center;
1428  dir.normalize();
1429  ASSERT( !rotbox.intersect_ray( pt, dir, TOL ) );
1430  pt = scaled_face( rotbox, 1, 3.0 );
1431  dir = pt - rotbox.center;
1432  dir.normalize();
1433  ASSERT( !rotbox.intersect_ray( pt, dir, TOL ) );
1434  pt = scaled_face( rotbox, 2, 3.0 );
1435  dir = pt - rotbox.center;
1436  dir.normalize();
1437  ASSERT( !rotbox.intersect_ray( pt, dir, TOL ) );
1438  pt = scaled_face( rotbox, 3, 3.0 );
1439  dir = pt - rotbox.center;
1440  dir.normalize();
1441  ASSERT( !rotbox.intersect_ray( pt, dir, TOL ) );
1442  pt = scaled_face( rotbox, 4, 3.0 );
1443  dir = pt - rotbox.center;
1444  dir.normalize();
1445  ASSERT( !rotbox.intersect_ray( pt, dir, TOL ) );
1446  pt = scaled_face( rotbox, 5, 3.0 );
1447  dir = pt - rotbox.center;
1448  dir.normalize();
1449  ASSERT( !rotbox.intersect_ray( pt, dir, TOL ) );
1450 
1451  // test ray starting outside face and parallel to face
1452  pt = scaled_face( rotbox, 0, 3.0 );
1453  dir = rotbox.scaled_axis( 1 );
1454  dir.normalize();
1455  ASSERT( !rotbox.intersect_ray( pt, dir, TOL ) );
1456  pt = scaled_face( rotbox, 1, 3.0 );
1457  dir = rotbox.scaled_axis( 2 );
1458  dir.normalize();
1459  ASSERT( !rotbox.intersect_ray( pt, dir, TOL ) );
1460  pt = scaled_face( rotbox, 2, 3.0 );
1461  dir = rotbox.scaled_axis( 0 );
1462  dir.normalize();
1463  ASSERT( !rotbox.intersect_ray( pt, dir, TOL ) );
1464  pt = scaled_face( rotbox, 3, 3.0 );
1465  dir = rotbox.scaled_axis( 2 );
1466  dir.normalize();
1467  ASSERT( !rotbox.intersect_ray( pt, dir, TOL ) );
1468  pt = scaled_face( rotbox, 4, 3.0 );
1469  dir = rotbox.scaled_axis( 0 );
1470  dir.normalize();
1471  ASSERT( !rotbox.intersect_ray( pt, dir, TOL ) );
1472  pt = scaled_face( rotbox, 5, 3.0 );
1473  dir = rotbox.scaled_axis( 1 );
1474  dir.normalize();
1475  ASSERT( !rotbox.intersect_ray( pt, dir, TOL ) );
1476 }

References ASSERT, moab::OrientedBox::center, moab::OrientedBox::intersect_ray(), moab::CartVect::normalize(), oblongbox, offsetbox, rotbox, moab::OrientedBox::scaled_axis(), scaled_corner(), scaled_face(), TOL, and unitbox.

Referenced by main().

◆ test_save()

static void test_save ( )
static

Definition at line 1612 of file oriented_box_test.cpp.

1613 {
1614  ErrorCode rval;
1615  Core moab;
1616  OrientedBox box;
1617 
1618  // create a tag to store the data in
1619  Tag tag;
1620  rval = OrientedBox::tag_handle( tag, &moab, "FOO" );
1621  ASSERT( MB_SUCCESS == rval );
1622 
1623  // check tag size
1624  int size;
1625  rval = moab.tag_get_bytes( tag, size );
1626  ASSERT( MB_SUCCESS == rval );
1627  ASSERT( size == sizeof( OrientedBox ) );
1628 }

References ASSERT, box(), ErrorCode, MB_SUCCESS, size, and moab::OrientedBox::tag_handle().

Referenced by main().

Variable Documentation

◆ error_count

int error_count = 0

Definition at line 11 of file oriented_box_test.cpp.

Referenced by assert_bool(), assert_doubles_equal(), assert_vector_element(), assert_vectors_equal(), and main().

◆ oblongbox

const OrientedBox oblongbox(origaxes, origin) ( origaxes  ,
origin   
)

Referenced by test_basic(), test_closest_point(), test_contained(), and test_ray_intersect().

◆ offsetbox

const OrientedBox offsetbox(unitaxes, unitcenter) ( unitaxes  ,
unitcenter   
)

Referenced by test_basic(), test_closest_point(), test_contained(), and test_ray_intersect().

◆ origin

const CartVect origin(0.0, 0.0, 0.0) ( 0.  0,
0.  0,
0.  0 
)

Referenced by dagmc_origin_face_rayfire(), dagmc_outside_face_rayfire(), dagmc_outside_face_rayfire_history(), dagmc_outside_face_rayfire_history_fail(), dagmc_outside_face_rayfire_orient_entrance(), dagmc_outside_face_rayfire_orient_exit(), dagmc_point_in_vol_1(), dagmc_point_in_vol_2(), dagmc_point_in_vol_3(), dagmc_point_in_vol_4(), dagmc_point_in_vol_5(), dagmc_point_in_vol_6(), dagmc_point_in_vol_dir(), dagmc_point_on_corner_1(), dagmc_point_on_corner_2(), dagmc_point_on_corner_3(), dagmc_point_on_corner_4(), dagmc_point_on_corner_5(), dagmc_point_on_corner_6(), dagmc_point_on_corner_7(), dagmc_point_on_corner_8(), do_ray_fire_test(), gqt_origin_face_rayfire(), gqt_outside_face_rayfire(), gqt_outside_face_rayfire_history(), gqt_outside_face_rayfire_history_fail(), gqt_outside_face_rayfire_orient_entrance(), gqt_outside_face_rayfire_orient_exit(), gqt_point_in_box_1(), gqt_point_in_box_2(), gqt_point_in_box_3(), gqt_point_in_box_4(), gqt_point_in_box_5(), gqt_point_in_vol_1(), gqt_point_in_vol_2(), gqt_point_in_vol_3(), gqt_point_in_vol_4(), gqt_point_in_vol_5(), gqt_point_in_vol_6(), gqt_point_in_vol_dir(), gqt_point_on_corner_1(), gqt_point_on_corner_2(), gqt_point_on_corner_3(), gqt_point_on_corner_4(), gqt_point_on_corner_5(), gqt_point_on_corner_6(), gqt_point_on_corner_7(), gqt_point_on_corner_8(), moab::GeomUtil::plucker_ray_tri_intersect(), moab::ReadMCNP5::read_mesh_planes(), test_basic(), test_ray_fire(), and moab::ReadVtk::vtk_read_structured_points().

◆ rotax

const CartVect rotax[3] = { rotax0, rotax1, rotax2 }

Definition at line 64 of file oriented_box_test.cpp.

◆ rotax0

const CartVect rotax0 = CartVect( 1.0, 1.0, 0.0 )

Definition at line 61 of file oriented_box_test.cpp.

Referenced by test_basic().

◆ rotax1

const CartVect rotax1 = CartVect( 1.0, -1.0, 1.0 )

Definition at line 62 of file oriented_box_test.cpp.

Referenced by test_basic().

◆ rotax2

const CartVect rotax2 = CartVect( 1.0, 1.0, 0.0 ) * CartVect( 1.0, -1.0, 1.0 )

Definition at line 63 of file oriented_box_test.cpp.

Referenced by test_basic().

◆ rotaxes

const Matrix3 rotaxes(rotax0, rotax1, rotax2, false) ( rotax0  ,
rotax1  ,
rotax2  ,
false   
)

Referenced by test_basic().

◆ rotbox

const OrientedBox rotbox(rotaxes, origin) ( rotaxes  ,
origin   
)

Referenced by test_basic(), test_closest_point(), test_contained(), and test_ray_intersect().

◆ rotbox_cv

const OrientedBox rotbox_cv(rotax, origin) ( rotax  ,
origin   
)

Referenced by test_basic().

◆ TOL

const double TOL = 1e-6

Definition at line 10 of file oriented_box_test.cpp.

Referenced by assert_doubles_equal(), assert_vector_element(), assert_vectors_equal(), test_build_from_tri(), test_contained(), and test_ray_intersect().

◆ unitaxes

const Matrix3 unitaxes(0.5, 0.0, 0.0, 0.0, 0.5, 0.0, 0.0, 0.0, 0.5) ( 0.  5,
0.  0,
0.  0,
0.  0,
0.  5,
0.  0,
0.  0,
0.  0,
0.  5 
)

Referenced by test_basic().

◆ unitbox

const OrientedBox unitbox(unitaxes, origin) ( unitaxes  ,
origin   
)

Referenced by test_basic(), test_closest_point(), test_contained(), and test_ray_intersect().

◆ unitcenter

const CartVect unitcenter(10, 20, 30) ( 10  ,
20  ,
30   
)

Referenced by test_basic().