def test_properties(self):
# Defaults
plane = geometry.Plane()
self.assertSameArray(np.array([0, 0, 1]), plane.normal())
# Normalizes
normals = [
np.array([0, 0, 7]),
np.array([0, 0, 23.6]),
np.array([0, .0, -2.47])
]
for n in normals:
plane = geometry.Plane(normal=n)
self.assertAlmostEqual(1, _utils.vabs(plane.normal()))
plane = geometry.Plane(pos=np.array([-0.5, -0.5, 1]))
ray = rays.Ray()
ray.k = np.array([0, 0, 1])
self.assertSameArray(np.array([0, 0, 1]), plane.intersect(ray))
ray = rays.Ray()
ray.k = np.array([1, 1, 0])
self.assertSameArray(None, plane.intersect(ray))
ray = rays.Ray()
ray.k = np.array([0, 0, -1])
self.assertSameArray(None, plane.intersect(ray))
def test_refract(self):
# Check it updates position
mirror = MockGeometryNormal(geometry.Mirror())
ray = rays.Ray(k=_utils.vec(0, 1, 1))
new_pos = _utils.pos(10, 34.2, -70)
mirror.refract(ray, new_pos, 1)
self.assertSameArray(new_pos, ray.pos)
# Check angle in is angle out
tests = [
(_utils.vec(5, 0, 0), _utils.vec(1, 0, 0), 1, 2),
(_utils.vec(1, 3, 5), _utils.vec(1, -2, 7), 1, 3.1),
(_utils.vec(0.246, 5.8, 24.9), _utils.vec(45.6, -2.888,
3.1), 1, 1.1),
(_utils.vec(-3, 1.8, 0), _utils.vec(1.7, 2.2, -1), 1, 7.24),
(_utils.vec(43.4, 9.38, -5), _utils.vec(-1.7, 22, -1), 2.1, 4.15),
]
def angle(a, b):
return np.arccos(abs(a.dot(b) / _utils.vabs(a) / _utils.vabs(b)))
for k, normal, n_prev, n_lens in tests:
mirror = MockGeometryNormal(geometry.Mirror(n=n_lens), normal)
ray = rays.Ray(k=k)
ang_1 = angle(ray.k, normal)
mirror.refract(ray, np.zeros(3), n_prev)
ang_2 = angle(ray.k, normal)
self.assertAlmostEqual(ang_1, ang_2)
def test_refract(self):
# Check it updates position
lens = MockGeometryNormal(geometry.Lens())
ray = rays.Ray(k=_utils.vec(0, 1, 1))
new_pos = _utils.pos(10, 34.2, -70)
lens.refract(ray, new_pos, 1)
self.assertSameArray(new_pos, ray.pos)
# Check Babinet’s principle holds
tests = [
(_utils.vec(5, 0, 0), _utils.vec(1, 0, 0), 1, 2),
(_utils.vec(1, 3, 5), _utils.vec(1, -2, 7), 1, 3.1),
(_utils.vec(0.246, 5.8, 24.9), _utils.vec(45.6, -2.888,
3.1), 1, 1.1),
(_utils.vec(-3, 1.8, 0), _utils.vec(1.7, 2.2, -1), 1, 7.24),
(_utils.vec(43.4, 9.38, -5), _utils.vec(-1.7, 22, -1), 2.1, 4.15),
(_utils.vec(1.4, 2.8, 3.9), _utils.vec(-1.7, 22, -1), 2, 2),
]
def angle(a, b):
return np.arccos(abs(a.dot(b) / _utils.vabs(a) / _utils.vabs(b)))
for k, normal, n_prev, n_lens in tests:
lens = MockGeometryNormal(geometry.Lens(n=n_lens), normal)
ray = rays.Ray(k=k)
n_1_sin_1 = n_prev * np.sin(angle(ray.k, normal))
lens.refract(ray, np.zeros(3), n_prev)
n_2_sin_2 = n_lens * np.sin(angle(ray.k, normal))
self.assertAlmostEqual(n_1_sin_1, n_2_sin_2)
def test_intersect(self):
plane = geometry.Plane(pos=np.zeros(3),
width=_utils.vec(1, 0, 0),
height=_utils.vec(0, 1, 0))
ray = rays.Ray(_utils.pos(.5, .5, 7), k=_utils.vec(0, 0, -1))
self.assertApproxArray(plane.intersect(ray), _utils.pos(.5, .5, 0))
ray = rays.Ray(_utils.pos(.5, .5, 7), k=_utils.vec(0, 0, 1))
self.assertEqual(plane.intersect(ray), None)
def test_refract(self):
screen = geometry.Screen()
ray = rays.Ray(origin=_utils.pos(.5, .5, 1), k=_utils.vec(0, 0, -1))
screen.refract(ray, _utils.pos(.5, .5, 0), 1)
self.assertTrue(ray.terminated)
self.assertSameArray(ray.pos, _utils.pos(.5, .5, 0))
def test_properties(self):
screen = geometry.Screen()
ray = rays.Ray(origin=_utils.pos(.5, .5, 1), k=_utils.vec(0, 0, -1))
screen.refract(ray, _utils.pos(.5, .5, 0), 1)
self.assertEqual(type([]), type(screen.hits))
self.assertEqual(1, len(screen.hits))
self.assertEqual(ray, screen.hits[0])
def test_accept_ray(self):
@materials.accept_ray
def mock(arg):
return arg
self.assertEqual(453e-9, mock(453e-9))
l = 603e-9
self.assertAlmostEqual(l, mock(rays.Ray(frequency=materials.c / l)))
self.assertEqual(500e-9, mock(None))
def test_intersect_axis(self):
ray = rays.Ray(k=_utils.vec(0, 0, 1))
origin = _utils.pos(1, 0, 1)
axis = _utils.vec(0, 1, 0)
pt_ray, pt_axi = ray.intersect_axis(origin, axis)
self.assertApproxArray(pt_ray, _utils.pos(0, 0, 1))
self.assertApproxArray(pt_axi, _utils.pos(1, 0, 1))
self.assertAlmostEqual(_utils.vabs(pt_ray - pt_axi), 1)
def test_refract_sphere_lens(self):
lens = geometry.SphereLens(1, 1, 1, n=1.0, pos=_utils.pos(0, 0, 1))
ray = rays.Ray(origin=np.array([0, 0, 2]))
ray.k = np.array([0, 0, -1])
inter = lens.intersect(ray)
lens.refract(ray, inter, 1.0)
self.assertApproxArray(ray.k, np.array([0, 0, -1]))
self.assertSameArray(inter, ray.pos)
self.assertEqual(None, lens.intersect(ray))
ray = rays.Ray(origin=np.array([0, 0, 1 + 1e-5]))
ray.k = np.array([0, -1, -1])
inter = lens.intersect(ray)
lens.refract(ray, inter, 1.0)
self.assertApproxArray(ray.k,
np.array([0, -1, -1] / np.sqrt(2)),
eps=1e-4)
self.assertSameArray(inter, ray.pos)
self.assertEqual(None, lens.intersect(ray))
def test_intersect(self):
lens = geometry.Sphere(1, 1, 1, pos=_utils.pos(0, 0, 1))
ray = rays.Ray(origin=np.array([0, 0, 2]))
ray.k = np.array([0, 0, -1])
self.assertSameArray(lens.intersect(ray), np.array([0, 0, 1]))
ray.k = np.array([0, 1, -2])
self.assertApproxArray(lens.intersect(ray), np.array([0, .6, .8]))
ray.pos = np.array([0, 0, 0.1])
ray.k = np.array([0, 0, 1])
self.assertEqual(None, lens.intersect(ray))
ray.pos = np.array([0, 0, -1])
ray.k = np.array([0, 0, -1])
self.assertEqual(None, lens.intersect(ray))
ray = rays.Ray(origin=np.array([-1, 0, 2]))
ray.k = np.array([1, 0, -1])
self.assertApproxArray(np.array([0, 0, 1]), lens.intersect(ray))
with self.assertRaises(AttributeError):
lens.intersect(None)
def test_refract(self):
# As refract in Splitter invokes
# super, our proxy class will
# cause runtime errors
class MockSplitter(geometry.Splitter):
def normal(*_):
return _utils.vec(0, 0, 1)
# Check it updates position
splitter = MockSplitter()
ray = rays.Ray(k=_utils.vec(0, 1, 1))
new_pos = _utils.pos(10, 34.2, -70)
splitter.refract(ray, new_pos, 1)
self.assertSameArray(new_pos, ray.pos)
# Check angle in is angle out
tests = [
(_utils.vec(5, 0, 0), 1, 2),
(_utils.vec(1, 3, 5), 1, 3.1),
(_utils.vec(0.246, 5.8, 24.9), 1, 1.1),
(_utils.vec(-3, 1.8, 0), 1, 7.24),
(_utils.vec(43.4, 9.38, -5), 2.1, 4.15),
]
def angle(a, b):
return np.arccos(abs(a.dot(b) / _utils.vabs(a) / _utils.vabs(b)))
for k, n_prev, n_lens in tests:
splitter = MockSplitter(n=n_lens)
ray = rays.Ray(k=k)
ang_1 = angle(ray.k, splitter.normal())
splitter.refract(ray, np.zeros(3), n_prev)
ang_2 = angle(ray.k, splitter.normal())
self.assertAlmostEqual(ang_1, ang_2)
def test_properties(self):
origin = np.array([1, 2, 3], dtype=float)
ray = rays.Ray(origin=origin)
self.assertSameArray(ray.pos, origin)
ray.k = origin * 3
self.assertSameArray(ray.k, origin / _utils.vabs(origin))
ray.pos = origin + origin
self.assertTrue(len(ray) == 2)
self.assertSameArray(ray.pos, ray[-1])
self.assertEqual(len(ray), len(ray.path))
self.assertSameArray(ray[0], ray.path[0])
freq = 7.9
ray.frequency = freq
self.assertAlmostEqual(freq, ray.frequency)
with self.assertRaises(TypeError):
ray.k = [1, 2, 3]
with self.assertRaises(TypeError):
ray.pos = 6.4
def test_defaults(self):
ray = rays.Ray()
self.assertSameArray(ray.pos, np.zeros(3))
self.assertSameArray(ray.k, np.zeros(3))
