def test_elevation_above_sphere_surface(self):
self.when_ordinary_sphere_is_constructed()
for expected_elevation, test_point in [
(-self.expected_radius, self.expected_center),
(0.0, Position.from_xyz((15.0, 20.0, 30.0))),
(0.0, Position.from_xyz((5.0, 20.0, 30.0))),
(0.0, Position.from_xyz((10.0, 23.0, 34.0))),
(sqrt(125.0) - 5.0, Position.from_xyz((0.0, 23.0, 34.0))),
]:
self.then_point_has_correct_elevation(expected_elevation, test_point)
def then_sphere_intersects_rays_correctly(self):
starting_points = [
Position.from_xyz((0.0, 0.0, 0.0)),
Position.from_xyz((100.0, 200.0, 300.0)),
Position.from_xyz((-50.0, 10.0, 10.0)),
]
interior_points = [
self.expected_center,
self.expected_center.add(Direction.up.scale(4.0)),
self.expected_center.add(Direction.left.scale(4.0)),
self.expected_center.add(Direction.backward.scale(4.0)),
]
for self.starting_point in starting_points:
for self.interior_point in interior_points:
self.when_sphere_intersects_ray_through_interior_point()
self.then_intersection_points_are_correct()
def initialize_translation(self):
self.transformation_context = "translation"
self.start_position_coordinates = (1.0, 20.0, 30.0, 40.0)
self.stop_position_coordinates = (1.0, 22.0, 33.0, 44.0)
delta_position = Position.from_xyz((2.0, 3.0, 4.0))
self.start_direction_coordinates = (0.0, math.sqrt(0.4), math.sqrt(0.5), math.sqrt(0.1))
self.stop_direction_coordinates = self.start_direction_coordinates
self.transformation_under_test = Transformation.translation_by_position(delta_position)
def _build_imager(self):
self.imager_position = Position.from_xyz((0.0, 0.0, 0.0))
self.imager_direction = self.placement.direction.normalized()
self.image_placement = Ray(self.imager_position, self.imager_direction)
self.imager = ImageSensor(
width = self.width,
height = self.height,
placement = self.image_placement,
horizontal_direction = self.horizontal_axis,
vertical_direction = self.vertical_axis,
)
def initialize_composite_transformation(self):
self.transformation_context = "composite transformation"
right_angle = math.pi / 2.0
self.start_position_coordinates = (1.0, 100.0, 200.0, 300.0)
delta_position = Position.from_xyz((2.0, 3.0, 4.0))
self.stop_position_coordinates = (1.0, 297.0, 102.0, 204.0)
self.start_direction_coordinates = (0.0, math.sqrt(0.4), math.sqrt(0.5), math.sqrt(0.1))
self.stop_direction_coordinates = (0.0, math.sqrt(0.1), math.sqrt(0.4), math.sqrt(0.5))
first_transform = Transformation.rotation_about_x_axis(right_angle)
second_transform = Transformation.translation_by_position(delta_position)
third_transform = Transformation.rotation_about_z_axis(right_angle)
self.transformation_under_test = first_transform.compose(second_transform).compose(third_transform)
def setUp(self):
self.clean_state()
self.vector = (2.0, 3.0, 4.0)
vector_length = vector_norm(self.vector)
self.unit_vector = tuple(component / vector_length for component in self.vector)
self.position = Position.from_xyz((10.0, 20.0, 30.0))
self.direction = Direction.from_xyz(self.vector)
self.unit_direction = Direction.from_xyz(self.unit_vector)
self.ray = Ray(self.position, self.direction)
self.unit_ray = Ray(self.position, self.unit_direction)
self.other_position = Position.from_xyz((-9.0, -88.0, 12.34))
self.other_direction = Direction.from_xyz((19.0, 8.0, -0.03))
self.other_ray = Ray(self.other_position, self.other_direction)
offset = self.position.dot(self.unit_direction)
plane_projector = (-offset,) + self.unit_vector
self.plane = Plane(plane_projector)
self.orthogonal_directions = [
Direction.from_xyz((0.2, 0.2, -0.25)),
Direction.from_xyz((-7.0, 2.0, 2.0))
]
self.orthogonal_rays = [Ray(self.position, direction)
for direction in self.orthogonal_directions]
def setUp(self):
self.clean_state()
self.diameter = 0.1
self.aperture_origin = Position.from_xyz((10.0, 20.0, 30.0))
self.aperture_direction = Direction.from_xyz((1.0, 2.0, 3.0))
self.placement = Ray(self.aperture_origin, self.aperture_direction.normalized())
self.aperture = Aperture(placement=self.placement, diameter=self.diameter)
self.initial_wavefront = WaveFront.unit_sphere
self.orthogonal_directions = [
self.aperture_direction.cross(Direction.right).normalized(),
self.aperture_direction.cross(Direction.forward).normalized(),
self.aperture_direction.cross(Direction.backward).normalized(),
]
def setUp(self):
self.clean_state()
self.diameter = 10.0
self.focal_length = 50.0
self.aperture_origin = Position.from_xyz((10.0, 20.0, 30.0))
self.aperture_direction = Direction.from_xyz((1.0, 2.0, 3.0))
self.aperture_normal = self.aperture_direction.normalized()
self.placement = Ray(self.aperture_origin, self.aperture_normal)
self.orthogonal_directions = [
self.aperture_direction.cross(Direction.right).normalized(),
self.aperture_direction.cross(Direction.forward).normalized(),
self.aperture_direction.cross(Direction.backward).normalized(),
]
self.test_directions = [self.aperture_normal.add(
orthogonal_direction.scale(0.1)).normalized() for orthogonal_direction in self.orthogonal_directions]
def setUp(self):
self.clean_state()
self.width = 8.0
self.height = 6.0
self.area = self.width * self.height
self.unit = "smidgen"
self.facing_direction = Direction.up
self.horizontal_direction = Direction.right
self.vertical_direction = Direction.forward
self.position = Position.from_xyz((10.0, 20.0, 30))
self.central_view = Ray(self.position, self.facing_direction)
self.location_expectations = {
(0.0, 0.0): (10.0, 20.0, 30.0),
(1.0, 0.0): (14.0, 20.0, 30.0),
(-1.0, 0.0): (6.0, 20.0, 30.0),
(0.0, 1.0): (10.0, 23.0, 30.0),
(0.0, -1.0): (10.0, 17.0, 30.0),
(1.0, 1.0): (14.0, 23.0, 30.0),
(1.0, -1.0): (14.0, 17.0, 30.0),
(-1.0, 1.0): (6.0, 23.0, 30.0),
(-1.0, -1.0): (6.0, 17.0, 30.0),
}
def when_ray_created_from_origin_endpoint(self):
self.ray = Ray.from_origin_endpoint(self.expected_position, Position.from_xyz(self.endpoint_xyz))
def then_test_with_multiple_location_directions_and_scales(self):
for self.ray_location in [
Position.from_xyz((44.0, 33.0, 2.0)),
Position.from_xyz((-9.0, 3.0, -2.0)),
]:
self.then_test_location_with_multiple_direction_and_scales()
class TestPosition(unittest.TestCase):
"""
Test Position Class
Indirectly tests ContravariantProjector base class
"""
def clean_state(self):
self.position = None
self.w = None
self.x = None
self.y = None
self.z = None
self.wxyz = None
self.xyz = None
def setUp(self):
self.clean_state()
self.w = 1.0
self.x = 3.0
self.y = 4.0
self.z = 5.0
self.wxyz = (self.w, self.x, self.y, self.z)
self.xyz = (self.x, self.y, self.z)
def tearDown(self):
self.clean_state()
def test_position_constructor_requires_tuple(self):
with self.assertRaises(TypeError):
Position("wrong stuff")
def test_position_constructor_requires_4_tuple(self):
with self.assertRaises(ValueError):
Position(self.xyz)
def test_position_constructor_requires_unit_w(self):
with self.assertRaises(ValueError):
Position((1.0001, 2.2, 3.3, 4.4))
def test_position_create_normal(self):
self.when_position_created()
self.then_position_has_expected_values()
def when_position_created(self):
self.position = Position(self.wxyz)
def then_position_has_expected_values(self):
self.assertTrue(self.position.is_position)
self.assertFalse(self.position.is_direction)
self.assertTupleEqual(self.xyz, self.position.xyz)
def test_position_from_xyz_normal(self):
self.when_position_created_from_xyz()
self.then_position_has_expected_values()
def when_position_created_from_xyz(self):
self.position = Position.from_xyz(self.xyz)
def test_position_from_xyz_requires_tuple(self):
with self.assertRaises(TypeError):
Position.from_xyz("wrong stuff")
def test_position_from_xyz_requires_3_tuple(self):
with self.assertRaises(ValueError):
Position.from_xyz(self.wxyz)
def test_position_origin(self):
self.assertTupleEqual((0.0, 0.0, 0.0), Position.origin.xyz)
def test_position_add(self):
self.when_position_created()
result = self.position.add((0.0, 1.0, 2.0, 3.0))
self.assertTupleEqual((4.0, 6.0, 8.0), result.xyz)
def test_position_direction_from_origin(self):
self.when_position_created()
self.direction = self.position.direction_from_origin()
self.assertTupleEqual(self.position.xyz, self.direction.xyz)
def when_distant_ray_is_constructed(self):
self.test_ray = Ray(Position.from_xyz((0.0, 20.0, 30.0)), Direction.up)
def when_position_created(self):
self.position = Position(self.wxyz)
def when_position_created_from_xyz(self):
self.position = Position.from_xyz(self.xyz)
def test_position_from_xyz_requires_tuple(self):
with self.assertRaises(TypeError):
Position.from_xyz("wrong stuff")
def setUp(self):
self.clean_state()
self.expected_center = Position.from_xyz((10.0, 20.0, 30.0))
self.expected_radius = 5.0
def test_position_from_xyz_requires_3_tuple(self):
with self.assertRaises(ValueError):
Position.from_xyz(self.wxyz)
def setUp(self):
self.clean_state()
self.expected_position = Position.from_xyz((10.0, 20.0, 30.0))
self.expected_direction = Direction.from_xyz((0.5, 0.4, 0.3))
self.endpoint_xyz = (10.5, 20.4, 30.3)
self.ten_scale_endpoint_xyz = (15.0, 24.0, 33.0)
