def light_sample(self, spectrum):
area = self.edge_a.length() * self.edge_b.length()
inv_area = 1.0 / area
code = """
rnd = random2()
shadepoint.light_pdf = inv_area
shadepoint.light_normal = normal
shadepoint.light_position = point + edge_a * rnd[0] + edge_b * rnd[1]
"""
inv_area = FloatArg('inv_area', inv_area)
normal = Vec3Arg('normal', self.normal)
point = Vec3Arg('point', self.point)
eda = Vec3Arg('edge_a', self.edge_a)
edb = Vec3Arg('edge_b', self.edge_b)
args = [inv_area, normal, point, eda, edb]
func_args = [
StructArgPtr('hitpoint', HitPoint.factory()),
StructArgPtr('shadepoint', ShadePoint.factory(spectrum))
]
name = 'rect_sample_%i' % id(self)
return Shader(code=code,
args=args,
name=name,
func_args=func_args,
is_func=True)
def light_sample(self, spectrum):
area = (self.p1 - self.p0).cross(self.p2 - self.p0).length() * 0.5
inv_area = 1.0 / area
code = """
r1 = random()
tmp = 1.0 - r1
tmp = sqrt(tmp)
beta = 1.0 - tmp
gamma = tmp * random()
shadepoint.light_position = (1.0 - beta - gamma) * p0 + beta * p1 + gamma * p2
shadepoint.light_pdf = inv_area
shadepoint.light_normal = normal
"""
inv_area = FloatArg('inv_area', inv_area)
normal = Vec3Arg('normal', self.normal)
p0 = Vec3Arg('p0', self.p0)
p1 = Vec3Arg('p1', self.p1)
p2 = Vec3Arg('p2', self.p2)
args = [inv_area, normal, p0, p1, p2]
func_args = [StructArgPtr('hitpoint', HitPoint.factory()),
StructArgPtr('shadepoint', ShadePoint.factory(spectrum))]
name = 'triangle_sample_%i' % id(self)
return Shader(code=code, args=args, name=name,
func_args=func_args, is_func=True)
def load(self, shader_name):
args = []
text = self._loader.load(shader_name, 'props.txt')
if text is not None:
args = parse_args(text)
w = Vec3Arg('w', self._w)
u = Vec3Arg('u', self._u)
v = Vec3Arg('v', self._v)
distance = FloatArg('distance', self._distance)
eye = Vec3Arg('eye', self._eye)
lookat = Vec3Arg('lookat', self._lookat)
args.extend([w, u, v, distance, eye, lookat])
code = self._loader.load(shader_name, 'code.py')
if code is None:
raise ValueError("code.py in %s shader dont exist!" % shader_name)
func_args = [
StructArgPtr('ray', Ray.factory()),
StructArgPtr('sample', Sample.factory())
]
self._shader_name = shader_name
self.shader = Shader(code=code,
args=args,
name='generate_ray',
func_args=func_args,
is_func=True)
def _parse_vec3(line):
t = line.split('=', maxsplit=1)
name = t.pop(0).strip()
if len(t) == 0:
return Vec3Arg(name, Vector3(0.0, 0.0, 0.0))
v = t.pop(0).strip().split(',')
arg = Vec3Arg(name, Vector3(float(v[0]), float(v[1]), float(v[2])))
return arg
def test_rgb_area_light(self):
sam_mgr = SampledManager()
register_rgb_shadepoint()
point = Vector3(0.0, 0.0, 55.92)
e1 = Vector3(55.28, 0.0, 0.0)
e2 = Vector3(0.0, 54.88, 0.0)
normal = Vector3(0.0, 0.0, -1.0)
rectangle = Rectangle(point, e1, e2, normal)
material = Material()
material.load('lambertian_emiter', sam_mgr)
e = RGBSpectrum(0.5, 0.5, 0.5)
material.set_value('emission', e)
runtimes = [Runtime()]
lgt = AreaLight(shape=rectangle, material=material)
lgt.load('general', sam_mgr, spectral=False)
lgt.compile()
lgt.prepare(runtimes)
ptrs = lgt.shader.get_ptrs()
ptr_func = PointerArg('ptr_func', ptrs[0])
spec = RGBArg('spec', RGBSpectrum(0.5, 0.5, 0.5))
wi = Vec3Arg('wi', Vector3(0.0, 0.0, 0.0))
pos = Vec3Arg('position', Vector3(0.0, 0.0, 0.0))
n = Vec3Arg('normal', Vector3(0.0, 0.0, 0.0))
pdf = FloatArg('pdf', 0.0)
emission = RGBArg('emission', RGBSpectrum(0.0, 0.0, 0.0))
code = """
hp = HitPoint()
hp.hit = (4.0, 5, 6)
sp = ShadePoint()
__light_radiance(hp, sp, ptr_func)
spec = sp.light_intensity
wi = sp.wi
position = sp.light_position
normal = sp.light_normal
pdf = sp.light_pdf
emission = sp.material_emission
"""
shader = Shader(code=code,
args=[ptr_func, wi, spec, pos, n, pdf, emission])
shader.compile()
shader.prepare(runtimes)
shader.execute()
print("Position ", shader.get_value('position'))
print("Normal ", shader.get_value('normal'))
print("Light pdf ", shader.get_value('pdf'))
print("Emission ", shader.get_value('emission'))
print("Wi ", shader.get_value('wi'))
print("Intensity ", shader.get_value('spec'))
def test_sampled_point_light(self):
sam_mgr = SampledManager()
register_sampled_shadepoint(sam_mgr)
runtimes = [Runtime()]
lgt = GeneralLight()
lgt.load('point', sam_mgr, spectral=True)
lgt.set_value('intensity', RGBSpectrum(0.3, 0.3, 0.3))
lgt.set_value('position', Vector3(2.0, 2.0, 2.0))
lgt.compile()
lgt.prepare(runtimes)
ptrs = lgt.shader.get_ptrs()
ptr_func = PointerArg('ptr_func', ptrs[0])
spec = SampledArg('spec', sam_mgr.zero())
wi = Vec3Arg('wi', Vector3(0.0, 0.0, 0.0))
pos = Vec3Arg('position', Vector3(0.0, 0.0, 0.0))
code = """
hp = HitPoint()
hp.hit = (4.0, 5, 6)
sp = ShadePoint()
__light_radiance(hp, sp, ptr_func)
spec = sp.light_intensity
wi = sp.wi
position = sp.light_position
"""
shader = Shader(code=code, args=[ptr_func, wi, spec, pos])
shader.compile()
shader.prepare(runtimes)
shader.execute()
wi = Vector3(2.0, 2.0, 2.0) - Vector3(4.0, 5.0, 6.0)
wi.normalize()
wi_s = shader.get_value('wi')
self.assertAlmostEqual(wi.x, wi_s.x)
self.assertAlmostEqual(wi.y, wi_s.y)
self.assertAlmostEqual(wi.z, wi_s.z)
p = Vector3(2.0, 2.0, 2.0)
p_s = shader.get_value('position')
self.assertAlmostEqual(p.x, p_s.x)
self.assertAlmostEqual(p.y, p_s.y)
self.assertAlmostEqual(p.z, p_s.z)
s = sam_mgr.rgb_to_sampled(RGBSpectrum(0.3, 0.3, 0.3), illum=True)
s_s = shader.get_value('spec')
for i in range(len(s.samples)):
self.assertAlmostEqual(s.samples[i], s_s.samples[i])
def test_sampled_to_rgb(self):
runtimes = [Runtime()]
color_mgr = SampledManager()
s_to_rgb = spectrum_to_rgb_shader(color_mgr)
s_to_rgb.compile(color_mgr=color_mgr)
s_to_rgb.prepare(runtimes)
code = """
value = spectrum_to_rgb(color)
"""
spec = RGBSpectrum(0.3, 0.5, 0.4)
spec = color_mgr.rgb_to_sampled(spec)
col = SampledArg('color', spec)
val = Vec3Arg('value', Vector3(0.0, 0.0, 0.0))
shader = Shader(code=code, args=[col, val])
shader.compile(shaders=[s_to_rgb], color_mgr=color_mgr)
shader.prepare(runtimes)
shader.execute()
value = shader.get_value('value')
vv = color_mgr.sampled_to_rgb(spec)
self.assertAlmostEqual(value.x, vv.r)
self.assertAlmostEqual(value.y, vv.g)
self.assertAlmostEqual(value.z, vv.b, places=6)
def argument_factory(name, cls):
if cls == int:
return IntArg(name, int())
elif cls == float:
return FloatArg(name, float())
elif cls == Vector3:
return Vec3Arg(name, Vector3.zero())
else:
raise ValueError("Argument factory. Unsuported arugment type", name,
cls)
def _rgb_to_rgb_spectrum_shader(rgb_mgr):
code = """
return rgb(color[0], color[1], color[2])
"""
vec = Vec3Arg('color', Vector3.zero())
shader = Shader(code=code,
name='rgb_to_spectrum',
func_args=[vec],
is_func=True)
return shader
def prepare_standalone(self):
runtimes = [Runtime()]
self.compile()
self.prepare(runtimes)
code = """
ray = Ray()
generate_ray(ray, sample)
origin = ray.origin
direction = ray.direction
"""
origin = Vec3Arg('origin', Vector3(0.0, 0.0, 0.0))
direction = Vec3Arg('direction', Vector3(0.0, 0.0, 0.0))
sample = Sample(0.0, 0.0, 0.0, 0.0, 0, 0, 0.0)
sample_arg = StructArg('sample', sample)
args = [origin, direction, sample_arg]
self._standalone = shader = Shader(code=code, args=args)
shader.compile([self.shader])
shader.prepare(runtimes)
def visiblity_shader(self):
func_args = [Vec3Arg('p1', Vector3(0.0, 0.0, 0.0)),
Vec3Arg('p2', Vector3(0.0, 0.0, 0.0))]
code = """
epsilon = 0.00001
direction = p2 - p1
len_squared = dot(direction, direction)
distance = sqrt(len_squared) - epsilon
ray = Ray()
ray.origin = p1
ray.direction = normalize(direction)
"""
args = []
for shp_type in self.shp_mgr.shape_types():
code1, args1 = self._get_visibility_code(shp_type)
args.extend(args1)
code += code1
code += "\nreturn 1\n"
shader = Shader(code=code, args=args, name='visibility',
func_args=func_args, is_func=True)
return shader
def test_light_manager(self):
sam_mgr = SampledManager()
register_rgb_shadepoint()
runtimes = [Runtime(), Runtime()]
lgt = GeneralLight()
lgt.load('point', sam_mgr, spectral=False)
lgt2 = GeneralLight()
lgt2.load('point', sam_mgr, spectral=False)
lgt2.set_value('intensity', RGBSpectrum(0.3, 0.3, 0.3))
lgt2.set_value('position', Vector3(2.0, 2.0, 2.0))
mgr = LightManager()
mgr.add('light1', lgt)
mgr.add('light2', lgt2)
mgr.compile_shaders(sam_mgr, spectral=False)
mgr.prepare_shaders(runtimes)
code = """
hp = HitPoint()
hp.hit = (4.0, 5, 6)
sp = ShadePoint()
light_radiance(hp, sp, 1)
wi = sp.wi
n = number_of_lights()
"""
wi = Vec3Arg('wi', Vector3(0.0, 0.0, 0.0))
nlights = IntArg('n', 999)
shader = Shader(code=code, args=[wi, nlights])
shader.compile(shaders=[mgr.rad_shader, mgr.nlights_shader])
shader.prepare(runtimes)
shader.execute()
wi = Vector3(2.0, 2.0, 2.0) - Vector3(4.0, 5.0, 6.0)
wi.normalize()
wi_s = shader.get_value('wi')
self.assertAlmostEqual(wi.x, wi_s.x)
self.assertAlmostEqual(wi.y, wi_s.y)
self.assertAlmostEqual(wi.z, wi_s.z)
self.assertEqual(2, shader.get_value('n'))
def test_material_sampling_manager(self):
sam_mgr = SampledManager()
register_rgb_shadepoint()
runtimes = [Runtime(), Runtime()]
mat = Material()
mat.load('lambertian', sam_mgr, spectral=False)
mat.set_value('diffuse', RGBSpectrum(0.2, 0.3, 0.4))
mgr = MaterialManager()
mgr.add('material1', mat)
mgr.compile_shaders(sam_mgr, spectral=False)
mgr.prepare_shaders(runtimes)
code = """
hp = HitPoint()
hp.normal = (0.1, 0.4, 0.66)
hp.normal = normalize(hp.normal)
sp = ShadePoint()
material_sampling(hp, sp, 0)
pdf = sp.pdf
wi = sp.wi
spec = sp.material_reflectance
"""
pdf = FloatArg('pdf', 0.0)
wi = Vec3Arg('wi', Vector3(0.0, 0.0, 0.0))
spec = RGBArg('spec', RGBSpectrum(0.5, 0.5, 0.5))
shader = Shader(code=code, args=[pdf, wi, spec])
shader.compile(shaders=[mgr.sampling_shader])
shader.prepare(runtimes)
shader.execute()
s = shader.get_value('pdf')
print(s)
s = shader.get_value('wi')
print(s)
s = shader.get_value('spec')
print(s)
normal = Vector3(0.1, 0.4, 0.66)
normal.normalize()
print(cos_hemisphere(r1=0.1, r2=0.06, normal=normal, e=1.0))
def test_rgb_to_rgb_spectrum(self):
runtimes = [Runtime()]
color_mgr = RGBManager()
rgb_to_spec = rgb_to_spectrum_shader(color_mgr)
rgb_to_spec.compile(color_mgr=color_mgr)
rgb_to_spec.prepare(runtimes)
code = """
spec = rgb_to_spectrum(color)
"""
val = Vector3(0.3, 0.5, 0.7)
col = Vec3Arg('color', val)
spec = RGBArg('spec', RGBSpectrum(0.0, 0.0, 0.0))
shader = Shader(code=code, args=[col, spec])
shader.compile(shaders=[rgb_to_spec], color_mgr=color_mgr)
shader.prepare(runtimes)
shader.execute()
value = shader.get_value('spec')
self.assertAlmostEqual(value.r, val.x)
self.assertAlmostEqual(value.g, val.y)
self.assertAlmostEqual(value.b, val.z)
def test_rgb_to_rgb(self):
runtimes = [Runtime()]
color_mgr = RGBManager()
s_to_rgb = spectrum_to_rgb_shader(color_mgr)
s_to_rgb.compile(color_mgr=color_mgr)
s_to_rgb.prepare(runtimes)
code = """
value = spectrum_to_rgb(color)
"""
spec = RGBSpectrum(0.3, 0.5, 0.4)
col = RGBArg('color', spec)
val = Vec3Arg('value', Vector3(0.0, 0.0, 0.0))
shader = Shader(code=code, args=[col, val])
shader.compile(shaders=[s_to_rgb], color_mgr=color_mgr)
shader.prepare(runtimes)
shader.execute()
value = shader.get_value('value')
self.assertAlmostEqual(value.x, 0.3)
self.assertAlmostEqual(value.y, 0.5)
self.assertAlmostEqual(value.z, 0.4)
def test_rgb_to_sampled_spectrum(self):
runtimes = [Runtime()]
color_mgr = SampledManager()
rgb_to_spec = rgb_to_spectrum_shader(color_mgr)
rgb_to_spec.compile(color_mgr=color_mgr)
rgb_to_spec.prepare(runtimes)
code = """
spec = rgb_to_spectrum(color)
"""
val = Vector3(0.3, 0.5, 0.7)
col = Vec3Arg('color', val)
spec = SampledArg('spec', color_mgr.zero())
shader = Shader(code=code, args=[col, spec])
shader.compile(shaders=[rgb_to_spec], color_mgr=color_mgr)
shader.prepare(runtimes)
shader.execute()
value = shader.get_value('spec')
vv = color_mgr.rgb_to_sampled(RGBSpectrum(val.x, val.y, val.z))
for i in range(len(value.samples)):
self.assertAlmostEqual(value.samples[i], vv.samples[i], places=6)
def _rgb_to_sampled_shader(sampled_mgr):
code = """
# conversion of reflectance
r = color[0]
g = color[1]
b = color[2]
tmp = min(r, g)
tmp = min(tmp, b)
if tmp == r:
# Compute illuminant with red as minimum
rez = r * spect_white
if g > b:
rez = rez + (b - r) * spect_cyan
rez = rez + (g - b) * spect_green
else:
rez = rez + (g - r) * spect_cyan
rez = rez + (b - g) * spect_blue
else:
dummy = 999999 # elif is still not supported in shading language
if tmp == g:
# Compute illuminant with green as minimum
rez = g * spect_white
if r > b:
rez = rez + (b - g) * spect_magenta
rez = rez + (r - b) * spect_red
else:
rez = rez + (r - g) * spect_magenta
rez = rez + (b - r) * spect_blue
else:
# Compute illuminant with blue as minimum
rez = b * spect_white
if r > g:
rez = rez + (g - b) * spect_yellow
rez = rez + (r - g) * spect_red
else:
rez = rez + (r - b) * spect_yellow
rez = rez + (g - r) * spect_green
rez = rez * 0.94
#rez.clamp()
return rez
"""
vec = Vec3Arg('color', Vector3.zero())
spect_cyan = SampledArg('spect_cyan', sampled_mgr._spect_cyan)
spect_blue = SampledArg('spect_blue', sampled_mgr._spect_blue)
spect_green = SampledArg('spect_green', sampled_mgr._spect_green)
spect_magenta = SampledArg('spect_magenta', sampled_mgr._spect_magenta)
spect_red = SampledArg('spect_red', sampled_mgr._spect_red)
spect_yellow = SampledArg('spect_yellow', sampled_mgr._spect_yellow)
spect_white = SampledArg('spect_white', sampled_mgr._spect_white)
args = [
spect_cyan, spect_blue, spect_green, spect_magenta, spect_red,
spect_yellow, spect_white
]
shader = Shader(code=code,
args=args,
name='rgb_to_spectrum',
func_args=[vec],
is_func=True)
return shader
def ray_triangle_isect_shader(name, isect_bool=False):
code = """
origin = ray.origin
direction = ray.direction
a = p0[0] - p1[0]
b = p0[0] - p2[0]
c = direction[0]
d = p0[0] - origin[0]
e = p0[1] - p1[1]
f = p0[1] - p2[1]
g = direction[1]
h = p0[1]- origin[1]
i = p0[2] - p1[2]
j = p0[2] - p2[2]
k = direction[2]
l = p0[2] - origin[2]
m = f * k - g * j
n = h * k - g * l
p = f * l - h * j
q = g * i - e * k
s = e * j - f * i
temp3 = a * m + b * q + c * s
if temp3 == 0.0:
return 0
inv_denom = 1.0 / temp3
e1 = d * m - b * n - c * p
beta = e1 * inv_denom
if beta < 0.0:
return 0
r = e * l - h * i
e2 = a * n + d * q + c * r
gamma = e2 * inv_denom
if gamma < 0.0:
return 0
betagamma = beta + gamma
if betagamma > 1.0:
return 0
e3 = a * p - b * r + d * s
t = e3 * inv_denom
epsilon = 0.00001
if t < 0.00001:
return 0
if t > min_dist:
return 0
"""
if isect_bool:
code += """
return 1
"""
else:
code += """
hitpoint.t = t
hitpoint.hit = direction * t + origin
hitpoint.u = beta
hitpoint.v = gamma
return 1
"""
ray_a = StructArgPtr('ray', Ray.factory())
p0 = Vec3Arg('p0', Vector3(0.0, 0.0, 0.0))
p1 = Vec3Arg('p1', Vector3(0.0, 0.0, 0.0))
p2 = Vec3Arg('p2', Vector3(0.0, 0.0, 0.0))
dist = FloatArg('min_dist', 0.0)
hit_a = StructArgPtr('hitpoint', HitPoint.factory())
if isect_bool:
func_args = [ray_a, p0, p1, p2, dist]
else:
func_args = [ray_a, p0, p1, p2, dist, hit_a]
shader = Shader(code=code,
args=[],
name=name,
func_args=func_args,
is_func=True)
return shader
def atest_material_glass(self):
sam_mgr = SampledManager()
register_rgb_shadepoint()
runtimes = [Runtime()]
mat = Material()
mat.load('glass', sam_mgr, spectral=False)
mat.set_value('ior', 1.5)
mgr = MaterialManager()
mgr.add('material1', mat)
shaders = shaders_functions()
for shader in shaders:
shader.compile()
shader.prepare(runtimes)
mgr.compile_shaders(sam_mgr, spectral=False, shaders=shaders)
mgr.prepare_shaders(runtimes)
code = """
hp = HitPoint()
hp.normal = normal
sp = ShadePoint()
sp.wo = wo
material_sampling(hp, sp, 0)
pdf = sp.pdf
wi = sp.wi
spec = sp.material_reflectance
"""
pdf = FloatArg('pdf', 0.0)
wi = Vec3Arg('wi', Vector3(0.0, 0.0, 0.0))
ww = Vector3(5.0, 1.0, 0.0)
ww.normalize()
wo = Vec3Arg('wo', ww)
nn = Vector3(0.0, 1.0, 0.0)
nn.normalize()
normal = Vec3Arg('normal', nn)
spec = RGBArg('spec', RGBSpectrum(0.5, 0.5, 0.5))
shader = Shader(code=code, args=[pdf, wi, wo, normal, spec])
shader.compile(shaders=[mgr.sampling_shader])
shader.prepare(runtimes)
shader.execute()
s = shader.get_value('wi')
print(s)
s = shader.get_value('pdf')
print(s)
s = shader.get_value('spec')
print(s)
print('------------------------------')
print('wo', ww)
wi, pdf, ref = sampling_glass(1.5, ww, nn)
print("wi", wi)
print("pdf", pdf)
print("ref", ref)
ndotwi = abs(nn.dot(wi))
print("ndotwi", ndotwi)
tmp = ndotwi / pdf
path_weight = ref * tmp
print("path weight", path_weight)
