Пример #1
0
    def __init__(self, color_mgr=RGBManager()):
        # def __init__(self, color_mgr=SampledManager()):
        self._color_mgr = color_mgr
        register_prototypes(color_mgr.zero())

        self.sampler = RegularSampler(width=512,
                                      height=512,
                                      pixelsize=1.0,
                                      nthreads=1)
        self.camera = Camera(eye=Vector3(5.0, 5.0, 5.0),
                             lookat=Vector3(0.0, 0.0, 0.0),
                             distance=200)
        self.camera.load('pinhole')
        self.shapes = ShapeManager()
        self.intersector = LinearIsect(self.shapes)
        self.materials = MaterialManager()
        self.lights = LightManager()
        self.filter = SampleFilter()
        self.filter.load('box')
        self.integrator = Integrator()
        self.integrator.load('test', self._color_mgr)

        self.tone_mapping = Tmo()
        self.tone_mapping.load('exp')

        self._ready = False
        self._create_hdr_buffer()
Пример #2
0
    def test_isect_b_sph(self):
        sph_shader = Sphere.isect_b_shader('isect_b_sphere')
        sph_shader.compile()
        runtimes = [Runtime()]
        sph_shader.prepare(runtimes)

        code = """
min_dist = 99999.0
p1 = isect_b_sphere(ray, sphere, min_dist)
        """

        direction = Vector3(-1.0, -1.0, -1.0)
        direction.normalize()
        ray = Ray(Vector3(5.0, 5.0, 5.0), direction)
        sphere = Sphere(Vector3(0.0, 0.0, 0.0), 2.0, 0)

        r_arg = StructArg('ray', ray)
        sph_arg = StructArg('sphere', sphere)
        p1 = IntArg('p1', 6)

        args = [r_arg, sph_arg, p1]
        shader = Shader(code=code, args=args)
        shader.compile([sph_shader.shader])

        shader.prepare(runtimes)
        shader.execute()

        result = shader.get_value('p1')
        self.assertEqual(result, 1)
Пример #3
0
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
Пример #4
0
 def factory(cls, spectrum):
     wo = Vector3(0.0, 0.0, 0.0)
     wi = Vector3(0.0, 0.0, 0.0)
     li = spectrum.zero()
     lpos = Vector3(0.0, 0.0, 0.0)
     ref = spectrum.zero()
     lnormal = Vector3(0.0, 1.0, 0.0)
     em = spectrum.zero()
     return ShadePoint(wo, wi, li, lpos, ref, 1.0, lnormal, 1.0, em, 0)
Пример #5
0
def test_mesh(mesh, nrays=1):
    dep_shader = type(mesh).isect_shader('ray_flat_mesh_isect')
    dep_shader.compile()
    runtimes = [Runtime()]
    dep_shader.prepare(runtimes)

    code = """
min_dist = 99999.0
ret = ray_flat_mesh_isect(ray, mesh, hitpoint, min_dist)
    """

    ray = generate_ray(mesh)
    hitpoint = HitPoint(0.0, Vector3(0.0, 0.0, 0.0), Vector3(0.0, 0.0, 0.0), 6,
                        0.0, 0.0)

    r_arg = StructArg('ray', ray)
    mesh_arg = StructArg('mesh', mesh)
    harg = StructArg('hitpoint', hitpoint)
    ret = IntArg('ret', 6)

    args = [r_arg, mesh_arg, harg, ret]
    shader = Shader(code=code, args=args)
    shader.compile([dep_shader.shader])

    shader.prepare(runtimes)

    for i in range(nrays):
        ray = generate_ray(mesh)
        # origin = Vector3(-0.21099534597992897,-0.02090535280108452,-0.09716709856688976)
        # direction = Vector3(0.7856996643888073,0.4629769683728137,0.4102783983292736)
        # ray = Ray(origin, direction)
        shader.set_value('ray', ray)

        hp2 = mesh.isect(ray)
        hp, index = isect_ray_mesh(ray, mesh)
        shader.execute()

        # print(hp, shader.get_value('ret'))
        if hp:
            ret = shader.get_value('ret')
            hp_new = shader.get_value('hitpoint')
            if round(hp.t - hp_new.t, 5) != 0:
                print(hp.t, hp_new.t, ret, index, hp2.t)
                print(ray.origin)
                print(ray.direction)
                p0, p1, p2 = mesh.get_points(index)
                print(p0)
                print(p1)
                print(p2)
                print('------------------------------------------')
