from teapot import load_triangles from draw_model import draw_model from math import pi def polygon_map(transformation, polygons): return [[transformation(vertex) for vertex in triangle] for triangle in polygons] def slant_xy(vector): x, y, z = vector return (x + y, y, z) #################################################################### #### this code takes a snapshot to reproduce the exact figure #### shown in the book as an image saved in the "figs" directory #### to run it, run this script with command line arg --snapshot import sys import camera if '--snapshot' in sys.argv: camera.default_camera = camera.Camera('fig_4.16_slant_teapot', [0]) #################################################################### draw_model(polygon_map(slant_xy, load_triangles()))
from teapot import load_triangles from draw_model import draw_model draw_model(load_triangles())
from draw_model import * from teapot import load_triangles teapot = load_triangles() def matrix(t): return ((2, 1, 1), (1, 2, 1), (1, 1, 2)) draw_model(teapot, get_matrix=matrix)
from teapot import load_triangles from draw_model import draw_model from camera import Camera from transforms import * from math import pi draw_model(polygon_map(rotate_y_by(pi / 2), load_triangles()), camera=Camera('rotate-teapot-y', [0]))
from vectors import scale from teapot import load_triangles from draw_model import draw_model def polygon_map(transformation, polygons): return [[transformation(vertex) for vertex in triangle] for triangle in polygons] def scale_by(scalar): def new_function(v): return scale(scalar, v) return new_function #################################################################### #### this code takes a snapshot to reproduce the exact figure #### shown in the book as an image saved in the "figs" directory #### to run it, run this script with command line arg --snapshot import sys import camera if '--snapshot' in sys.argv: camera.default_camera = camera.Camera('ex_scale_teapot_-1', [0]) #################################################################### draw_model(polygon_map(scale_by(-1), load_triangles()))
from teapot import load_triangles from draw_model import draw_model from transforms import polygon_map, multiply_matrix_vector def translate_3d(translation): def new_function(target): #1 a, b, c = translation x, y, z = target matrix = ((1, 0, 0, a), (0, 1, 0, b), (0, 0, 1, c), (0, 0, 0, 1)) #2 vector = (x, y, z, 1) x_out, y_out, z_out, _ = multiply_matrix_vector(matrix, vector) #3 return (x_out, y_out, z_out) return new_function #################################################################### #### this code takes a snapshot to reproduce the exact figure #### shown in the book as an image saved in the "figs" directory #### to run it, run this script with command line arg --snapshot import sys import camera if '--snapshot' in sys.argv: camera.default_camera = camera.Camera('fig_5.36_translated_teapot', [0]) #################################################################### draw_model(polygon_map(translate_3d((2, 2, -3)), load_triangles()))
def draw_teapot(): draw_model(load_triangles())
from teapot import load_triangles from draw_model import draw_model from math import pi def polygon_map(transformation, polygons): return [[transformation(vertex) for vertex in triangle] for triangle in polygons] def stretch_y(vector): x, y, z = vector return (x, 4. * y, z) #################################################################### #### this code takes a snapshot to reproduce the exact figure #### shown in the book as an image saved in the "figs" directory #### to run it, run this script with command line arg --snapshot import sys import camera if '--snapshot' in sys.argv: camera.default_camera = camera.Camera('fig_4.14_stretch_teapot_y', [0]) #################################################################### draw_model(polygon_map(stretch_y, load_triangles()))
from vectors import scale from teapot import load_triangles from draw_model import draw_model from transforms import rotate_x_by, compose from math import pi def polygon_map(transformation, polygons): return [ [transformation(vertex) for vertex in triangle] for triangle in polygons ] def scale_by(scalar): def new_function(v): return scale(scalar, v) return new_function #################################################################### #### this code takes a snapshot to reproduce the exact figure #### shown in the book as an image saved in the "figs" directory #### to run it, run this script with command line arg --snapshot import sys import camera for i in range(10): if '--snapshot' in sys.argv: camera.default_camera = camera.Camera('fig_4_UN_04_%s' % i,[0]) #################################################################### draw_model(polygon_map(compose(rotate_x_by(2*pi*i/10),scale_by(-1)), load_triangles()))
for triangle in polygons ] def rotate2d(angle, vector): l,a = to_polar(vector) return to_cartesian((l, a+angle)) def rotate_z(angle, vector): x,y,z = vector new_x, new_y = rotate2d(angle, (x,y)) return new_x, new_y, z def rotate_z_by(angle): def new_function(v): return rotate_z(angle,v) return new_function #################################################################### #### this code takes a snapshot to reproduce the exact figure #### shown in the book as an image saved in the "figs" directory #### to run it, run this script with command line arg --snapshot import sys import camera for d in range(1,46): if '--snapshot' in sys.argv: camera.default_camera = camera.Camera('fig_4.3_%s' % d,[0]) #################################################################### draw_model(polygon_map(rotate_z_by(d * pi/180), load_triangles()))
from teapot import load_triangles from matrices import * from draw_model import * from camera import Camera from transforms import polygon_map def translate_3d(translation): def new_function(target): a, b, c = translation x, y, z = target matrix = ((1, 0, 0, a), (0, 1, 0, b), (0, 0, 1, c), (0, 0, 0, 1)) vector = (x, y, z, 1) x_out, y_out, z_out, _ = multiply_matrix_vector(matrix, vector) return (x_out, y_out, z_out) return new_function draw_model(load_triangles(), camera=Camera("translate-teapot-pre", [0])) draw_model(polygon_map(translate_3d((2, 2, -3)), load_triangles()), camera=Camera("translate-teapot-post", [0]))
from teapot import load_triangles from matrices import * from draw_model import * from camera import Camera from transforms import polygon_map from vector_drawing import * def transform(v): m = ((2, 1, 1), (1, 2, 1), (1, 1, 2)) return multiply_matrix_vector(m, v) draw_model(polygon_map(transform, load_triangles()), camera=Camera("teapot-matrix-exercise", [0])) s = Space((-1, -1, -1), (3, 3, 3), "stretched-squeezed-standard-basis") s.draw_axes() s.draw_arrow((0, 0, 0), (1, 0, 0), color='black') s.draw_arrow((0, 0, 0), (0, 1, 0), color='black') s.draw_arrow((0, 0, 0), (0, 0, 1), color='black') s.draw_arrow((0, 0, 0), (2, 1, 1), color='blue') s.draw_arrow((0, 0, 0), (1, 2, 1), color='blue') s.draw_arrow((0, 0, 0), (1, 1, 2), color='blue') s.show()
x,y,z = vector return (x, y, 4*z) def stretch_x(scalar,vector): x,y,z = vector return (scalar*x, y, z) def stretch_x_by(scalar): def new_function(vector): return stretch_x(scalar,vector) return new_function t4 = compose(translate_by((-1,-3,-2)), compose(rotate_x_by(3*pi/2), stretch_z)) draw_model(polygon_map(t4, load_triangles()), camera=Camera("stretch_z_rot_trans", [0])) def cube_stretch_z(vector): x,y,z = vector return (x, y, 2*z*z*z) t5 = compose(translate_by((-1,-2,-2)), compose(rotate_x_by(3*pi/2), cube_stretch_z)) draw_model(polygon_map(t5, load_triangles()), camera=Camera("cube_stretch_z_rot_trans", [0])) def slant_xz(vector): x,y,z = vector return (x+z, y, z) t6 = compose(translate_by((-1,-1,0)), compose(rotate_x_by(3*pi/2), slant_xz))
from teapot import load_triangles from draw_model import draw_model from camera import Camera from transforms import * from math import * from vectors import add import os # draw_model(polygon_map(rotate_z_by(pi/4.), load_triangles()), camera=Camera("teapot_45deg_z", [0])) # draw_model(polygon_map(rotate_x_by(3*pi/2.), load_triangles()), camera=Camera("teapot_270deg_x", [0])) # Ae1 = (1, 1, 1) Ae2 = (1, 0, -1) Ae3 = (0, 1, 1) def apply_A(v): return add(scale(v[0], Ae1), scale(v[1], Ae2), scale(v[2], Ae3)) draw_model(polygon_map(apply_A, load_triangles()), camera=Camera('teapot-linear-transform', [0]))
from teapot import load_triangles from draw_model import draw_model def to_4d_vector(v): return (*v, 1) def translate_matrix(t): time = t / 10000 return ( (1, 0, 0, min(2, 2 * time)), (0, 1, 0, min(2, 2 * time)), (0, 0, 1, max(-3, -3 * time)), (0, 0, 0, 1), ) teapot = [(to_4d_vector(t[0]), to_4d_vector(t[1]), to_4d_vector(t[2])) for t in load_triangles()] draw_model(teapot, get_matrix=translate_matrix)
from teapot import load_triangles from draw_model_custom_impl import draw_model_anim from transformations_support import * from vectors_my_implementation import to_radians # Basic rendering of Utah teapot, no transformations #draw_model_anim(load_triangles()) # Rendering of Utah teapot, using non-curried transformation # orig_triangles = load_triangles() # scaled_triangles = [ # [scale(0.5, v) for v in triangle] # for triangle in orig_triangles # ] # draw_model_anim(scaled_triangles) # Rendering using currying and polygon_map # draw_model_anim(polygon_map(translate_by((-1, -1, -1)), load_triangles())) # Rendering using composition draw_model_anim(polygon_map(compose(rotate_z_by(to_radians(45)), rotate_y_by(to_radians(45)), rotate_x_by(to_radians(45))), load_triangles()))
return [[transformation(vertex) for vertex in triangle] for triangle in polygons] def scale2(v): return scale(2.0, v) def translate1left(v): return add((-1, 0, 0), v) def compose(f1, f2): def new_function(input): return f1(f2(input)) return new_function #################################################################### #### this code takes a snapshot to reproduce the exact figure #### shown in the book as an image saved in the "figs" directory #### to run it, run this script with command line arg --snapshot import sys import camera if '--snapshot' in sys.argv: camera.default_camera = camera.Camera('ex_translate_scale', [0]) #################################################################### draw_model(polygon_map(compose(scale2, translate1left), load_triangles()))
from teapot import load_triangles from draw_model import draw_model from camera import Camera from transforms import * from math import * from vectors import add def get_rotation_matrix(t): return ((cos(t), 0, -sin(t)), (0, 1, 0), (sin(t), 0, cos(t))) def get_rotation_matrix(t): theta = t / 1000 return ((cos(theta), 0, -sin(theta)), (0, 1, 0), (sin(theta), 0, cos(theta))) cam = Camera('parametrize_rotation', [1000, 2000, 3000, 4000, 5000], comic_strip=5) draw_model(load_triangles(), get_matrix=get_rotation_matrix, camera=cam)
from math import pi from teapot import load_triangles from draw_model import draw_model from transforms import * triangles = load_triangles() f = compose(rotate_x_by(pi / 2), rotate_z_by(pi / 2)) triangles = polygon_map(f, triangles) draw_model(triangles)
from vectors import scale from teapot import load_triangles from draw_model import draw_model def scale2(v): return scale(2.0, v) original_triangles = load_triangles() #1 scaled_triangles = [ [scale2(vertex) for vertex in triangle] #21 for triangle in original_triangles #32 ] #################################################################### #### this code takes a snapshot to reproduce the exact figure #### shown in the book as an image saved in the "figs" directory #### to run it, run this script with command line arg --snapshot import sys import camera if '--snapshot' in sys.argv: camera.default_camera = camera.Camera('fig_4.5_scale_teapot',[0]) #################################################################### draw_model(scaled_triangles)
def rotate2d(angle, vector): l, a = to_polar(vector) return to_cartesian((l, a + angle)) def rotate_z(angle, vector): x, y, z = vector new_x, new_y = rotate2d(angle, (x, y)) return new_x, new_y, z def rotate_z_by(angle): def new_function(v): return rotate_z(angle, v) return new_function #################################################################### #### this code takes a snapshot to reproduce the exact figure #### shown in the book as an image saved in the "figs" directory #### to run it, run this script with command line arg --snapshot import sys import camera if '--snapshot' in sys.argv: camera.default_camera = camera.Camera('fig_4.11_rotate_teapot', [0]) #################################################################### draw_model(polygon_map(rotate_z_by(pi / 4.), load_triangles()))
from vectors import scale, add from teapot import load_triangles from draw_model import draw_model def polygon_map(transformation, polygons): return [ [transformation(vertex) for vertex in triangle] for triangle in polygons ] def translate_by(translation): def new_function(v): return add(translation,v) return new_function #################################################################### #### this code takes a snapshot to reproduce the exact figure #### shown in the book as an image saved in the "figs" directory #### to run it, run this script with command line arg --snapshot import sys import camera if '--snapshot' in sys.argv: camera.default_camera = camera.Camera('ex_translate_teapot_down_z',[0]) #################################################################### draw_model(polygon_map(translate_by((0,0,-20)), load_triangles()))
from teapot import load_triangles from draw_model import draw_model from camera import Camera from transforms import * from math import * from vectors import add import os # draw_model(polygon_map(rotate_z_by(pi/4.), load_triangles()), camera=Camera("teapot_45deg_z", [0])) # draw_model(polygon_map(rotate_x_by(3*pi/2.), load_triangles()), camera=Camera("teapot_270deg_x", [0])) # camera = Camera('teapot-rotation-chapter-intro', range(0, 45), comic_strip=9, dir=os.path.join('figs', 'chapter-intro-teapot')) def t(ticks): rate = 1. / 100. # 1 degree per 100 ms return compose( rotate_z_by(ticks * .5 * rate * pi / 180.), compose(translate_by((-0.5, -0.5, 3)), rotate_x_by(3 * pi / 2))) draw_model(load_triangles(), camera=camera, transform=t)