Python - Matrix Transformations - translation, scaling, rotation(x, y, z axises), shearing, chaining, clock

The Ray Tracer Challenge:
A Test-Driven Guide to Your First 3D Renderer
楽天 紀伊国屋書店

開発環境

• macOS Mojave - Apple (OS)
• Emacs (Text Editor)
• Windows 10 Pro (OS)
• Visual Studio Code (Text Editor)
• Python 3.7 (プログラミング言語)
• GIMP (ビットマップ画像編集・加工ソフトウェア、PPM形式(portable pixmap)の画像用)

The Ray Tracer Challenge: A Test-Driven Guide to Your First 3D Renderer (Jamis Buck(著)、Pragmatic Bookshelf)、Chapter 4(Matrix Transformations)のPut It Together(54)を取り組んでみる。

コード

Python 3

transformations_test.py

#!//usr/bin/env python3
from unittest import TestCase, main
from tuples import Point, Vector
from transformations import translation, scaling
from transformations import rotation_x, rotation_y, rotation_z
from transformations import shearing
import math


class TransformationsTest(TestCase):
    def setUp(self):
        pass

    def tearDown(self):
        pass

    def test_translation(self):
        transform = translation(5, -3, 2)
        inv = transform.inverse()
        p = Point(-3, 4, 5)
        self.assertEqual(transform * p, Point(2, 1, 7))

    def test_translation_vector(self):
        transform = translation(5, -3, 2)
        v = Vector(-3, 4, 5)
        self.assertEqual(transform * v, v)

    def test_scaling_point(self):
        transform = scaling(2, 3, 4)
        p = Point(-4, 6, 8)
        self.assertEqual(transform * p, Point(-8, 18, 32))

    def test_scaling_vector(self):
        transform = scaling(2, 3, 4)
        v = Vector(-4, 6, 8)
        self.assertEqual(transform * v, Vector(-8, 18, 32))

    def test_scaling_vector_inv(self):
        transform = scaling(2, 3, 4)
        v = inv = transform.inverse()
        v = Vector(-4, 6, 8)
        self.assertEqual(inv * v, Vector(-2, 2, 2))

    def test_scaling_negative(self):
        transform = scaling(-1, 1, 1)
        p = Point(2, 3, 4)
        self.assertEqual(transform * p, Point(-2, 3, 4))

    def test_rotation_x(self):
        p = Point(0, 1, 0)
        half_quarter = rotation_x(math.pi / 4)
        full_quarter = rotation_x(math.pi / 2)
        self.assertEqual(half_quarter * p,
                         Point(0, math.sqrt(2) / 2, math.sqrt(2) / 2))
        self.assertEqual(full_quarter * p,
                         Point(0, 0, 1))

    def test_rotation_x_opposite(self):
        p = Point(0, 1, 0)
        half_quarter = rotation_x(math.pi / 4)
        inv = half_quarter.inverse()
        self.assertEqual(inv * p,
                         Point(0, math.sqrt(2) / 2, -math.sqrt(2) / 2))

    def test_rotation_y(self):
        p = Point(0, 0, 1)
        half_quarter = rotation_y(math.pi / 4)
        full_quarter = rotation_y(math.pi / 2)
        self.assertEqual(half_quarter * p,
                         Point(math.sqrt(2) / 2, 0, math.sqrt(2) / 2))
        self.assertEqual(full_quarter * p,
                         Point(1, 0, 0))

    def test_rotation_z(self):
        p = Point(0, 1, 0)
        half_quarter = rotation_z(math.pi / 4)
        full_quarter = rotation_z(math.pi / 2)
        self.assertEqual(half_quarter * p,
                         Point(-math.sqrt(2) / 2, math.sqrt(2) / 2, 0))
        self.assertEqual(full_quarter * p,
                         Point(-1, 0, 0))

    def test_shearing_x_to_y(self):
        transform = shearing(1, 0, 0, 0, 0, 0)
        p = Point(2, 3, 4)
        self.assertEqual(transform * p, Point(5, 3, 4))

    def test_shearing_x_z(self):
        transform = shearing(0, 1, 0, 0, 0, 0)
        p = Point(2, 3, 4)
        self.assertEqual(transform * p, Point(6, 3, 4))

    def test_shearing_y_x(self):
        transform = shearing(0, 0, 1, 0, 0, 0)
        p = Point(2, 3, 4)
        self.assertEqual(transform * p, Point(2, 5, 4))

    def test_shearing_y_z(self):
        transform = shearing(0, 0, 0, 1, 0, 0)
        p = Point(2, 3, 4)
        self.assertEqual(transform * p, Point(2, 7, 4))

    def test_shearing_z_x(self):
        transform = shearing(0, 0, 0, 0, 1, 0)
        p = Point(2, 3, 4)
        self.assertEqual(transform * p, Point(2, 3, 6))

    def test_shearing_z_y(self):
        transform = shearing(0, 0, 0, 0, 0, 1)
        p = Point(2, 3, 4)
        self.assertEqual(transform * p, Point(2, 3, 7))

    def test_transformation_sequence(self):
        p = Point(1, 0, 1)
        A = rotation_x(math.pi / 2)
        B = scaling(5, 5, 5)
        C = translation(10, 5, 7)
        p2 = A * p
        p3 = B * p2
        p4 = C * p3
        for a, b in zip([p2, p3, p4], [Point(1, -1, 0),
                                       Point(5, -5, 0),
                                       Point(15, 0, 7)]):
            self.assertEqual(a, b)

    def test_transformation_chain(self):
        p = Point(1, 0, 1)
        A = rotation_x(math.pi / 2)
        B = scaling(5, 5, 5)
        C = translation(10, 5, 7)
        T = C * B * A
        self.assertEqual(T * p, Point(15, 0, 7))


