def sample_p(self, p, u1, u2):
"""Sample at point p."""
# Compute coordinate system for sphere sampling
p_center = self.object_to_world(Point(0, 0, 0))
wc = normalize(p_center - p)
wc_x, wc_y = coordinate_system(wc)
# Sample uniformly on sphere if $\pt{}$ is inside it
if (distance_squared(p, p_center) - self.radius * self.radius) < 1e-4:
return self.sample(u1, u2)
# Sample sphere uniformly inside subtended cone
sin_theta_max2 = self.radius * self.radius / distance_squared(
p, p_center)
cos_theta_max = math.sqrt(max(0.0, 1.0 - sin_theta_max2))
raise Exception("next_line")
# r = Ray(p, uniform_sample_cone(u1, u2, cos_theta_max, wcX, wcY, wc), 1e-3)
r = Ray(p)
intersect, t_hit, ray_epsilon, dg_sphere = self.intersect(r)
if not intersect:
t_hit = dot(p_center - p, normalize(r.d))
ps = r(t_hit)
ns = Normal(normalize(ps - p_center))
if (self.reverse_orientation):
ns *= -1.0
return ps, ns
def sample(self, u1, u2):
"""Sample the shape."""
raise Exception("check_next_line")
p = Point(0, 0, 0) + self.radius * 1.0 # uniform_sample_sphere(u1, u2)
ns = normalize(self.object_to_world(Normal(p.x, p.y, p.z)))
if (self.reverse_orientation):
ns *= -1.0
return self.object_to_world(p), ns
def test_transform(self):
p = Point(1, 2, 3)
p2 = translate(Point(10, 20, 30))(p)
self.assertTrue(isinstance(p2, Point))
self.assertEqual(p2, Point(11, 22, 33))
v = Vector(1, 2, 3)
v2 = translate(Point(10, 20, 30))(v)
self.assertTrue(isinstance(v2, Vector))
self.assertEqual(v2, Vector(1, 2, 3))
self.assertEqual(scale(2, 3, 4)(Point(1, 2, 3)),
Point(2, 6, 12))
self.assertEqual(scale(2, 3, 4)(Vector(1, 2, 3)),
Vector(2, 6, 12))
self.assertEqual(rotate(90, Vector(0, 1, 0))(Normal(1, 0, 0)),
Normal(0, 0, -1))
def test_normal(self):
# operator[]
n = Normal(1.0, 2.0, 3.0)
self.assertEqual(n[0], 1.0)
self.assertEqual(n[1], 2.0)
self.assertEqual(n[2], 3.0)
# face_forward
n2 = Normal(1, 0, 0)
v = Vector(-0.5, -0.1, 0.2)
self.assertEqual(face_forward(n, v), -n)
# operator[] for assignments
n = Normal(1.0, 2.0, 3.0)
for i in range(3):
n[i] = 9.0
self.assertEqual(n[i], 9.0)
def __init__(self):
"""Default constructor for DifferentialGeometry."""
self.p = Point()
self.nn = Normal()
self.u = 0.0
self.v = 0.0
self.shape = None
self.dp_du = Vector()
self.dp_dv = Vector()
self.dn_du = Normal()
self.dn_dv = Normal()
self.dp_dx = Vector()
self.dp_dy = Vector()
self.du_dx = 0.0
self.dv_dx = 0.0
self.du_dy = 0.0
self.dv_dy = 0.0
def __call__(self, elt):
"""Overload the operator().
Supported operations:
* Transform(Point)
* Transform(Vector)
* Transform(Normal)
* Transform(Ray)
* Transform(RayDifferential)
* Transform(BBox)
"""
if isinstance(elt, Point):
x = elt.x
y = elt.y
z = elt.z
xp = self.m.m[0][0] * x + self.m.m[0][1] * y + self.m.m[0][
2] * z + self.m.m[0][3]
yp = self.m.m[1][0] * x + self.m.m[1][1] * y + self.m.m[1][
2] * z + self.m.m[1][3]
zp = self.m.m[2][0] * x + self.m.m[2][1] * y + self.m.m[2][
2] * z + self.m.m[2][3]
wp = self.m.m[3][0] * x + self.m.m[3][1] * y + self.m.m[3][
2] * z + self.m.m[3][3]
if wp == 1.0:
return Point(xp, yp, zp)
else:
return Point(xp, yp, zp) / wp
elif isinstance(elt, Vector):
x = elt.x
y = elt.y
z = elt.z
xp = self.m.m[0][0] * x + self.m.m[0][1] * y + self.m.m[0][2] * z
yp = self.m.m[1][0] * x + self.m.m[1][1] * y + self.m.m[1][2] * z
zp = self.m.m[2][0] * x + self.m.m[2][1] * y + self.m.m[2][2] * z
return Vector(xp, yp, zp)
elif isinstance(elt, Normal):
x = elt.x
y = elt.y
z = elt.z
return Normal(
self.m_inv.m[0][0] * x + self.m_inv.m[1][0] * y +
self.m_inv.m[2][0] * z, self.m_inv.m[0][1] * x +
self.m_inv.m[1][1] * y + self.m_inv.m[2][1] * z,
self.m_inv.m[0][2] * x + self.m_inv.m[1][2] * y +
self.m_inv.m[2][2] * z)
elif isinstance(elt, RayDifferential):
ray = RayDifferential.from_ray_differential(elt)
ray.o = self(ray.o)
ray.d = self(ray.d)
ray.rx_origin = self(ray.rx_origin)
ray.ry_origin = self(ray.ry_origin)
ray.rx_direction = self(ray.rx_direction)
ray.ry_direction = self(ray.ry_direction)
return ray
elif isinstance(elt, Ray):
ray = Ray.from_ray(elt)
ray.o = self(ray.o)
ray.d = self(ray.d)
return ray
elif isinstance(elt, BBox):
ret = BBox(self(Point(elt.p_min.x, elt.p_min.y, elt.p_min.z)))
ret = union(ret, self(Point(elt.p_max.x, elt.p_min.y,
elt.p_min.z)))
ret = union(ret, self(Point(elt.p_min.x, elt.p_max.y,
elt.p_min.z)))
ret = union(ret, self(Point(elt.p_min.x, elt.p_min.y,
elt.p_max.z)))
ret = union(ret, self(Point(elt.p_min.x, elt.p_max.y,
elt.p_max.z)))
ret = union(ret, self(Point(elt.p_max.x, elt.p_max.y,
elt.p_min.z)))
ret = union(ret, self(Point(elt.p_max.x, elt.p_min.y,
elt.p_max.z)))
ret = union(ret, self(Point(elt.p_max.x, elt.p_max.y,
elt.p_max.z)))
return ret
