def test__mat_invert_(self):
foo1 = Transform.create_translate(10.0,2.0,3.0)
foo2 = Transform.create_rot_x(math.radians(37))
foo3 = Transform.create_translate(1.0,-2.0,-6.0)
foo4 = Transform.create_rot_y(math.radians(7))
foo5 = Transform.create_translate(1.0,7.0,2.0)
foo6 = Transform.create_rot_z(math.radians(137))
foo7 = foo1 * foo2 * foo3 * foo4 * foo5 * foo6
self.assertEqual(foo7.mat.get_invert(), foo7.mat_inv)
self.assertEqual(foo7.mat_inv, foo7.mat_inv)
def test_mul_transform(self):
#=========================================== point3d * transform
foo1 = Point3d(0.0, 0.0, 0.0)
foo2 = Transform.create_translate(1.0, 2.0, 3.0)
foo3 = foo1 * foo2
self.assertEqual(foo3, Point3d(1.0, 2.0, 3.0))
def __init__(self, cam2world: Transform, projection_matrix: Transform, screen_window: [float]*4, shutter_open: float, shutter_close: float, lensr: float, focald: float, film: Film):
super().__init__(cam2world, shutter_open, shutter_close, film)
self.cameraToScreen = projection_matrix
self.screenToRaster = \
Transform.create_translate(-screen_window[0], -screen_window[3], 0.0) * \
Transform.create_scale(1.0 / (screen_window[1] - screen_window[0]), 1.0 / (screen_window[2] - screen_window[3]), 1.0) * \
Transform.create_scale(film.width, film.height, 1.0)
self.rasterToScreen = Transform.get_invert(self.screenToRaster)
self.rasterToCamera = self.rasterToScreen * Transform.get_invert(self.cameraToScreen)
self.lensRadius = lensr
self.focalDistance= focald
def test_mul_transform(self):
#=========================================== Vector4 * transform(tr)
foo1 = Vector4d(0.0, 0.0, 0.0, 1.0)
foo2 = Transform.create_translate(1.0, 2.0, 3.0)
foo3 = foo1 * foo2
self.assertEqual(foo3.x, 1.0)
self.assertEqual(foo3.y, 2.0)
self.assertEqual(foo3.z, 3.0)
#=========================================== Vector4 * transform(rtZ 90)
foo1 = Vector4d(0.0, 1.0, 0.0, 1.0)
foo2 = Transform.create_rot_z(math.radians(90))
foo3 = foo1 * foo2
self.assertEqual(foo3, Vector4d(-1.0, 0.0, 0.0, 1.0))
def create_spotLight(paramSet: ParamSet, light2world: Transform) -> PointLight:
from maths.matrix44 import Matrix44
from maths.vector4d import Vector4d
I = paramSet.find_spectrum("I", Spectrum(1.0))
sc = paramSet.find_spectrum("scale", Spectrum(1.0))
coneangle = paramSet.find_float("coneangle", 30.0)
conedelta = paramSet.find_float("conedeltaangle", 5.0)
# Compute spotlight world to light transformation
frome = paramSet.find_point("from", Point3d(0.0, 0.0, 0.0))
to = paramSet.find_point("to", Point3d(0.0, 0.0, 1.0))
direction = (to - frome).get_normalized()
du, dv = Transform.create_coordinateSystem(dir)
m = Matrix44.create_from_vector4d(
Vector4d(du.x, du.y, du.z, 0.0),
Vector4d(dv.x, dv.y, dv.z, 0.0),
Vector4d(direction.x, direction.y, direction.z, 0.0),
Vector4d(0.0, 0.0, 0.0, 1.0))
dirToZ = Transform(m)
light2world = light2world * Transform.create_translate(frome.ex, frome.ey, frome.ez) * dirToZ.get_invert()
return SpotLight(light2world, I * sc, coneangle, coneangle - conedelta)
def test__get_real_invert_(self):
foo1 = Transform.create_translate(1.0,2.0,3.0)
foo2 = foo1.mat.get_invert()
self.assertEqual(foo2, foo1.mat_inv)
def pbrtTranslate(dx: float, dy: float, dz: float):
global curTransform
for i in range(len(curTransform)):
curTransform[i] = curTransform[i] * Transform.create_translate(dx, dy, dz)
def create_light_point(paramSet: ParamSet, light2world: Transform) -> PointLight:
I = paramSet.find_spectrum("I", Spectrum(1.0))
sc = paramSet.find_spectrum("scale", Spectrum(1.0))
P = paramSet.find_point("from", Point3d(0.0, 0.0, 0.0))
l2w = Transform.create_translate(P.x, P.y, P.z) * light2world
return PointLight(l2w, I * sc)
def test___mul__(self):
# ///////////////////////////////////////////__mul__ float
foo1 = Vector4d(1.0, 2.0, 3.0, 4.0)
foo2 = foo1 * 2.0
self.assertEqual(foo2, Vector4d(2.0, 4.0, 6.0, 8.0))
#///////////////////////////////////////////__imul__ float
foo1 = Vector4d(1.0, 2.0, 3.0, 4.0)
foo1 *= 2.0
self.assertEqual(foo1, Vector4d(2.0, 4.0, 6.0, 8.0))
#///////////////////////////////////////////__mul__ vector4d
foo1 = Vector4d(1.0, 2.0, 3.0, 4.0)
foo2 = Vector4d(2.0, 3.0, 4.0, 5.0)
foo3 = foo1 * foo2
self.assertEqual(foo3, Vector4d(2.0, 6.0, 12.0, 20.0))
#///////////////////////////////////////////__imul__ vector4d
foo1 = Vector4d(1.0, 2.0, 3.0, 4.0)
foo1 *= Vector4d(2.0, 3.0, 4.0, 5.0)
self.assertEqual(foo1, Vector4d(2.0, 6.0, 12.0, 20.0))
#///////////////////////////////////////////__mul__ matrix44 Rotz
foo1 = Vector4d(0.0, 2.0, 0.0, 1.0)
foo2 = Transform.create_rot_z(math.radians(90))
foo3 = foo1 * foo2.mat
self.assertEqual(foo3, Vector4d(-2.0, 0.0, 0.0, 1.0))
foo3 = foo3 * foo2.mat
self.assertEqual(foo3, Vector4d(0.0, -2.0, 0.0, 1.0))
#///////////////////////////////////////////__mul__ matrix44 Roty
foo1 = Vector4d(2.0, 0.0, 0.0, 1.0)
foo2 = Transform.create_rot_y(math.radians(90))
foo3 = foo1 * foo2.mat
self.assertEqual(foo3, Vector4d(0.0, 0.0, -2.0, 1.0))
foo3 = foo3 * foo2.mat
self.assertEqual(foo3, Vector4d(-2.0, 0.0, 0.0, 1.0))
#///////////////////////////////////////////__mul__ matrix44 Rotx
foo1 = Vector4d(0.0, 2.0, 0.0, 1.0)
foo2 = Transform.create_rot_x(math.radians(90))
foo3 = foo1 * foo2.mat
self.assertEqual(foo3, Vector4d(0.0, 0.0, 2.0, 1.0))
foo3 = foo3 * foo2.mat
self.assertEqual(foo3, Vector4d(0.0, -2.0, 0.0, 1.0))
#///////////////////////////////////////////__mul__ matrix44 Rotx * Roty * Rotz
foo1 = Vector4d(2.0, 0.0, 0.0, 1.0)
foo2 = Transform.create_rot_x(math.radians(90))
foo3 = Transform.create_rot_y(math.radians(90))
foo4 = Transform.create_rot_z(math.radians(90))
foo5 = foo2 * foo3 * foo4
foo6 = foo1 * foo5.mat
foo7 = Vector4d(0.0, 0.0, -2.0, 1.0)
self.assertEqual(foo6, foo7)
#///////////////////////////////////////////__mul__ matrix44 Tr * Rotz
foo1 = Vector4d(0.0, 0.0, 0.0, 1.0)
foo2 = Transform.create_translate(1.0, 0.0, 0.0)
foo4 = Transform.create_rot_z(math.radians(90))
foo5 = foo1 * foo2 * foo4
foo7 = Vector4d(0.0, 1.0, 0.0, 1.0)
self.assertEqual(foo5, foo7)
def test___mul__(self):
from core.transform import Transform
from maths.matrix44 import Matrix44
from maths.vector4d import Vector4d
# //////////////////////////////////////////////////////I *I = I
foo1 = Transform.create_identity()
foo2 = Transform.create_identity()
foo3 = foo1 * foo2
for i in range(0, 4):
for j in range(0, 4):
if i == j:
self.assertEqual(foo3.mat[i][j], 1.0)
self.assertEqual(foo3.mat_inv[i][j], 1.0)
else:
self.assertEqual(foo3.mat[i][j], 0.0)
self.assertEqual(foo3.mat_inv[i][j], 0.0)
#//////////////////////////////////////////////////////Ta * Tb = Tab
foo1 = Transform.create_translate(1.0, 0.0, 0.0)
foo2 = Transform.create_translate(0.0, 2.0, 0.0)
foo0 = foo1 * foo2
for i in range(0, 3):
for j in range(0, 4):
if i == j:
self.assertEqual(foo3.mat[i][j], 1.0)
else:
self.assertEqual(foo3.mat[i][j], 0.0)
self.assertEqual(foo0.mat[3][0], 1.0)
self.assertEqual(foo0.mat[3][1], 2.0)
self.assertEqual(foo0.mat[3][2], 0.0)
self.assertEqual(foo0.mat[3][3], 1.0)
self.assertEqual(foo0.mat[3], Vector4d(1.0, 2.0, 0.0, 1.0))
#//////////////////////////////////////////////////////RotXa * RotXb = RotXab
foo0 = Transform.create_rot_x(math.radians(90))
foo1 = Transform.create_rot_x(math.radians(45))
foo2 = Transform.create_rot_x(math.radians(45))
foo3 = foo1 * foo2
self.assertEqual(foo0, foo3)
#//////////////////////////////////////////////////////RotZ(a) * RotZ(-a) = I
foo0 = Transform.create_rot_z(math.radians(90))
foo1 = Transform.create_rot_z(math.radians(-90))
foo2 = foo0 * foo1
foo3 = Transform.create_identity()
self.assertEqual(foo2, foo3)
#//////////////////////////////////////////////////////Tr(a) * Tr(-a) = I
foo0 = Transform.create_translate(1.0, 0.0, 0.0)
foo1 = Transform.create_translate(-1.0, 0.0, 0.0)
foo2 = foo0 * foo1
foo3 = Transform.create_identity()
self.assertEqual(foo2, foo3)
#//////////////////////////////////////////////////////RotXa * T = RotXab
foo0 = Transform.create_translate(1.0, 2.0, 3.0)
foo1 = Transform.create_rot_x(math.radians(90))
foo2 = Transform.create_rot_z(math.radians(22))
foo3 = Transform.create_translate(1.0, 2.0, 3.0)
foo4 = foo0 * foo1 * foo2 * foo3
self.assertEqual(foo4.mat_inv, foo4.mat.get_invert())
