def test_a_shearing_transformation_moves_z_in_proportion_to_y():
transform = transformations.shearing(0, 0, 0, 0, 0, 1)
with tf.Session() as sess:
[expected, actual] = sess.run(
[point(2, 3, 7), transform(point(2, 3, 4))])
assert((expected == actual).all())
def test_difference_of_two_point_is_a_vector():
p1 = point(3, 2, 1)
p2 = point(5, 6, 7)
expected_vector = vector(-2, -4, -6)
with tf.Session() as sess:
actual, expected = sess.run([p1 - p2, expected_vector])
assert ((actual == expected).all())
def test_a_scaling_matrix_applied_to_a_point():
transform = transformations.scaling(2, 3, 4)
p = point(-4, 6, 8)
expected_point = point(-8, 18, 32)
with tf.Session() as sess:
[expected, actual] = sess.run([expected_point, transform(p)])
assert((expected == actual).all())
def test_difference_of_a_vector_and_a_point_is_a_point():
p = point(3, 2, 1)
v = vector(5, 6, 7)
expected_point = point(-2, -4, -6)
with tf.Session() as sess:
actual, expected = sess.run([p - v, expected_point])
assert ((actual == expected).all())
def test_sum_of_vector_and_point_is_a_point():
v = vector(3, -2, 5)
p = point(-2, 3, 1)
expected_point = point(1, 1, 6)
with tf.Session() as sess:
actual, expected = sess.run([v + p, expected_point])
assert ((actual == expected).all())
def test_multiplying_by_the_inverse_of_a_translation_matrix():
transform = transformations.translation(5, -3, 2)
transform = transformations.invert(transform)
p = point(-3, 4, 5)
expected_point = point(-8, 7, 3)
with tf.Session() as sess:
[expected, actual] = sess.run([expected_point, transform(p)])
assert((expected == actual).all())
def test_multiplying__by_a_translation_matrix():
transform = transformations.translation(5, -3, 2)
p = point(-3, 4, 5)
expected_point = point(2, 1, 7)
with tf.Session() as sess:
[expected, actual] = sess.run([expected_point, transform(p)])
assert((expected == actual).all())
def test_the_inverse_of_an_x_rotation_rotates_in_the_opposite_direction():
p = point(0, 1, 0)
half_quarter = transformations.rotation_x(math.pi/4)
inverse = transformations.invert(half_quarter)
expected_rotated = point(0, math.sqrt(2)/2, -math.sqrt(2)/2)
with tf.Session() as sess:
[expected, actual] = sess.run([expected_rotated, inverse(p)])
assert(np.allclose(expected, actual))
def test_chained_transofrmations_must_be_applied_in_reverse_order():
p = point(1, 0, 1)
A = transformations.rotation_x(math.pi/2)
B = transformations.scaling(5, 5, 5)
C = transformations.translation(10, 5, 7)
CBA = transformations.concat(C, B, A)
with tf.Session() as sess:
[expected, actual] = sess.run([point(15, 0, 7), CBA(p)])
assert(np.allclose(expected, actual))
def test_individual_transformations_are_applied_in_sequence():
p = point(1, 0, 1)
A = transformations.rotation_x(math.pi/2)
B = transformations.scaling(5, 5, 5)
C = transformations.translation(10, 5, 7)
with tf.Session() as sess:
[expected_p2, expected_p3, expected_p4, actual_p2, actual_p3, actual_p4] = sess.run(
[point(1, -1, 0), point(5, -5, 0), point(15, 0, 7), A(p), B(A(p)), C(B(A(p)))])
assert(np.allclose(expected_p2, actual_p2))
assert(np.allclose(expected_p3, actual_p3))
assert(np.allclose(expected_p4, actual_p4))
def test_rotating_a_point_around_the_x_axis():
p = point(0, 1, 0)
half_quarter = transformations.rotation_x(math.pi/4)
full_quarter = transformations.rotation_x(math.pi/2)
expected_half_quarter = point(0, math.sqrt(2)/2, math.sqrt(2)/2)
with tf.Session() as sess:
[expected, actual] = sess.run([expected_half_quarter, half_quarter(p)])
assert(np.allclose(expected, actual))
expected_full_quarter = point(0, 0, 1)
with tf.Session() as sess:
[expected, actual] = sess.run([expected_full_quarter, full_quarter(p)])
assert(np.allclose(expected, actual))
def test_a_sphere_behind_a_ary():
xs = Sphere().intersect(Ray(point(0, 0, 5), vector(0, 0, 1)))
with tf.Session() as sess:
[actual_xs] = sess.run([xs])
assert (len(actual_xs) == 2)
assert (actual_xs[0] == -6.0)
assert (actual_xs[1] == -4.0)
def test_a_ray_originates_inside_a_sphere():
xs = Sphere().intersect(Ray(point(0, 0, 0), vector(0, 0, 1)))
with tf.Session() as sess:
[actual_xs] = sess.run([xs])
assert (len(actual_xs) == 2)
assert (actual_xs[0] == -1.0)
assert (actual_xs[1] == 1.0)
def test_a_ray_misses_a_sphere():
xs = Sphere().intersect(Ray(point(0, 2, -5), vector(0, 0, 1)))
with tf.Session() as sess:
[actual_xs] = sess.run([xs])
assert (len(actual_xs) == 2)
assert (math.isnan(actual_xs[0]))
assert (math.isnan(actual_xs[1]))
def test_a_ray_intersects_a_sphere_at_a_tangent():
xs = Sphere().intersect(Ray(point(0, 1, -5), vector(0, 0, 1)))
with tf.Session() as sess:
[actual_xs] = sess.run([xs])
assert (len(actual_xs) == 2)
assert (actual_xs[0] == 5.0)
assert (actual_xs[1] == 5.0)
def test_a_point_is_an_array_with_w_set_to_1():
actual_point = point(4.3, -4.2, 3.1)
expected_point = tf.constant(np.array([4.3, -4.2, 3.1, 1.0]),
dtype=tf.float32)
with tf.Session() as sess:
actual, expected = sess.run([actual_point, expected_point])
assert ((actual == expected).all())
def test_translating_a_ray():
origin = point(1, 2, 3)
direction = vector(0, 1, 0)
r = Ray(origin, direction)
expected_origin = point(4, 6, 8)
expected_direction = vector(0, 1, 0)
m = tftracer.transformations.translation(3, 4, 5)
with tf.Session() as sess:
[actual_origin, actual_direction, expected_origin,
expected_direction] = sess.run([
r.transform(m).origin,
r.transform(m).direction, expected_origin, expected_direction
])
assert (np.allclose(actual_origin, expected_origin))
assert (np.allclose(actual_direction, expected_direction))
def test_intersecting_a_scaled_sphere_with_a_ray():
r = Ray(point(0., 0., -5.), vector(0., 0., 1.))
s = Sphere(transformations.scaling(2, 2, 2))
xs = s.intersect(r)
with tf.Session() as sess:
actual_xs = sess.run(xs)
assert (len(actual_xs) == 2)
assert (actual_xs[0] == 3)
assert (actual_xs[1] == 7)
def perform_intersection(origin, direction):
sphere_to_ray = origin - point(0, 0, 0)
a = dot(direction, direction)
b = 2 * dot(direction, sphere_to_ray)
c = dot(sphere_to_ray, sphere_to_ray) - 1
delta = b**2 - 4 * a * c
t1 = (-b - tf.sqrt(delta)) / tf.scalar_mul(2, a)
t2 = (-b + tf.sqrt(delta)) / tf.scalar_mul(2, a)
return tf.stack([t1, t2])
def test_computing_a_point_from_a_distance():
origin = point(2, 3, 4)
direction = vector(1, 0, 0)
r = Ray(origin, direction)
with tf.Session() as sess:
[
expected1, expected2, expected3, expected4, actual1, actual2,
actual3, actual4
] = sess.run([
point(2, 3, 4),
point(3, 3, 4),
point(1, 3, 4),
point(4.5, 3, 4),
r.position(0),
r.position(1),
r.position(-1),
r.position(2.5)
])
assert ((expected1 == actual1).all())
assert ((expected2 == actual2).all())
assert ((expected3 == actual3).all())
assert ((expected4 == actual4).all())
