def test__get_invert_by_transpose_(self):
foo1 = Transform.create_rot_z(math.radians(90))
foo2 = Transform.create_identity()
foo3 = foo1.mat * foo1.mat_inv
self.assertEqual(foo3, foo2.mat)
def test__get_invert__(self):
from core.transform import Transform
foo0 = Transform.create_rot_z(math.radians(90))
foo1 = Transform.create_identity()
foo2 = foo0.get_invert()
foo3 = foo0 * foo2
self.assertEqual(foo3, foo1)
def test_set_to_identity(self):
from core.transform import Transform
foo = Transform.create_identity()
for i in range(0, 4):
for j in range(0, 4):
if i == j:
self.assertEqual(foo.mat[i][j], 1.0)
self.assertEqual(foo.mat_inv[i][j], 1.0)
else:
self.assertEqual(foo.mat[i][j], 0.0)
self.assertEqual(foo.mat_inv[i][j], 0.0)
def __init__(self):
self.filterName = None
self.filterParams = ParamSet()
self.filmName = None
self.filmParams = ParamSet()
self.samplerName = None
self.samplerParams = ParamSet()
self.acceleratorName = None
self.acceleratorParams = ParamSet()
self.rendererName = None
self.rendererParams = ParamSet()
self.surfIntegratorName = None
self.surfIntegratorParams = ParamSet()
self.volIntegratorName = None
self.volIntegratorParams = ParamSet()
self.cameraName = None
self.cameraParams = ParamSet()
self.primitives = []
self.instances = []
self.cameraToWorld = Transform.create_identity()
self.volumeRegions = []
self.lights = []
def __init__(self):
self.transform = Transform(Transform.create_identity(), Transform.create_identity())
def pbrtWorldBegin():
global curTransform
for i in range(len(curTransform)):
curTransform[i] = Transform.create_identity()
from samplers.bestcandidateSampler import BestcandidateSampler
from samplers.haltonSampler import HaltonSampler
from samplers.lowdiscrepancySampler import LowDiscrepancySampler
from samplers.randomSampler import RandomSampler
from samplers.stratifiedSampler import StratifiedSampler
from shapes.plane import Plane
from shapes.sphere import Sphere
from shapes.triangle import TriangleMesh
from surface_integrator.ambient_occlusion_integrator import AmbientOcclusionIntegrator
from surface_integrator.direct_lighting_integrator import DirectLightingIntegrator
from surface_integrator.path import PathIntegrator
from textures.constant_texture import ConstantTexture
renderOptions = RenderOptions()
curTransform = [Transform.create_identity()]
namedCoordinateSystems = {}
pushedActiveTransformBits = []
pushedTransforms = []
graphicsState = GraphicsState()
pushedGraphicsStates = [GraphicsState()]
# ==========================camera
def create_environment_camera(paramset: ParamSet, cam2world: Transform, film: Film) -> EnvironmentCamera:
return None
def create_perspective_camera(paramset: ParamSet, cam2world: Transform, film: Film) -> PerspectiveCamera:
shutteropen = paramset.find_float("shutteropen", 0.0)
shutterclose = paramset.find_float("shutterclose", 1.0)
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())