Пример #6
0
 def bbox(self):
     epsilon = 0.0001
     v0 = self.p0 
     v1 = self.p1
     v2 = self.p2
     minx = min(min(v0.x, v1.x), v2.x) - epsilon
     maxx = max(max(v0.x, v1.x), v2.x) + epsilon
     miny = min(min(v0.y, v1.y), v2.y) - epsilon
     maxy = max(max(v0.y, v1.y), v2.y) + epsilon
     minz = min(min(v0.z, v1.z), v2.z) - epsilon
     maxz = max(max(v0.z, v1.z), v2.z) + epsilon
     p0 = Vector3(minx, miny, minz)
     p1 = Vector3(maxx, maxy, maxz)
     return BBox(p0, p1)
Пример #7
0
    def bbox(self):

        epsilon = 0.001
        p0X = self.origin.x - self.radius - epsilon
        p0Y = self.origin.y - self.radius - epsilon
        p0Z = self.origin.z - self.radius - epsilon

        p1X = self.origin.x + self.radius + epsilon
        p1Y = self.origin.y + self.radius + epsilon
        p1Z = self.origin.z + self.radius + epsilon

        p0 = Vector3(p0X, p0Y, p0Z)
        p1 = Vector3(p1X, p1Y, p1Z)

        return BBox(p0, p1)
Пример #8
0
    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)
Пример #9
0
def _parse_camera(fobj, renderer):
    values = _extract_values(fobj)
    #NOTE keywords are expected to be in lower case!!! Improve this

    eye = values['eye']
    eye = Vector3(float(eye[0]), float(eye[1]), float(eye[2]))
    lookat = values['lookat']
    lookat = Vector3(float(lookat[0]), float(lookat[1]), float(lookat[2]))
    distance = float(values['distance'][0])

    camera = Camera(eye=eye, lookat=lookat, distance=distance)
    typ = values['type'][0].strip().lower()
    camera.load(typ)

    #TODO - shader public parameters
    renderer.camera = camera
Пример #10
0
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
Пример #11
0
    def test_isect_b_flat_triangle(self):
        runtimes = [Runtime()]

        tri_shader = FlatTriangle.isect_b_shader('isect_b_flat_triangle')
        tri_shader.compile()
        tri_shader.prepare(runtimes)

        p0 = Vector3(2.2, 4.4, 6.6)
        p1 = Vector3(1.1, 1.1, 1.1)
        p2 = Vector3(5.1, -1.1, 5.1)

        origin = Vector3(0.0, 0.0, 0.0)
        direction = Vector3(3, 3.0, 3.01)
        direction.normalize()
        ray = Ray(origin, direction)
        t = FlatTriangle(p0, p1, p2)

        code = """
min_dist = 150.0
ret = isect_b_flat_triangle(ray, triangle, min_dist)
        """

        r_arg = StructArg('ray', ray)
        tri_arg = StructArg('triangle', t)
        ret = IntArg('ret', 6)

        args = [r_arg, tri_arg, ret]
        shader = Shader(code=code, args=args)
        shader.compile([tri_shader.shader])
        shader.prepare(runtimes)

        shader.execute()

        min_dist = 150.0
        hit = t.isect_b(ray, min_dist)

        hit2 = shader.get_value('ret')
        if hit2 == 0:
            hit2 = False
        elif hit2 == 1:
            hit2 = True
        else:
            raise ValueError("Unexpected value for isect flat triangle ", hit2)

        self.assertEqual(hit, hit2)