if __name__ == '__main__':
    main()

transformations.py

from matrices import Matrix
import math


def translation(x: float, y: float, z: float) -> Matrix:
    return Matrix([[1, 0, 0, x],
                   [0, 1, 0, y],
                   [0, 0, 1, z],
                   [0, 0, 0, 1]])


def scaling(x: float, y: float, z: float) -> Matrix:
    return Matrix([[x, 0, 0, 0],
                   [0, y, 0, 0],
                   [0, 0, z, 0],
                   [0, 0, 0, 1]])


def rotation_x(r: float) -> Matrix:
    return Matrix(((1, 0, 0, 0),
                   (0, math.cos(r), -math.sin(r), 0),
                   (0, math.sin(r), math.cos(r), 0),
                   (0, 0, 0, 1)))


def rotation_y(r: float) -> Matrix:
    return Matrix(((math.cos(r), 0, math.sin(r), 0),
                   (0, 1, 0, 0),
                   (-math.sin(r), 0, math.cos(r), 0),
                   (0, 0, 0, 1)))


def rotation_z(r: float) -> Matrix:
    return Matrix(((math.cos(r), -math.sin(r), 0, 0),
                   (math.sin(r), math.cos(r), 0, 0),
                   (0, 0, 1, 0),
                   (0, 0, 0, 1)))


def shearing(xy: float, xz: float,
             yx: float, yz: float,
             zx: float, zy: float) -> Matrix:
    return Matrix(((1, xy, xz, 0),
                   (yx, 1, yz, 0),
                   (zx, zy, 1, 0),
                   (0, 0, 0, 1)))

clock.py

#!/usr/bin/env python3
from tuples import *
from transformations import *
from canvas import Canvas
import random

width = 500
height = 500


def p(msg, ponts):
    print(msg)
    for p in points:
        print(p)


if __name__ == '__main__':
    r = rotation_y(math.pi / 6)
    twelve = Point(0, 0, 1)
    points = [twelve]
    for i in range(11):
        points.append(r * points[i])
    p('回転', points)

    canvas = Canvas(width, height)
    radius = width * 3 / 8
    s = scaling(radius, 0, radius)
    points = [s * point for point in points]
    p('拡大(縮小)', points)

    t = translation(width / 2, 0, height / 2)
    points = [t * point for point in points]
    p('移動', points)

    for point in points:
        color = Color(*[random.random() for _ in range(3)])
        x, z = point.x, point.z
        xzs = [(x + i, z + j) for i in range(-5, 6) for j in range(-5, 6)]
        for x0, z0 in xzs:
            canvas.write_pixel(int(x0), int(z0), color)

    ppm = canvas.to_ppm()
    with open('clock.ppm', 'w') as f:
        print(ppm, file=f)

