def render():
(w, h) = (640, 480)
camera = Camera(w, h, fov=np.pi / 6)
# Materials
mat_base = Material([0.2, 0.2, 0.2])
mat_s1 = Material(colors.P_Brass3, finish=Finish(transparent=True, ior=1.1))
mat_s2 = Material(colors.CornflowerBlue, finish=Finish(reflection=0.1))
mat_s3 = Material(colors.ForestGreen, finish=Finish(reflection=0.1))
mat_s4 = Material(colors.GreenCopper, finish=Finish(reflection=0.1))
# Scene Elements + Scene
se_ls = LightSourcePoint([-5., 10., 20.], intensity=1000.)
se_base = SceneElement(Sphere([0.0, -10004., 20.], 10000.), mat_base)
se_s1 = SceneElement(Sphere([0., 0., 20.], 4.), mat_s1)
se_s2 = SceneElement(Sphere([5.0, -1., 15.], 2.), mat_s2)
se_s3 = SceneElement(Sphere([5.0, 0, 25.], 3.), mat_s3)
se_s4 = SceneElement(Sphere([-5.5, 0, 15.], 3.), mat_s4)
scene = Scene([se_ls, se_base, se_s1, se_s2, se_s3, se_s4])
# Render
rt = RayTracer(camera, scene)
traced = rt.render()
plt.imshow(traced); plt.show()
def render():
(w, h) = (640, 480)
camera = Camera(w, h, fov=np.pi / 6)
# Materials
base_finish = SoftDull
base_finish.reflection = 0.1
mat_base = Material(colors.P_Chrome3, finish=base_finish)
mat_s1 = Material(colors.P_Brass3)
se_ls = LightSourcePoint([-1., 5., 35.],
intensity=200.,
emission_color=[2., 2., 2.])
se_base = SceneElement(Plane([0.0, -4.0, 20.], [0., 1., 0.]), mat_base)
se_s1 = SceneElement(Sphere([0., 0., 40.], 4.), mat_s1)
scene = Scene([se_ls, se_base, se_s1])
# scene = Scene([se_ls, se_base])
# Render
rt = RayTracer(camera, scene)
traced = rt.render()
plt.imshow(traced)
plt.show()
def render():
(w, h) = (640, 480)
camera = Camera(w, h, fov=np.pi / 6)
# Materials
mat_base = Material([1., 1., 1.])
# mat_s1 = Material(colors.Aquamarine, finish=Finish(diffuse=0.7, ambient=0.1, specular=0.8, roughness=1./120, transparent=True, ior=1.5))
# mat_s1 = Material(colors.Glass_Winebottle, finish=Finish(diffuse=0.7, ambient=0.1, specular=0.8, roughness=1./120, transparent=True, ior=1.5))
mat_s1 = Material(colors.P_Silver3, finish=Finish(diffuse=0.7, ambient=0.1, specular=0.8, roughness=1./120, transparent=True, ior=1.5))
mat_s2 = Material(colors.P_Copper3, finish=Medium, metallic=True)
mat_s3 = Material(colors.P_Chrome3, finish=Medium, metallic=True)
mat_s4 = Material(colors.P_Brass3, finish=Medium, metallic=True)
# Scene Elements + Scene
se_ls = LightSourcePoint([-5., 15., 20.], intensity=1000., emission_color=[2., 2., 2.])
se_base = SceneElement(Sphere([0.0, -10004., 20.], 10000.), mat_base)
se_s1 = SceneElement(Sphere([0., 0., 20.], 4.), mat_s1)
se_s2 = SceneElement(Sphere([5.0, -1., 15.], 2.), mat_s2)
se_s3 = SceneElement(Sphere([3.0, 0, 22.], 2.), mat_s3)
se_s4 = SceneElement(Sphere([-5.5, 0, 15.], 3.), mat_s4)
scene = Scene([se_ls, se_base, se_s1, se_s2, se_s3, se_s4])
# Render
rt = RayTracer(camera, scene, num_bounces=5)
traced = rt.render()
plt.imshow(traced); plt.show()
def render():
# with open('examples/cube.obj') as f:
with open('examples/teapot.obj') as f:
lines = f.readlines()
# simple (read stupid) parser for obj files
V = []
F = []
for line in lines:
line = line.replace(' ', ' ')
if line[0:2] == "v ":
V.append(map(float, line.strip().split(' ')[1:]))
elif line[0:2] == "f ":
f = line.strip().split(' ')[1:]
f = map(lambda x: int(x.split('/')[0])-1, f)
F.extend(f)
n_polys = len(F) / 3
fi = [3 for _ in range(n_polys)]
# n_polys, fi, V, F = down_sample(n_polys, fi, V, F)
tm = TriangleMesh(n_polys, fi, F, np.array(V).T, clockwise=True)
(w, h) = (640, 480)
camera = Camera(w, h, fov=np.pi / 2)
camera.translate([0, 0, -100])
# camera = Camera(w, h, fov=np.pi / 3)
# Materials
mat_base = Material([0.2, 0.2, 0.2])
# mat_s1 = Material(colors.NeonPink, diffuse=0.7, ambient=0.1, specular=0.8, roughness=1./120, reflection=0.)
mat_s1 = Material(colors.NeonPink, finish=VerySoftDull)
se_ls = LightSourceDirectional([1, -1, 0], intensity=2., emission_color=[1., 1., 1.])
se_base = SceneElement(Sphere([0.0, -10004., 20.], 10000.), mat_base)
se_tm = SceneElement(tm, mat_s1)
scene = Scene([se_ls, se_tm])
# Render
rt = RayTracer(camera, scene, num_bounces=0, background_color=0.5*np.ones((3, 1)))
traced = rt.render()
plt.imshow(traced); plt.show()
import ipdb; ipdb.set_trace()
def render():
(w, h) = (640, 480)
camera = Camera(w, h, fov=np.pi / 6)
# Materials
mat_base = Material(colors.DimGray)
mat_s1 = Material(colors.P_Silver3,
finish=Finish(reflection=0.,
specular=0.8,
roughness=1. / 20))
mat_s2 = Material(colors.P_Brass3,
finish=Finish(ambient=0.25,
diffuse=0.5,
transparent=True,
specular=0.8,
roughness=1. / 80,
ior=1.5),
metallic=True)
se_ls = LightSourcePoint([-5., 10., 20.], intensity=1000.)
se_ls2 = LightSourceDirectional([1., -1., 1.], intensity=0.5)
se_base = SceneElement(Sphere([0.0, -10004., 20.], 10000.), mat_base)
se_s1 = SceneElement(Sphere([-3., -1., 20.], 2.), mat_s1)
se_s2 = SceneElement(Sphere([0, -1., 35.], 2.), mat_s1)
se_s3 = SceneElement(Sphere([4., -1., 40.], 2.), mat_s1)
se_s4 = SceneElement(Sphere([9., -1., 55.], 2.), mat_s1)
scene = Scene([se_ls, se_ls2, se_base, se_s1, se_s2, se_s3, se_s4])
# Render
rt = RayTracer(camera, scene)
traced_nodov = rt.render()
traced = rt.render_dov([-3., -1., 20.], num_samples=8)
# traced = rt.render_dov([0, -1., 35.], num_samples=8)
# traced = rt.render_dov([4., -1., 40.], num_samples=8)
# traced = rt.render_dov([9., -1., 55.], num_samples=4)
# traced = rt.render()
plt.subplot(211)
plt.imshow(traced_nodov)
plt.subplot(212)
plt.imshow(traced)
plt.show()
def render():
(w, h) = (640 * 2, 480 * 2)
camera = Camera(w, h, fov=np.pi / 6)
# Materials
mat_base = Material([1., 1., 1.], finish=Medium)
mat_s1 = Material(colors.Sapphire2, finish=HardPolished)
mat_s2 = Material(colors.Amber3, finish=HardPolished)
mat_s3 = Material(colors.Tourmaline1, finish=HardPolished)
mat_s4 = Material(colors.Ruby4, finish=HardPolished)
mat_s5 = Material(colors.Emerald5, finish=HardPolished)
mat_s6 = Material(colors.Citrine2, finish=HardPolished)
mat_s7 = Material(colors.Azurite3, finish=HardPolished)
mat_s8 = Material(colors.Amethyst3, finish=HardPolished)
mat_s9 = Material(colors.P_Brass3, finish=HardPolished, metallic=True)
# Scene Elements + Scene
se_ls = LightSourcePoint([-5., 15., 15.],
intensity=1000.,
emission_color=[2., 2., 2.])
se_base = SceneElement(Sphere([0.0, -10004., 20.], 10000.), mat_base)
se_s1 = SceneElement(Sphere([0., 0., 20.], 4.), mat_s1)
se_s2 = SceneElement(Sphere([-7., -2., 23.], 2.), mat_s2)
se_s3 = SceneElement(Sphere([-5., -3., 27.], 1.), mat_s3)
se_s4 = SceneElement(Sphere([-10., 3., 50.], 7.), mat_s4)
se_s5 = SceneElement(Sphere([22., 3., 50.], 7.), mat_s5)
se_s6 = SceneElement(Sphere([15., -3., 35.], 1.), mat_s6)
se_s7 = SceneElement(Sphere([10., -1., 33.], 3.), mat_s7)
se_s8 = SceneElement(Sphere([5., -2., 25.], 2.), mat_s8)
se_s9 = SceneElement(Sphere([4., -3., 15.], 1.), mat_s9)
scene = Scene([
se_ls, se_base, se_s1, se_s2, se_s3, se_s4, se_s5, se_s6, se_s7, se_s8,
se_s9
])
# Render
rt = RayTracer(camera, scene, num_bounces=10)
traced = rt.render()
# plt.imshow(traced); plt.show()
misc.imsave('renders/pretty2.png', traced)
def __init__(self, scene, screen_width=100, screen_height=100):
self.scene = scene
self.ray_generator = RayGenerator(
self.scene.direction,
screen_width,
screen_height
)
self.ray_tracer = RayTracer(scene)
self.screen = Screen(screen_width, screen_height)
def render():
(w, h) = (640, 480)
camera = Camera(w, h, fov=np.pi / 6)
# Materials
base_finish = SoftDull
base_finish.reflection = 0.5
mat_base = Material(colors.P_Chrome1, finish=base_finish)
mat_f = VeryHardPolished
mat_f.reflection = 0.1
mat_s1 = Material(colors.Ruby1, finish=mat_f)
mat_s2 = Material(colors.Emerald1, finish=mat_f)
mat_s3 = Material(colors.Aquamarine1, finish=mat_f)
# se_ls = LightSourcePoint([-5., 15., 20.], intensity=1000., emission_color=[2., 2., 2.])
se_ls = LightSourceDirectional([1, -1, 0],
intensity=2.,
emission_color=[1., 1., 1.])
se_base = SceneElement(Plane([0.0, -4.0, 20.], [0., 1., 0.]), mat_base)
cone = Cone([5., 0., 40.], 2., length=4, closed=True)
cone.rotate(np.pi / 2. + np.pi / 4, [0, 1, 0])
cylinder = Cylinder([2., 0., 40.], 2., length=2, closed=True)
cylinder.rotate(-np.pi / 4, [0, 1, 0])
se_s1 = SceneElement(cone, mat_s1)
se_s2 = SceneElement(cylinder, mat_s2)
se_s3 = SceneElement(Sphere([-5., 0., 40.], 2.), mat_s3)
scene = Scene([se_ls, se_base, se_s1, se_s2, se_s3])
# Render
rt = RayTracer(camera, scene)
traced = rt.render()
plt.imshow(traced)
plt.show()
def render():
(w, h) = (640, 480)
camera = Camera(w, h, fov=np.pi / 6)
# Materials
mat_base = Material(colors.DimGray)
mat_s1 = Material(colors.CadetBlue,
finish=Finish(reflection=0.,
specular=0.8,
roughness=1. / 20))
mat_s2 = Material(colors.P_Brass3,
finish=Finish(ambient=0.25,
diffuse=0.5,
transparent=True,
specular=0.8,
roughness=1. / 80,
ior=1.5),
metallic=True)
se_ls = LightSourcePoint([-5., 10., 20.], intensity=1000.)
se_ls2 = LightSourceDirectional([1., -1., 1.], intensity=0.2)
se_base = SceneElement(Sphere([0.0, -10004., 20.], 10000.), mat_base)
se_s1 = SceneElement(Sphere([-1., -2., 20.], 2.), mat_s1)
se_s2 = SceneElement(Sphere([3.25, -1., 22.], 2.), mat_s2)
se_s3 = SceneElement(Sphere([3.25, -1., 27.], 2.), mat_s1)
scene = Scene([se_ls, se_ls2, se_base, se_s1, se_s2, se_s3])
# Render
rt = RayTracer(camera, scene)
traced = rt.render()
plt.imshow(traced)
plt.show()
class RayTracerMain(object):
def __init__(self, scene, screen_width=100, screen_height=100):
self.scene = scene
self.ray_generator = RayGenerator(
self.scene.direction,
screen_width,
screen_height
)
self.ray_tracer = RayTracer(scene)
self.screen = Screen(screen_width, screen_height)
def trace_scene(self):
for (x, y), ray in self.ray_generator.yield_primary_rays():
# TODO: create a ray class to encapsulate ray + position so this
# class doesn't have to know about the scene
pixel_color = self.ray_tracer.find_pixel_color_for_ray(
ray,
self.scene.position
)
self.screen.write_pixel(x, y, pixel_color)
def export_png(self, filename):
self.screen.dump_to_png(filename)
import matplotlib.pyplot as plt
from ray_tracer import RayTracer
from timestopper import TimeStopper
if __name__ == "__main__":
lines = 200 #Height of picture
ratio = 16 / 9 #Ratio of pic, width will be calculated
height = int(lines)
width = int(lines * ratio)
rayTracer = RayTracer(height,
width,
max_depth=4,
randomShadowRays=0,
systematicShadowRayRoot=2,
liveDisplay=True)
#max_depth, max number of a rays per pixel, randomShadow donot look good, systematicShadow details of shadows, live display try it
timerkek = TimeStopper()
for height_px in range(height):
for width_px in range(width):
rayTracer.traceRays(height_px, width_px)
print("%d / %d . %s" %
(height_px, height,
timerkek.getPassedTimeString(height_px, height)))
rayTracer.display()
print("%d / %d . %s" %
(height_px, height, timerkek.getPassedTimeString(height, height)))
rayTracer.printImage("images/test_image")
from parser import parse_camera_scene
from ray_tracer import RayTracer, calculate_distance, calculate_normal, calculate_object_color
arg_parser = argparse.ArgumentParser()
arg_parser.add_argument('--scene', help='path to the scene', action='store', dest='scene', required=True)
arg_parser.add_argument('--output', action='store', dest='output', required=True)
arg_parser.add_argument('--resolution_x', action='store', dest='resolution_x', type=int, default=100)
arg_parser.add_argument('--resolution_y', action='store', dest='resolution_y', type=int, default=100)
arg_parser.add_argument('--trace_depth', action='store', dest='trace_depth', type=int, default=0)
arg_parser.add_argument('--normal_as_color', action='store_true', default=False)
arg_parser.add_argument('--distance_as_color', action='store_true', default=False)
arg_parser.add_argument('--dist_range', action='store', dest='dist_range', type=int)
args = arg_parser.parse_args()
camera, scene = parse_camera_scene(args.scene)
tracer = RayTracer(scene, camera)
camera.resolution_x = args.resolution_x
camera.resolution_y = args.resolution_y
if args.normal_as_color:
res_img = tracer.run(calculate_normal, 3)
plt.imsave(args.output, res_img)
elif args.distance_as_color:
calc_dist = lambda hit: calculate_distance(hit, args.dist_range)
res_img = tracer.run(calc_dist)
plt.imsave(args.output, res_img, cmap=cm.gray)
else:
res_img = tracer.run(calculate_object_color, 3, camera.near_clip, tracing_depth=args.trace_depth)
plt.imsave(args.output, res_img)