Пример #12
0
    def test_isect_sph(self):
        sph_shader = Sphere.isect_shader('isect_sphere')
        sph_shader.compile()
        runtimes = [Runtime()]
        sph_shader.prepare(runtimes)

        code = """
min_dist = 99999.0
p1 = isect_sphere(ray, sphere, hitpoint, min_dist)
        """

        direction = Vector3(-1.0, -1.0, -1.0)
        direction.normalize()
        ray = Ray(Vector3(5.0, 5.0, 5.0), direction)
        sphere = Sphere(Vector3(0.0, 0.0, 0.0), 2.0, 0)
        hitpoint = HitPoint(0.0, Vector3(0.0, 0.0, 0.0),
                            Vector3(0.0, 0.0, 0.0), 6, 0.0, 0.0)

        r_arg = StructArg('ray', ray)
        sph_arg = StructArg('sphere', sphere)
        harg = StructArg('hitpoint', hitpoint)
        p1 = IntArg('p1', 6)

        args = [r_arg, sph_arg, harg, p1]
        shader = Shader(code=code, args=args)
        shader.compile([sph_shader.shader])

        shader.prepare(runtimes)
        shader.execute()

        hp2 = sphere.isect(ray)
        hitpoint = shader.get_value('hitpoint')
        self.assertAlmostEqual(hp2.t, hitpoint.t)
        self.assertEqual(hp2.mat_idx, hitpoint.mat_idx)
        n1 = hp2.normal
        n2 = hitpoint.normal
        self.assertAlmostEqual(n1.x, n2.x)
        self.assertAlmostEqual(n1.y, n2.y)
        self.assertAlmostEqual(n1.z, n2.z)
        self.assertAlmostEqual(hitpoint.hit.x, hp2.hit.x)
        self.assertAlmostEqual(hitpoint.hit.y, hp2.hit.y)
        self.assertAlmostEqual(hitpoint.hit.z, hp2.hit.z)

        result = shader.get_value('p1')
        self.assertEqual(result, 1)
Пример #13
0
    def bounding_sphere(self):
        if self._bbox is None:
            origin = Vector3(0.0, 0.0, 0.0)
            return Sphere(origin, radius=0.01, mat_idx=0)

        bbox = self._bbox
        dx = (bbox.x1 - bbox.x0)**2
        dy = (bbox.y1 - bbox.y0)**2
        dz = (bbox.z1 - bbox.z0)**2
        distance = math.sqrt(dx + dy + dz)
        radius = distance / 2.0

        ox = (bbox.x0 + bbox.x1) * 0.5
        oy = (bbox.y0 + bbox.y1) * 0.5
        oz = (bbox.z0 + bbox.z1) * 0.5
        origin = Vector3(ox, oy, oz)

        return Sphere(origin, radius=radius, mat_idx=0)
Пример #14
0
    def test_pinhole(self):
        cam = Camera(eye=Vector3(5.0, 5.0, 5.0),
                     lookat=Vector3(0.0, 0.0, 0.0),
                     distance=200)
        cam.load('pinhole')
        cam.prepare_standalone()

        sample = Sample(x=2.14, y=3.33, px=0.6, py=0.7, ix=2, iy=2, weight=1.0)
        r1 = cam.generate_ray(sample)
        r2 = self.generate_pinhole_ray(cam, sample)

        self.assertAlmostEqual(r1.origin.x, r2.origin.x)
        self.assertAlmostEqual(r1.origin.y, r2.origin.y)
        self.assertAlmostEqual(r1.origin.z, r2.origin.z)

        self.assertAlmostEqual(r1.direction.x, r2.direction.x)
        self.assertAlmostEqual(r1.direction.y, r2.direction.y)
        self.assertAlmostEqual(r1.direction.z, r2.direction.z)
Пример #15
0
    def bbox(self):
        epsilon = 0.001

        p = self.point
        ea = self.edge_a
        eb = self.edge_b

        p0X = min(p.x, p.x + ea.x, p.x + eb.x, p.x + ea.x + eb.x) - epsilon
        p1X = max(p.x, p.x + ea.x, p.x + eb.x, p.x + ea.x + eb.x) + epsilon
        p0Y = min(p.y, p.y + ea.y, p.y + eb.y, p.y + ea.y + eb.y) - epsilon
        p1Y = max(p.y, p.y + ea.y, p.y + eb.y, p.y + ea.y + eb.y) + epsilon
        p0Z = min(p.z, p.z + ea.z, p.z + eb.z, p.z + ea.z + eb.z) - epsilon
        p1Z = max(p.z, p.z + ea.z, p.z + eb.z, p.z + ea.z + eb.z) + epsilon

        p0 = Vector3(p0X, p0Y, p0Z)
        p1 = Vector3(p1X, p1Y, p1Z)

        return BBox(p0, p1)
Пример #16
0
    def generate_pinhole_ray(self, camera, sample):

        direction = camera._u * sample.x + camera._v *\
            sample.y - camera._w * camera._distance

        direction.normalize()
        eye = camera._eye
        origin = Vector3(eye.x, eye.y, eye.z)
        return Ray(origin, direction)
