def test_ray2(self):
origin = Point(2, 3, 4)
direction = Vector(1, 0, 0)
r = Ray(origin, direction)
self.assertTrue(Point(2, 3, 4).equals(r.position(0)))
self.assertTrue(Point(3, 3, 4).equals(r.position(1)))
self.assertTrue(Point(1, 3, 4).equals(r.position(-1)))
self.assertTrue(Point(4.5, 3, 4).equals(r.position(2.5)))
def prepare_computations(
intersection: Intersection,
ray: Ray,
xs: Iterable[Intersection] = None) -> 'Computations':
comps = Computations(intersection.t, intersection.object)
comps.point = Ray.position(ray, comps.t)
comps.eyev = -ray.direction
comps.normalv = comps.object.normal_at(comps.point, intersection)
if Vector.dot(comps.normalv, comps.eyev) < 0:
comps.inside = True
comps.normalv = -comps.normalv
else:
comps.inside = False
comps.reflectv = Vector.reflect(ray.direction, comps.normalv)
comps.over_point = comps.point + comps.normalv * Constants.epsilon
comps.under_point = comps.point - comps.normalv * Constants.epsilon
# default parameter
if xs is None:
xs = [intersection]
containers: Iterable[Shape] = []
for i in xs:
if i == intersection:
if len(containers) == 0:
comps.n1 = 1.0
else:
comps.n1 = containers[-1].material.refractive_index
if i.object in containers:
containers.remove(i.object)
else:
containers.append(i.object)
# if i == hit:
if i == intersection:
if len(containers) == 0:
comps.n2 = 1.0
else:
comps.n2 = containers[-1].material.refractive_index
break
return comps
def test_ray_position(self):
r = Ray(Point(2, 3, 4), Vector(1, 0, 0))
self.assertEqual(r.position(0.0), Point(2, 3, 4))
self.assertEqual(r.position(1.0), Point(3, 3, 4))
self.assertEqual(r.position(-1.0), Point(1, 3, 4))
self.assertEqual(r.position(2.5), Point(4.5, 3, 4))
def test_compute_point(self):
r = Ray(Point(2, 3, 4), Vector(1, 0, 0))
self.assertEqual(Ray.position(r, 0), Point(2, 3, 4))
self.assertEqual(Ray.position(r, 1), Point(3, 3, 4))
self.assertEqual(Ray.position(r, -1), Point(1, 3, 4))
self.assertEqual(Ray.position(r, 2.5), Point(4.5, 3, 4))
s = input("Press any key...")
for x in range(W):
for y in range(H):
p = m * Point(x, y, 0)
ray = Ray(eye, (p - eye).norm())
xs = sphere.intersect(ray)
if xs:
dprint(f"\nSphere hit at {x}, {y}...")
dprint("p: {}".format(p))
dprint("ray: {}".format(ray))
dprint("xs: {}".format(str(xs)))
hit = intersection.hit(xs)
dprint("hit: {}".format(hit))
point = ray.position(hit.t)
dprint("point: {}".format(point))
normal = hit.object.normal(point)
dprint("normal: {}".format(normal))
eyev = -ray.direction
dprint("eyev: {}".format(eyev))
c = lighting(hit.object.material,
light,
point,
eyev,
normal,
components=True)
dprint("color: {}".format(c))
color = c[0] + c[1] + c[2]
pix[x, y] = color.rgb()
pause()
for x in range(canvas_pixels):
world_x = -half + pixel_size * x
position = Point(world_x, world_y, wall_z)
r = Ray(ray_origin, Vector.normalize(position - ray_origin))
# shrink along y-axis
# r = r.transform(Transformations.scaling(1, 0.5, 1))
# shrink along x-axis
# r = r.transform(Transformations.scaling(0.5, 1, 1))
# shrink and rotate
# r = r.transform(Transformations.rotation_z(math.pi / 4)).transform(Transformations.scaling(0.5, 1, 1))
# shrink and skew
# r = r.transform(Transformations.shearing(1, 0, 0, 0, 0, 0)).transform(Transformations.scaling(0.5, 1, 1))
xs = shape.intersect(r)
hit = Intersection.hit(xs)
if hit is not None:
point = Ray.position(r, hit.t)
normal = shape.normal_at(point)
eye = -r.direction
color = PointLight.lighting(hit.object.material, hit.object,
light, point, eye, normal, False)
canvas.write_pixel(x, y, color)
canvas.canvas_to_ppm()
# sphere.set_transform(rotate_z(pi/6)* scale(1, 0.5, 1)*shear(1, 0, 0, 0, 0, 0))
camera = Point(0, 0, -5)
wall_z = 10
wall_size = 7
canvas_pixels = 100
pixel_size = wall_size / canvas_pixels
half = wall_size / 2
for j in range(HEIGHT):
print(j)
y = half - pixel_size * j
for i in range(WIDTH):
x = -half + pixel_size*i
target = Point(x, y, wall_z)
ray = Ray(camera, (target-camera).normalize())
intersections = sphere.intersect(ray)
intersection = intersections.hit()
if intersection is not None:
point = ray.position(intersection.t)
normal = intersection.obj.normal_at(point)
eye = -ray.direction
color = intersection.obj.material.lighting(light, point, eye, normal)
c.write_pixel(i, j, color)
# print(j, "target: ", target, obj.t)
with open('test_016.ppm', 'w') as fout:
c.to_ppm(fout)
t2 = time()
print("Time spent: {:.2f}s".format(t2-t1))