入出力結果(cmd(コマンドプロンプト)、Terminal、Bash、Jupyter(IPython))

C:\Users\...>py transformations_test.py
..................
----------------------------------------------------------------------
Ran 18 tests in 0.003s

OK

C:\Users\...>py transformations_test.py -v
test_rotation_x (__main__.TransformationsTest) ... ok
test_rotation_x_opposite (__main__.TransformationsTest) ... ok
test_rotation_y (__main__.TransformationsTest) ... ok
test_rotation_z (__main__.TransformationsTest) ... ok
test_scaling_negative (__main__.TransformationsTest) ... ok
test_scaling_point (__main__.TransformationsTest) ... ok
test_scaling_vector (__main__.TransformationsTest) ... ok
test_scaling_vector_inv (__main__.TransformationsTest) ... ok
test_shearing_x_to_y (__main__.TransformationsTest) ... ok
test_shearing_x_z (__main__.TransformationsTest) ... ok
test_shearing_y_x (__main__.TransformationsTest) ... ok
test_shearing_y_z (__main__.TransformationsTest) ... ok
test_shearing_z_x (__main__.TransformationsTest) ... ok
test_shearing_z_y (__main__.TransformationsTest) ... ok
test_transformation_chain (__main__.TransformationsTest) ... ok
test_transformation_sequence (__main__.TransformationsTest) ... ok
test_translation (__main__.TransformationsTest) ... ok
test_translation_vector (__main__.TransformationsTest) ... ok

----------------------------------------------------------------------
Ran 18 tests in 0.003s

OK

C:\Users\...>py clock.py
回転
Point(0,0,1,1)
Point(0.49999999999999994,0,0.8660254037844387,1)
Point(0.8660254037844386,0.0,0.5000000000000002,1.0)
Point(1.0,0.0,2.7755575615628914e-16,1.0)
Point(0.8660254037844388,0.0,-0.4999999999999997,1.0)
Point(0.5000000000000004,0.0,-0.8660254037844385,1.0)
Point(5.551115123125783e-16,0.0,-1.0,1.0)
Point(-0.49999999999999944,0.0,-0.8660254037844389,1.0)
Point(-0.8660254037844383,0.0,-0.5000000000000007,1.0)
Point(-1.0,0.0,-8.326672684688674e-16,1.0)
Point(-0.8660254037844392,0.0,0.4999999999999992,1.0)
Point(-0.5000000000000009,0.0,0.8660254037844382,1.0)
拡大(縮小)
Point(0.0,0,187.5,1)
Point(93.74999999999999,0.0,162.37976320958225,1.0)
Point(162.37976320958225,0.0,93.75000000000004,1.0)
Point(187.5,0.0,5.204170427930421e-14,1.0)
Point(162.37976320958228,0.0,-93.74999999999994,1.0)
Point(93.75000000000009,0.0,-162.37976320958222,1.0)
Point(1.0408340855860843e-13,0.0,-187.5,1.0)
Point(-93.7499999999999,0.0,-162.3797632095823,1.0)
Point(-162.37976320958217,0.0,-93.75000000000013,1.0)
Point(-187.5,0.0,-1.5612511283791264e-13,1.0)
Point(-162.37976320958234,0.0,93.74999999999986,1.0)
Point(-93.75000000000017,0.0,162.37976320958217,1.0)
移動
Point(250.0,0.0,437.5,1.0)
Point(343.75,0.0,412.3797632095823,1.0)
Point(412.3797632095823,0.0,343.75000000000006,1.0)
Point(437.5,0.0,250.00000000000006,1.0)
Point(412.3797632095823,0.0,156.25000000000006,1.0)
Point(343.7500000000001,0.0,87.62023679041778,1.0)
Point(250.0000000000001,0.0,62.5,1.0)
Point(156.2500000000001,0.0,87.62023679041769,1.0)
Point(87.62023679041783,0.0,156.2499999999999,1.0)
Point(62.5,0.0,249.99999999999986,1.0)
Point(87.62023679041766,0.0,343.7499999999999,1.0)
Point(156.24999999999983,0.0,412.37976320958217,1.0)

C:\Users\...>