Пример #17
0
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)
Пример #18
0
    def test_linear(self):
        sphere = Sphere(Vector3(0.0, 0.0, 0.0), 2.0, 0)
        mgr = ShapeManager()
        mgr.add('sph1', sphere)
        sphere2 = Sphere(Vector3(0.0, 2.0, 0.0), 3.0, 0)
        mgr.add('sph2', sphere2)

        isector = LinearIsect(mgr)
        runtimes = [Runtime()]

        direction = Vector3(-1.0, -1.0, -1.0)
        direction.normalize()
        ray = Ray(Vector3(5.0, 5.0, 5.0), direction)

        isector.compile()
        isector.prepare(runtimes)

        code = """
min_dist = 99999.0
p1 = isect_scene(ray, hitpoint, min_dist)
        """
        direction = Vector3(-1.0, -1.0, -1.0)
        direction.normalize()
        ray = Ray(Vector3(5.0, 5.0, 5.0), direction)
        hitpoint = HitPoint(0.0, Vector3(0.0, 0.0, 0.0),
                            Vector3(0.0, 0.0, 0.0), 6, 0.0, 0.0)

        r_arg = StructArg('ray', ray)
        harg = StructArg('hitpoint', hitpoint)
        p1 = IntArg('p1', 6)

        args = [r_arg, harg, p1]
        shader = Shader(code=code, args=args)
        shader.compile([isector.shader])
        shader.prepare(runtimes)

        hp2 = isector.isect(ray)
        shader.execute()

        hitpoint = shader.get_value('hitpoint')

        self.assertAlmostEqual(hp2.t, hitpoint.t, places=5)
        self.assertEqual(hp2.mat_idx, hitpoint.mat_idx)
        n1 = hp2.normal
        n2 = hitpoint.normal
        self.assertAlmostEqual(n1.x, n2.x)
        self.assertAlmostEqual(n1.y, n2.y, places=6)
        self.assertAlmostEqual(n1.z, n2.z)
        self.assertAlmostEqual(hitpoint.hit.x, hp2.hit.x, places=6)
        self.assertAlmostEqual(hitpoint.hit.y, hp2.hit.y, places=6)
        self.assertAlmostEqual(hitpoint.hit.z, hp2.hit.z, places=6)

        result = shader.get_value('p1')
        self.assertEqual(result, 1)
Пример #19
0
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)
Пример #20
0
    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'))
Пример #21
0
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
Пример #22
0
    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))
Пример #23
0
    def __init__(self, eye, lookat, distance):
        self._eye = eye
        self._lookat = lookat
        self._up = Vector3(0.0, 1.0, 0.0)
        self._distance = float(distance)  # distance of image plane form eye
        self._compute_uvw()

        path = os.path.dirname(__file__)
        path = os.path.join(path, 'cam_shaders')
        self._loader = Loader([path])
        self._standalone = None
        self._shader_name = None
Пример #24
0
    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)
Пример #25
0
    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)
Пример #26
0
    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'))
Пример #27
0
    def isect_shader(self):
        origin = Vector3(0.0, 0.0, 0.0)
        direction = Vector3(0.0, 0.0, 0.0)
        ray = Ray(origin, direction)
        hitpoint = HitPoint(0.0, Vector3(0.0, 0.0, 0.0),
                            Vector3(0.0, 0.0, 0.0), 0, 0.0, 0.0)

        func_args = [StructArgPtr('ray', ray),
                     StructArgPtr('hitpoint', hitpoint),
                     FloatArg('min_dist', 99999.0)]

        args = []
        code = "hit_happend = 0\n"
        for shp_type in self.shp_mgr.shape_types():
            code1, args1 = self._get_shape_code(shp_type)
            args.extend(args1)
            code += code1
        code += "\nreturn hit_happend\n"

        shader = Shader(code=code, args=args, name='isect_scene',
                        func_args=func_args, is_func=True)
        return shader
Пример #28
0
def calculate_origin(mesh):
    bbox = mesh._grid.bbox

    wx = bbox.x1 - bbox.x0
    wy = bbox.y1 - bbox.y0
    wz = bbox.z1 - bbox.z0
    cx = (bbox.x1 + bbox.x0) / 2.0
    cy = (bbox.y1 + bbox.y0) / 2.0
    cz = (bbox.z1 + bbox.z0) / 2.0

    ox = cx - wx
    oy = cy - wy
    oz = cz - wz
    return Vector3(ox, oy, oz)
Пример #29
0
    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
