#!/usr/bin/env python3
"""
A simple raytracer that supports spheres with configurable color properties
(like the base color and specular coefficient).
"""
import math
try:
import PIL
except Exception:
PIL = None
print('PIL import failed')
class Scene:
"""
The scene that gets rendered. Contains information like the camera
position, the different objects present, etc.
"""
def __init__(self, camera, objects, lights, width, height):
self.camera = camera
self.objects = objects
self.lights = lights
self.width = width
self.height = height
def render(self):
"""
Return a `self.height`x`self.width` 2D array of `Color`s representing
the color of each pixel, obtained via ray-tracing.
"""
pixels = [
[Color() for _ in range(self.width)] for _ in range(self.height)]
for y in range(self.height):
for x in range(self.width):
ray_direction = Point(x, y) - self.camera
ray = Ray(self.camera, ray_direction)
pixels[y][x] = self._trace_ray(ray)
return pixels
def _trace_ray(self, ray, depth=0, max_depth=5):
"""
Recursively trace a ray through the scene, returning the color it
accumulates.
"""
color = Color()
if depth >= max_depth:
return color
intersection = self._get_intersection(ray)
if intersection is None:
return color
obj, dist = intersection
intersection_pt = ray.point_at_dist(dist)
surface_norm = obj.surface_norm(intersection_pt)
# ambient light
color += obj.material.color * obj.material.ambient
# lambert shading
for light in self.lights:
pt_to_light_vec = (light - intersection_pt).normalize()
pt_to_light_ray = Ray(intersection_pt, pt_to_light_vec)
if self._get_intersection(pt_to_light_ray) is None:
lambert_intensity = surface_norm * pt_to_light_vec
if lambert_intensity > 0:
color += obj.material.color * obj.material.lambert * \
lambert_intensity
# specular (reflective) light
reflected_ray = Ray(
intersection_pt, ray.direction.reflect(surface_norm).normalize())
color += self._trace_ray(reflected_ray, depth + 1) * \
obj.material.specular
return color
def _get_intersection(self, ray):
"""
If ray intersects any of `self.objects`, return `obj, dist` (the object
itself, and the distance to it). Otherwise, return `None`.
"""
intersection = None
for obj in self.objects:
dist = obj.intersects(ray)
if dist is not None and \
(intersection is None or dist < intersection[1]):
intersection = obj, dist
return intersection
class Vector:
"""
A generic 3-element vector. All of the methods should be self-explanatory.
"""
def __init__(self, x=0, y=0, z=0):
self.x = x
self.y = y
self.z = z
def norm(self):
return math.sqrt(sum(num * num for num in self))
def normalize(self):
return self / self.norm()
def reflect(self, other):
other = other.normalize()
return self - 2 * (self * other) * other
def __str__(self):
return "Vector({}, {}, {})".format(*self)
def __add__(self, other):
return Vector(self.x + other.x, self.y + other.y, self.z + other.z)
def __sub__(self, other):
return Vector(self.x - other.x, self.y - other.y, self.z - other.z)
def __mul__(self, other):
if isinstance(other, Vector):
return self.x * other.x + self.y * other.y + self.z * other.z;
else:
return Vector(self.x * other, self.y * other, self.z * other)
def __rmul__(self, other):
return self.__mul__(other)
def __truediv__(self, other):
return Vector(self.x / other, self.y / other, self.z / other)
def __pow__(self, exp):
if exp != 2:
raise ValueError("Exponent can only be two")
else:
return self * self
def __iter__(self):
yield self.x
yield self.y
yield self.z
# Since 3D points and RGB colors are effectively 3-element vectors, we simply
# declare them as aliases to the `Vector` class to take advantage of all its
# defined operations (like overloaded addition, multiplication, etc.) while
# improving readability (so we can use `color = Color(0xFF)` instead of
# `color = Vector(0xFF)`).
Point = Vector
Color = Vector
class Sphere:
"""
A sphere object.
"""
def __init__(self, origin, radius, material):
self.origin = origin
self.radius = radius
self.material = material
def intersects(self, ray):
"""
If `ray` intersects sphere, return the distance at which it does;
otherwise, `None`.
"""
sphere_to_ray = ray.origin - self.origin
b = 2 * ray.direction * sphere_to_ray
c = sphere_to_ray ** 2 - self.radius ** 2
discriminant = b ** 2 - 4 * c
if discriminant >= 0:
dist = (-b - math.sqrt(discriminant)) / 2
if dist > 0:
return dist
def surface_norm(self, pt):
"""
Return the surface normal to the sphere at `pt`.
"""
return (pt - self.origin).normalize()
class Material:
def __init__(self, color, specular=0.5, lambert=1, ambient=0.2):
self.color = color
self.specular = specular
self.lambert = lambert
self.ambient = ambient
class Ray:
"""
A mathematical ray.
"""
def __init__(self, origin, direction):
self.origin = origin
self.direction = direction.normalize()
def point_at_dist(self, dist):
return self.origin + self.direction * dist
def pixels_to_ppm(pixels):
"""
Convert `pixels`, a 2D array of `Color`s, into a PPM P3 string.
"""
header = "P3 {} {} 255\n".format(len(pixels[0]), len(pixels))
img_data_rows = []
for row in pixels:
pixel_strs = [
" ".join([str(int(color)) for color in pixel]) for pixel in row]
img_data_rows.append(" ".join(pixel_strs))
return header + "\n".join(img_data_rows)
if __name__ == "__main__":
print("Let's trace some rays!")
objects = [
Sphere(
Point(150, 120, -20), 80, Material(Color(0xFF, 0, 0),
specular=0.2)),
Sphere(
Point(420, 120, 0), 100, Material(Color(0, 0, 0xFF),
specular=0.8)),
Sphere(Point(320, 240, -40), 50, Material(Color(0, 0xFF, 0))),
Sphere(
Point(300, 200, 200), 100, Material(Color(0xFF, 0xFF, 0),
specular=0.8)),
Sphere(Point(300, 130, 100), 40, Material(Color(0xFF, 0, 0xFF))),
Sphere(Point(300, 1000, 0), 700, Material(Color(0xFF, 0xFF, 0xFF),
lambert=0.5)),
]
lights = [Point(200, -100, 0), Point(600, 200, -200)]
camera = Point(200, 200, -400)
scene = Scene(camera, objects, lights, 600, 400)
pixels = scene.render()
with open("image.ppm", "w") as img_file:
img_file.write(pixels_to_ppm(pixels))
print("Done!")