def test_dot_product(self):
a = vector(1, 2, 3)
b = vector(2, 3, 4)
self.assertEqual(dot(a, b), 20, 'The dot product should be equal 20')
self.assertEqual(dot(b, a), 20, 'The dot product should be equal 20')
def test_tuple_general(self):
ap = point(1.1, 4.5, 4.6)
av = vector(0, 2.1, 3.3)
ap2 = point(1.1, 6.6, 7.9)
av2 = vector(1, 2, 3)
av3 = vector(1, -0.1, -0.3)
ap3 = point(-1.1, -4.5, -4.6)
self.assertEqual(av + av3, av2, 'These shoud be equal')
self.assertEqual(ap + av, ap2, 'These shoud be equal')
self.assertEqual(ap2 - ap, av, 'These should be equal')
self.assertEqual(ap2 - av, ap, 'These should be equal')
self.assertEqual(av2 - av, av3, 'These should be equal')
self.assertEqual(-ap, ap3, 'These should be equal')
#multiplication and division
ascalar = 3.5
ascalar2 = 0.5
scalar3 = 2
ap = point(1, 2, 4.4)
ap2 = point(3.5, 7, 15.4)
ap3 = point(0.5, 1, 2.2)
self.assertEqual(ascalar * ap, ap2,
'This multiplication should be equal')
self.assertEqual(ascalar2 * ap, ap3,
'This multiplication should be equal')
self.assertEqual(ap / scalar3, ap3, 'This division shouldbe equal')
def test_reflection(self):
"""Refleting a vector approaching at 45d"""
v_var = vector(1, -1, 0)
n_var = vector(0, 1, 0)
r_var = reflect(v_var, n_var)
self.assertEqual(r_var, vector(1, 1, 0), 'The 45 reflection failed.')
def test_scaling_vector(self):
transform = scaling(2, 3, 4)
v = vector(-4, 6, 8)
v_out = vector(-8, 18, 32)
self.assertEqual(transform * v, v_out, 'The scaling of vector failed')
def test_reflection_slanted(self):
"""Tests a reflecting a vector off a slanted surface"""
v_var = vector(0, -1, 0)
n_var = vector(sqrt(2) / 2, sqrt(2) / 2, 0)
r_var = reflect(v_var, n_var)
self.assertEqual(r_var, vector(1, 0, 0),
"The slanted reflection failed.")
def test_cross_product(self):
a = vector(1, 2, 3)
b = vector(2, 3, 4)
self.assertEqual(cross(a, b), vector(-1, 2, -1),
'This cros product should be (-1,2,-1)')
self.assertEqual(cross(b, a), vector(1, -2, 1),
'This cros product should be (1,-2,1)')
def test_lightning1(self):
"""Lighting with the eye between the light and the surface."""
eyev = vector(0, 0, -1)
normalv = vector(0, 0, -1)
light = PointLight(point(0, 0, -10), color(1, 1, 1))
result = lighting(self.m_var, light, self.position, eyev, normalv)
self.assertEqual(result, color(1.9, 1.9, 1.9), \
'The lighting function failed.')
def test_lightning4(self):
"""Lighting with the light and the eye 45 degrees from the suface line"""
eyev = vector(0, -sqrt(2) / 2, -sqrt(2) / 2)
normalv = vector(0, 0, -1)
light = PointLight(point(0, 10, -10), color(1, 1, 1))
result = lighting(self.m_var, light, self.position, eyev, normalv)
self.assertEqual(result, color(1.6364, 1.6364, 1.6364), \
'The lighting function failed.')
def test_lightning5(self):
"""Lighting with the light hidden behind the surfice"""
eyev = vector(0, 0, -1)
normalv = vector(0, 0, -1)
light = PointLight(point(0, 0, 10), color(1, 1, 1))
result = lighting(self.m_var, light, self.position, eyev, normalv)
self.assertEqual(result, color(0.1, 0.1, 0.1), \
'The lighting function failed.')
def test_inverse_scaling(self):
transform = scaling(2, 3, 4)
inv = inverse(transform)
v = vector(-4, 6, 8)
v_out = vector(-2, 2, 2)
self.assertEqual(inv * v, v_out, 'The inverse scaling failed')
def test_norm_vectors(self):
av = vector(4, 0, 0)
av2 = vector(1, 2, 3)
av3 = vector(0.26726, 0.53452, 0.80178)
av4 = vector(1, 0, 0)
self.assertEqual(normalize(av), av4,
'The normalization should be (1,0,0)')
self.assertEqual(
normalize(av2), av3,
'The normalization should be (0.26726, 0.53452, 0.80178)')
self.assertEqual(abs(normalize(av2)), 1,
'The normalized vector shoud be 1')
def test_translation_vector(self):
transform = translation(5, -3, 2)
v = vector(-3, 4, 5)
self.assertEqual(transform * v, v,
'The translation of a vector failed')
def test_sphere_nonaxial(self):
"""Test sphere normal in nonaxial direction"""
s_var = sphere()
n_var = normal_at(s_var, point(sqrt(3) / 3, sqrt(3) / 3, sqrt(3) / 3))
self.assertEqual(n_var, vector(sqrt(3)/3, sqrt(3)/3, sqrt(3)/3),\
"Sphere normal in z direction failed.")
def test_sphere_z(self):
"""Test sphere normal in z direction"""
s_var = sphere()
n_var = normal_at(s_var, point(0, 0, 1))
self.assertEqual(n_var, vector(0, 0, 1),
"Sphere normal in z direction failed.")
def test_sphere_miss(self):
r = ray(point(0, 2, -5), vector(0, 0, 1))
s = sphere()
xs = intersect(s, r)
self.assertEqual(len(xs), 0, 'There should be no intersections ')
def test_sphere_transformed2(self):
r = ray(point(0, 0, -5), vector(0, 0, 1))
s = sphere()
s.set_transform(translation(5, 0, 0))
xs = intersect(s, r)
self.assertEqual(len(xs), 0, 'There sould be no intersection')
def test_sphere_translated(self):
"""Tests a sphere normal vector under translation"""
s_var = sphere()
s_var.set_transform(translation(0, 1, 0))
n_var = normal_at(s_var, point(0, 1.70711, -0.70711))
self.assertEqual(n_var, vector(0, 0.70711, -0.70711),\
'The normal in the translated sphere is wrong.')
def test_ray(self):
origin = point(1, 2, 3)
direction = vector(4, 5, 6)
r = ray(origin, direction)
self.assertEqual(r.origin, origin, 'The origin of ray failed')
self.assertEqual(r.direction, direction, 'The direction of ray failed')
def test_position(self):
r = ray(point(2, 3, 4), vector(1, 0, 0))
self.assertEqual(position(r, 0), point(2, 3, 4), 'Ray position failed')
self.assertEqual(position(r, 1), point(3, 3, 4), 'Ray position failed')
self.assertEqual(position(r, -1), point(1, 3, 4),
'Ray position failed')
self.assertEqual(position(r, 2.5), point(4.5, 3, 4),
'Ray position failed')
def test_sphere_intersect_group(self):
r = ray(point(0, 0, -5), vector(0, 0, 1))
s = sphere()
xs = intersect(s, r)
self.assertEqual(len(xs), 2, 'There should be 2 intersections')
self.assertEqual(xs[0].object, s, 'The intersection object failed')
self.assertEqual(xs[1].object, s, 'The intersection object failed')
def test_transformation(self):
r = ray(point(1, 2, 3), vector(0, 1, 0))
m = translation(3, 4, 5)
r2 = transform(r, m)
self.assertEqual(r2.origin, point(4, 6, 8),
'The ray translation failed')
self.assertEqual(r2.direction, vector(0, 1, 0),
'The ray translation failed')
m2 = scaling(2, 3, 4)
r3 = transform(r, m2)
self.assertEqual(r3.origin, point(2, 6, 12), 'The ray scaling failed')
self.assertEqual(r3.direction, vector(0, 3, 0),
'The ray scaling failed')
def test_sphere(self):
r = ray(point(0, 0, -5), vector(0, 0, 1))
s = sphere()
xs = intersect(s, r)
self.assertEqual(len(xs), 2, 'There should be 2 intersections')
self.assertEqual(xs[0].t, 4.0, 't=4 should intersect')
self.assertEqual(xs[1].t, 6.0, 't=6 should intersect')
def test_sphere_transformed(self):
"Tests the sphere normal vector under a transformation"
s_var = sphere()
m_var = scaling(1, 0.5, 1) * rotation_z(pi / 5)
s_var.set_transform(m_var)
n_var = normal_at(s_var, point(0, sqrt(2) / 2, -sqrt(2) / 2))
self.assertEqual(n_var, vector(0, 0.97014, -0.24254),\
'The normal of an sphere transformed is wrong.')
def test_sphere_behind(self):
r = ray(point(0, 0, 5), vector(0, 0, 1))
s = sphere()
xs = intersect(s, r)
self.assertEqual(len(xs), 2,
'There should be 2 intersections (virtual)')
self.assertEqual(xs[0].t, -6.0, 't=-6 should be an intersection time')
self.assertEqual(xs[1].t, -4.0, 't=-4 should be an intersection time')
def test_sphere_inner(self):
r = ray(point(0, 0, 0), vector(0, 0, 1))
s = sphere()
xs = intersect(s, r)
self.assertEqual(len(xs), 2,
'There should be 2 intersections (virtual)')
self.assertEqual(xs[0].t, -1.0, 't=-1 should be an intersection time')
self.assertEqual(xs[1].t, 1.0, 't=1 should be an intersection time')
def test_sphere_transformed(self):
r = ray(point(0, 0, -5), vector(0, 0, 1))
s = sphere()
s.set_transform(scaling(2, 2, 2))
xs = intersect(s, r)
self.assertEqual(len(xs), 2, 'There should have been 2 intersections')
self.assertEqual(xs[0].t, 3, 't=3 should have been present')
self.assertEqual(xs[1].t, 7, 't=4 should have been present')
def test_function_vector(self):
av = vector(1, 1, 1)
atuple = rtTuple(1, 1, 1, 0)
scalar = math.sqrt(3)
self.assertEqual(av, atuple, 'This should be a point')
self.assertEqual(abs(av), scalar, 'The abs value should be {scalar}')
max_y = max(canvas_list, key=lambda loc: loc[1])[1]+1
c = canvas(max_x,max_y)
background_c = color(0.9,0.9,0.9)
c.set_one_color(background_c)
for pt in canvas_list:
x = pt[0]
y = max_y-pt[1]-1
pt2 = x,y
c[pt2] = color(1,0,0)
return c
p0 = point(0,0,0)
v0 = normalize(vector(1,4,0)) * 20
env = enviroment(vector(0,-1,0),vector(0.5,0,0))
tt = trajectory(v0,p0,env,0.001)
c = tt.canvas()
ppm = c.to_PPM()
with open('image.ppm','w') as f:
f.write(ppm)
np_trajectory = np.array(tt.tracjectory)
import matplotlib.pyplot as plt
light_color = color(1, 1, 1)
light = PointLight(light_position, light_color)
s = sphere()
s.material = Material()
s.material.color = color(1, 0.2, 1)
trans = scaling(200, 200, 1) * translation(0, 0, 800)
s.set_transform(trans)
print('{:04d},{:04d}'.format(0, 0), end='\r')
h = False
for i in range(CANVAS_W):
#print()
for j in range(CANVAS_H):
print('{:04d},{:04d}'.format(i, j), end='\r')
r = ray(point(0, 0, 0), vector(i + pad_x, -pad_y - j, CANVAS_DISTANCE))
inter = intersect(s, r)
if hit(inter) != None:
c[i, j] = HIT_COLOR
h = True
#if h:
#print('\033[48;2;255;0;0m \033[0m', end='', flush=True)
#else:
#print('\033[48;2;230;230;230m \033[0m', end='', flush=True)
h = False
PPM = c.to_PPM()
with open('shadow_sphere.ppm', 'w') as f:
f.write(PPM)