Пример #30
0
def _value_factory(old_val, val, color_mgr, light=False):

    if isinstance(old_val, Vector3):
        return Vector3(float(val[0]), float(val[1]), float(val[2]))
    elif isinstance(old_val, RGBSpectrum):
        #TODO parsing of spectrum values from file
        return RGBSpectrum(float(val[0]), float(val[1]), float(val[2]))
    elif isinstance(old_val, SampledSpectrum):
        #TODO parsing of spectrum values from file
        s = RGBSpectrum(float(val[0]), float(val[1]), float(val[2]))
        return color_mgr.rgb_to_sampled(s, illum=light)
    elif isinstance(old_val, float):
        return float(val[0])
    else:
        raise ValueError("Unknown type ", old_val)
Пример #31
0
    def test_isect_flat_triangle1(self):
        runtimes = [Runtime()]

        tri_shader = FlatTriangle.isect_shader('isect_flat_triangle')
        tri_shader.compile()
        tri_shader.prepare(runtimes)

        p0 = Vector3(-0.0831229984, 0.0591476, -0.03213749)
        p1 = Vector3(-0.082775, 0.059025, -0.031787)
        p2 = Vector3(-0.0831229, 0.0591773, -0.031787)

        origin = Vector3(-0.21276909825205803, -0.021492251798510553,
                         -0.09822520208358765)
        direction = Vector3(0.7788769269741005, 0.4843782624535974,
                            0.3984073687694737)

        ray = Ray(origin, direction)
        hitpoint = HitPoint(0.0, Vector3(0.0, 0.0, 0.0),
                            Vector3(0.0, 0.0, 0.0), 6, 0.0, 0.0)

        t = FlatTriangle(p0, p1, p2)

        code = """
min_dist = 150.0
ret = isect_flat_triangle(ray, triangle, hitpoint, min_dist)
        """

        r_arg = StructArg('ray', ray)
        tri_arg = StructArg('triangle', t)
        harg = StructArg('hitpoint', hitpoint)
        ret = IntArg('ret', 6)

        args = [r_arg, tri_arg, harg, ret]
        shader = Shader(code=code, args=args)
        shader.compile([tri_shader.shader])
        shader.prepare(runtimes)

        shader.execute()

        min_dist = 150.0
        hit = t.isect(ray, min_dist)

        hp = shader.get_value('hitpoint')

        self.assertAlmostEqual(hit.t, hp.t, places=6)
        self._almost_equal_vec3(hit.hit, hp.hit, places=6)
        self._almost_equal_vec3(hit.normal, hp.normal, places=6)
        self.assertEqual(hit.mat_idx, hp.mat_idx)
        self.assertAlmostEqual(hit.u, hp.u)
        self.assertAlmostEqual(hit.v, hp.v)
Пример #32
0
    def test_isect_flat_triangle(self):
        runtimes = [Runtime()]

        tri_shader = FlatTriangle.isect_shader('isect_flat_triangle')
        tri_shader.compile()
        tri_shader.prepare(runtimes)

        p0 = Vector3(2.2, 4.4, 6.6)
        p1 = Vector3(1.1, 1.1, 1.1)
        p2 = Vector3(5.1, -1.1, 5.1)

        origin = Vector3(0.0, 0.0, 0.0)
        direction = Vector3(3, 3.0, 3.01)
        direction.normalize()
        ray = Ray(origin, direction)
        hitpoint = HitPoint(0.0, Vector3(0.0, 0.0, 0.0),
                            Vector3(0.0, 0.0, 0.0), 6, 0.0, 0.0)

        t = FlatTriangle(p0, p1, p2)

        code = """
min_dist = 150.0
ret = isect_flat_triangle(ray, triangle, hitpoint, min_dist)
        """

        r_arg = StructArg('ray', ray)
        tri_arg = StructArg('triangle', t)
        harg = StructArg('hitpoint', hitpoint)
        ret = IntArg('ret', 6)

        args = [r_arg, tri_arg, harg, ret]
        shader = Shader(code=code, args=args)
        shader.compile([tri_shader.shader])
        shader.prepare(runtimes)

        shader.execute()

        min_dist = 150.0
        hit = t.isect(ray, min_dist)

        hp = shader.get_value('hitpoint')

        self.assertAlmostEqual(hit.t, hp.t, places=6)
        self._almost_equal_vec3(hit.hit, hp.hit, places=6)
        self._almost_equal_vec3(hit.normal, hp.normal, places=6)
        self.assertEqual(hit.mat_idx, hp.mat_idx)
        self.assertAlmostEqual(hit.u, hp.u)
        self.assertAlmostEqual(hit.v, hp.v)
Пример #33
0
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