def performance_regular_sampler(width, height):
sam = RegularSampler(width, height)
runtimes = [Runtime(), Runtime(), Runtime(), Runtime()]
sam.prepare(runtimes)
sam.set_pass(0)
code = """
ret = 1
nsamples = 0
while ret != 0:
ret = generate_sample(sample)
if ret == 0:
break
nsamples = nsamples + 1
"""
sample = Sample(0.0, 0.0, 0, 0, 1.0)
props = {'sample': sample, 'ret': 0, 'nsamples': 0}
bas = BasicShader(code, props)
bas.prepare(runtimes, [sam.shader])
start = time.clock()
bas.execute()
end = time.clock()
print("Exectution of generating %i samples took %f" %
(bas.shader.get_value('nsamples'), end - start))
def atest_material_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()
sp = ShadePoint()
material_reflectance(hp, sp, 0)
spec = sp.material_reflectance
"""
spec = RGBArg('spec', RGBSpectrum(0.5, 0.5, 0.5))
shader = Shader(code=code, args=[spec])
shader.compile(shaders=[mgr.ref_shader])
shader.prepare(runtimes)
shader.execute()
s = shader.get_value('spec')
ls = RGBSpectrum(0.2, 0.3, 0.4) * (1.0 / math.pi)
self.assertAlmostEqual(s.r, ls.r)
self.assertAlmostEqual(s.g, ls.g)
self.assertAlmostEqual(s.b, ls.b)
def test_assign1(self):
code = """
shadepoint.light_intensity = spectrum(0.25)
sample = sample_hemisphere()
sample = (0.6, 0.4, 0.8)
#w = hitpoint.normal
w = (2.3, 2.5, 8.8)
w = normalize(w)
tv = (0.0034, 1.0, 0.0071)
v = cross(tv, w)
v = normalize(v)
u = cross(v, w)
ndir = u * sample[0] + v * sample[1] + w * sample[2]
shadepoint.wi = normalize(ndir)
shadepoint.pdf = dot(w, shadepoint.wi) * 0.318309886
"""
props = {}
col_mgr = ColorManager(spectral=True)
brdf = SurfaceShader(code, props, col_mgr=col_mgr)
mat = Material(bsdf=brdf)
mgr = MaterialManager()
mgr.add('blue_velvet', mat)
runtime = Runtime()
runtime2 = Runtime()
runtimes = [runtime, runtime2]
#bs.prepare([runtime])
shader = mgr.prepare_bsdf('brdf', runtimes)
#print (bs.shader._code)
#bs.execute()
sh = ShadePoint()
code = """
hp = Hitpoint()
sp = Shadepoint()
brdf(hp, sp, 0)
spec = sp.light_intensity
wi = sp.wi
pdf = sp.pdf
"""
wi = Vector3(2, 2, 2)
spec = col_mgr.black()
props = {'spec': spec, 'wi': wi, 'pdf': 0.0}
bs = BasicShader(code, props, col_mgr=col_mgr)
bs.prepare(runtimes, shaders=[shader])
print (bs.shader._code)
bs.execute()
print(bs.shader.get_value('spec'))
print(bs.shader.get_value('wi'))
print(bs.shader.get_value('pdf'))
print(next_direction())
def test_sincos_ps(self):
asm = Tdasm()
mc = asm.assemble(SINCOS_CODE_PS)
runtime = Runtime()
load_math_func("fast_sincos_ps", runtime)
ds = runtime.load("sincos_ps", mc)
for x in range(1000):
num1 = random.random() * 2000
num2 = random.random() * 2000
num3 = random.random() * 2000
num4 = random.random() * 2000
ds["v1"] = (num1, num2, num3, num4)
runtime.run("sincos_ps")
rez_asm_sin = ds["v1"]
rez_asm_cos = ds["v2"]
rez_py1_sin = math.sin(num1)
rez_py2_sin = math.sin(num2)
rez_py3_sin = math.sin(num3)
rez_py4_sin = math.sin(num4)
rez_py1_cos = math.cos(num1)
rez_py2_cos = math.cos(num2)
rez_py3_cos = math.cos(num3)
rez_py4_cos = math.cos(num4)
self.assertAlmostEqual(rez_asm_sin[0], rez_py1_sin, 3)
self.assertAlmostEqual(rez_asm_sin[1], rez_py2_sin, 3)
self.assertAlmostEqual(rez_asm_sin[2], rez_py3_sin, 3)
self.assertAlmostEqual(rez_asm_sin[3], rez_py4_sin, 3)
self.assertAlmostEqual(rez_asm_cos[0], rez_py1_cos, 3)
self.assertAlmostEqual(rez_asm_cos[1], rez_py2_cos, 3)
self.assertAlmostEqual(rez_asm_cos[2], rez_py3_cos, 3)
self.assertAlmostEqual(rez_asm_cos[3], rez_py4_cos, 3)
def test_mesh_b(mesh, nrays=1):
dep_shader = type(mesh).isect_b_shader('ray_flat_mesh_b_isect')
dep_shader.compile()
runtimes = [Runtime()]
dep_shader.prepare(runtimes)
code = """
min_dist = 99999.0
ret = ray_flat_mesh_b_isect(ray, mesh, min_dist)
"""
origin = calculate_origin(mesh)
rpoint = random_in_bbox(mesh._grid.bbox)
direction = rpoint - origin
direction.normalize()
ray = Ray(origin, direction)
r_arg = StructArg('ray', ray)
mesh_arg = StructArg('mesh', mesh)
ret = IntArg('ret', 6)
args = [r_arg, mesh_arg, ret]
shader = Shader(code=code, args=args)
shader.compile([dep_shader.shader])
shader.prepare(runtimes)
hp = mesh.isect_b(ray)
shader.execute()
print("Bool isect", hp, shader.get_value('ret'))
def test_isect_b(self):
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)
origin = Vector3(3.0, 2.5, 0.0)
direction = Vector3(0.0, 0.1, 0.88)
direction.normalize()
ray = Ray(origin, direction)
runtime = Runtime()
rectangle.isect_asm_b([runtime], "ray_rectangle_intersection")
assembler = create_assembler()
mc = assembler.assemble(self.asm_code_bool())
ds = runtime.load("test", mc)
Ray.populate_ds(ds, ray, 'ray1')
Rectangle.populate_ds(ds, rectangle, 'rec1')
runtime.run("test")
hp = rectangle.isect(ray)
if hp is False: self.assertFalse(ds["ret"] != 0)
if ds["ret"] == 0: self.assertFalse(hp)
def test_shader1(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
irender = renmas2.IRender(ren)
#ren.spectral_rendering = True
runtime = Runtime()
irender.add_light(type="pointlight",
name="light1",
source=(4.0, 4.0, 4.0),
position=(10.1, 10, 10))
irender.add_shape(type="sphere",
name="Sphere00",
radius=3.0,
position=(0.0, 0.0, 0.0))
ren.prepare()
ren.intersector.visibility_asm([runtime], "ray_scene_visibility")
ren.shader.shade_asm([runtime], "shade", "ray_scene_visibility")
mc = ren.assembler.assemble(self.asm_code1(ren))
ds = runtime.load("test", mc)
ds["hp.hit"] = (4.4, 2.2, 1.0, 0.0)
ds["hp.t"] = 2.2
ds["hp.normal"] = (0.0, 1.0, 0.0, 0.0)
ds["hp.mat_index"] = 0
runtime.run("test")
hit = renmas2.Vector3(4.4, 2.2, 1.0)
normal = renmas2.Vector3(0.0, 1.0, 0.0)
hp = renmas2.shapes.HitPoint(2.2, hit, normal, 0)
ret = ren.shader.shade(hp)
print(ret)
print(ds["hp.l_spectrum.values"])
def test_sampled_spec_to_vec(self):
mgr = SampledManager()
shader = sampled_to_vec_shader(mgr)
shader.compile()
runtime = Runtime()
shader.prepare([runtime])
code = """
rez = spectrum_to_vec(r1)
"""
vals = [(450, 0.13), (480, 0.45), (620, 0.58)]
samples = create_samples(vals, 32, 400, 700)
sam_spec = SampledSpectrum(samples)
s = SampledArg('r1', sam_spec)
rez = Vec3Arg('rez', Vector3(0.0, 0.0, 0.0))
shader2 = Shader(code=code, args=[rez, s])
shader2.compile([shader])
shader2.prepare([runtime])
shader2.execute()
val = shader2.get_value('rez')
conv = mgr.sampled_to_rgb(sam_spec)
self.assertAlmostEqual(val.x, conv.r, places=6)
self.assertAlmostEqual(val.y, conv.g, places=6)
self.assertAlmostEqual(val.z, conv.b, places=6)
def test_sampled_spectrum(self):
code = """
spec2 = Spectrum(spec, 0.23)
"""
vals = [(450, 0.13), (480, 0.45), (620, 0.58)]
samples = create_samples(vals, 32, 400, 700)
sam_spec = SampledSpectrum(samples)
spec = SampledArg('spec', sam_spec)
vals = [(450, 0.11)]
samples = create_samples(vals, 32, 400, 700)
sam_spec = SampledSpectrum(samples)
spec2 = SampledArg('spec2', sam_spec)
shader = Shader(code=code, args=[spec, spec2])
shader.compile()
runtime = Runtime()
shader.prepare([runtime])
shader.execute()
val = shader.get_value('spec2')
for i in range(len(val.samples)):
self.assertAlmostEqual(val.samples[i], 0.23)
def test_hemisphere_cos(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
mat1 = ren.shader.material("default")
sam = renmas2.materials.HemisphereCos(1.5)
mat1.add(sam)
normal = factory.vector(2, 4, 5)
normal.normalize()
hit_point = factory.vector(3, 5, 6)
hp = renmas2.shapes.HitPoint(1.5, hit_point, normal, 0)
ren.macro_call.set_runtimes([runtime])
mat1.next_direction_asm([runtime], ren.structures, ren.assembler)
mc = ren.assembler.assemble(self.asm_code1(ren))
ds = runtime.load("test", mc)
ds["next_dir_ptr"] = runtime.address_module(mat1.nd_asm_name)
ds["hp.normal"] = (normal.x, normal.y, normal.z, 0.0)
ds["hp.t"] = 1.5
ds["hp.hit"] = (hit_point.x, hit_point.y, hit_point.z)
runtime.run("test")
print(ds['hp.wi'])
print(ds['hp.ndotwi'])
print(ds['hp.pdf'])
mat1.next_direction(hp)
print(hp.ndotwi)
print(hp.wi)
print(hp.pdf)
def test_isect1(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
ply = renmas2.core.Ply()
ply.load("I:/Ply_files/Horse97K.ply")
vb = ply.vertex_buffer
tb = ply.triangle_buffer
mesh = factory.create_mesh(vb, tb)
mesh.isect_asm([runtime], "ray_smooth_mesh_intersection",
ren.assembler, ren.structures)
mc = ren.assembler.assemble(self.asm_code1(ren))
ds = runtime.load("test", mc)
for i in range(1000):
ray = self.random_ray()
self.ray_ds(ds, ray, "ray1")
self.smooth_mesh_ds(ds, mesh, "mesh1")
runtime.run("test")
hp = mesh.isect(ray)
if hp:
#print(hp.t, ds["hp1.t"])
n1 = hp.normal
n2 = ds["hp1.normal"]
self.assertAlmostEqual(n1.x, n2[0], 3)
self.assertAlmostEqual(n1.y, n2[1], 3)
self.assertAlmostEqual(n1.z, n2[2], 3)
def test_isect1(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
triangle = factory.create_triangle(v0=(2, 2, 2),
v1=(5, 2, 2),
v2=(3.5, 5, 2))
triangle = factory.create_triangle(v0=(3.64479, 19.4901, 31.67),
v1=(1.5157999, 0.6639999, 31.8798),
v2=(1.4469, 0.663999, 31.415))
ray = factory.create_ray(origin=(280.0, 110.0, 244.0),
direction=(-0.759278, -0.2980911,
-0.57847869))
#hp = triangle.isect(ray)
triangle.isect_asm([runtime], "ray_triangle_intersection",
ren.assembler, ren.structures)
mc = ren.assembler.assemble(self.asm_code(ren))
ds = runtime.load("test", mc)
self.ray_ds(ds, ray, "ray1")
self.triangle_ds(ds, triangle, "tri1")
runtime.run("test")
self.intersect(ray, triangle, runtime, ds)
for i in range(1000):
r = self.random_ray()
t = self.random_triangle()
self.intersect(r, t, runtime, ds)
def _build_runtime(self):
start = time.clock()
self._runtime = runtime = Runtime()
self._sampler.get_sample_asm(runtime, "get_sample")
self._camera.ray_asm(runtime, "generate_ray")
self._world_arrays = {}
darr = renmas.utils.DynamicArray(self._grid.struct())
darr.add_instance(self._grid.attributes())
self._world_arrays[type(self._grid)] = darr
renmas.shapes.linear_isect_asm(runtime, "scene_isect",
self._world_arrays)
renmas.shapes.visible_asm(runtime, "visible", "scene_isect")
renmas.core.generate_shade(runtime, "shade", "visible", self)
self._film.add_sample_asm(runtime, "add_sample")
if self._algorithm_name == "raycast_asm":
renmas.integrators.prepare_raycast_asm(runtime) #alogorithm
else:
renmas.integrators.prepare_pathtracer_asm(runtime) #alogorithm
end = time.clock()
log.info("Time to builde Runtime object: " + str(end - start))
return runtime
def test_isect_b_rect(self):
rect_shader = Rectangle.isect_b_shader('isect_b_rectangle')
rect_shader.compile()
runtimes = [Runtime()]
rect_shader.prepare(runtimes)
code = """
min_dist = 99999.0
p1 = isect_b_rectangle(ray, rectangle, min_dist)
"""
origin = Vector3(3.0, 2.5, 0.0)
direction = Vector3(0.0, 0.1, 0.88)
direction.normalize()
ray = Ray(origin, direction)
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)
r_arg = StructArg('ray', ray)
sph_arg = StructArg('rectangle', rectangle)
p1 = IntArg('p1', 6)
args = [r_arg, sph_arg, p1]
shader = Shader(code=code, args=args)
shader.compile([rect_shader.shader])
shader.prepare(runtimes)
shader.execute()
result = shader.get_value('p1')
self.assertEqual(result, 1)
def test1(self):
mgr = ColorManager()
sampler = RandomSampler(2, 2, pixel=1.0)
tile = Tile(0, 0, 3, 3)
tile.split(1)
runtime = Runtime()
mgr.macro_call.set_runtimes([runtime])
sampler.get_sample_asm([runtime], "get_sample", mgr.assembler)
mc = mgr.assembler.assemble(self.asm_code())
ds = runtime.load('test', mc)
sampler.set_tile(tile)
while True:
sample = sampler.get_sample()
if sample is None:
break
runtime.run('test')
self.show_samples(sample, ds)
runtime.run('test')
ret = ds['kraj']
self.assertFalse(ret)
def test_pow_ps(self):
asm = Tdasm()
mc = asm.assemble(POW_CODE_PS)
runtime = Runtime()
load_math_func("fast_pow_ps", runtime)
ds = runtime.load("pow_ps", mc)
for x in range(1000):
num1 = random.random() * 3
num2 = random.random() * 3
num3 = random.random() * 3
num4 = random.random() * 3
num5 = random.random() * 3
num6 = random.random() * 3
num7 = random.random() * 3
num8 = random.random() * 3
ds["v1"] = (num1, num2, num3, num4)
ds["v2"] = (num5, num6, num7, num8)
runtime.run("pow_ps")
rez_asm = ds["v1"]
rez_py1 = math.pow(num1, num5)
rez_py2 = math.pow(num2, num6)
rez_py3 = math.pow(num3, num7)
rez_py4 = math.pow(num4, num8)
self.assertAlmostEqual(rez_asm[0], rez_py1, 1)
self.assertAlmostEqual(rez_asm[1], rez_py2, 1)
self.assertAlmostEqual(rez_asm[2], rez_py3, 1)
self.assertAlmostEqual(rez_asm[3], rez_py4, 1)
def test_addsample(self):
ren = renmas2.Renderer()
runtime = Runtime()
#ren.spectrum_rendering = True
ren.film.nsamples = 2
ren.prepare()
ren.converter.to_rgb_asm("spectrum_to_rgb", [runtime])
ren.film.add_sample_asm([runtime], "add_sample", "spectrum_to_rgb")
mc = ren.assembler.assemble(self.asm_code(ren))
ds = runtime.load("test", mc)
ds["sp1.ix"] = 10
ds["sp1.iy"] = 10
ds["sp1.xyxy"] = (10.4, 10.4, 10.4, 10.4)
sample = renmas2.samplers.Sample(10.4, 10.4, 10, 10, 0.5)
spec = ren.converter.create_spectrum((0.70, 0.2, 0.3))
ren.film.add_sample(sample, spec)
ds["spec1.values"] = spec.to_ds()
runtime.run("test")
ds["sp1.ix"] = 15
ds["sp1.iy"] = 19
ds["sp1.xyxy"] = (15.7, 19.4, 15.7, 19.4)
sample = renmas2.samplers.Sample(10.4, 10.4, 15, 19, 0.5)
spec = ren.converter.create_spectrum((0.50, 0.4, 0.1))
ren.film.add_sample(sample, spec)
ds["spec1.values"] = spec.to_ds()
runtime.run("test")
print(ren.film._ds[0]["temp"])
def test_assign4(self):
code = """
spec1 = sh.spectrum1
sh.spectrum2 = spec2
"""
nsamples = 32
rgb = SampledSpectrum([0.1] * nsamples)
rgb2 = SampledSpectrum([0.2] * nsamples)
rgb3 = SampledSpectrum([0.3] * nsamples)
rgb4 = SampledSpectrum([0.4] * nsamples)
sh = ShadePoint(rgb3, rgb4)
props = {'spec1': rgb, 'spec2': rgb2, 'sh': sh}
col_mgr = ColorManager(spectral=True)
col_mgr._nsamples = 32 #NOTE HACK - just for testing spectrum asm commands
bs = BasicShader(code, props, col_mgr=col_mgr)
runtime = Runtime()
bs.prepare([runtime])
#print (bs.shader._code)
bs.execute()
val1 = bs.shader.get_value('spec1')
val2 = bs.shader.get_value('sh.spectrum1')
for i in range(nsamples):
self.assertAlmostEqual(val1.samples[i], val2.samples[i], places=5)
val1 = bs.shader.get_value('spec2')
val2 = bs.shader.get_value('sh.spectrum2')
for i in range(nsamples):
self.assertAlmostEqual(val1.samples[i], val2.samples[i], places=5)
def intersect_ray_spheres_bool(n):
asm = util.get_asm()
mc = asm.assemble(ASM1)
runtime = Runtime()
#Sphere.intersectbool_asm(runtime, "ray_sphere_intersect")
Sphere.intersect_asm(runtime, "ray_sphere_intersect")
ds = runtime.load("test", mc)
for x in range(n):
sphere = generate_sphere()
ray = generate_ray()
ds["sph.origin"] = v4(sphere.origin)
ds["sph.radius"] = sphere.radius
ds["sph.mat_index"] = sphere.material
ds["r1.origin"] = v4(ray.origin)
ds["r1.dir"] = v4(ray.dir)
hp = sphere.intersect(ray, 999999.0)
runtime.run("test")
if hp is not False and ds["hit"] == 0:
print(hp.t, ds["t"], ds["hit"])
if hp is False and ds["hit"] == 1:
print(ds["t"], ds["hit"])
if hp is not False:
print_hitpoint(ds, hp)
def test_assign3(self):
code = """
spec1 = sh.spectrum1
sh.spectrum2 = spec2
"""
rgb = RGBSpectrum(0.2, 0.3, 0.2)
rgb2 = RGBSpectrum(0.1, 0.8, 0.9)
rgb3 = RGBSpectrum(0.5, 0.3, 0.1)
rgb4 = RGBSpectrum(0.1, 0.2, 0.2)
sh = ShadePoint(rgb3, rgb4)
props = {'spec1': rgb, 'spec2': rgb2, 'sh': sh}
col_mgr = ColorManager(spectral=False)
bs = BasicShader(code, props, col_mgr=col_mgr)
runtime = Runtime()
bs.prepare([runtime])
#print (bs.shader._code)
bs.execute()
val1 = bs.shader.get_value('spec1')
val2 = bs.shader.get_value('sh.spectrum1')
self.assertAlmostEqual(val1.r, val2.r, places=5)
self.assertAlmostEqual(val1.g, val2.g, places=5)
self.assertAlmostEqual(val1.b, val2.b, places=5)
val1 = bs.shader.get_value('spec2')
val2 = bs.shader.get_value('sh.spectrum2')
self.assertAlmostEqual(val1.r, val2.r, places=5)
self.assertAlmostEqual(val1.g, val2.g, places=5)
self.assertAlmostEqual(val1.b, val2.b, places=5)
