Example #1
0
    def test_arith2(self):
        code = """
spec3 = spec1 + spec2
spec4 = spec1 * 0.3
spec5 = 2 * spec2
        """

        nsamples = 32
        rgb = SampledSpectrum([0.1]*nsamples)
        rgb2 = SampledSpectrum([0.2]*nsamples)
        rgb3 = SampledSpectrum([0.3]*nsamples)
        rgb4 = SampledSpectrum([0.4]*nsamples)
        rgb5 = SampledSpectrum([0.5]*nsamples)

        props = {'spec1':rgb, 'spec2':rgb2, 'spec3':rgb3, 'spec4':rgb4, 'spec5':rgb5}
        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()

        val = bs.shader.get_value('spec3')
        for i in range(nsamples):
            self.assertAlmostEqual(val.samples[i], rgb.samples[i] + rgb2.samples[i], places=5)
        val = bs.shader.get_value('spec4')
        for i in range(nsamples):
            self.assertAlmostEqual(val.samples[i], rgb.samples[i] * 0.3, places=5)
        val = bs.shader.get_value('spec5')
        for i in range(nsamples):
            self.assertAlmostEqual(val.samples[i], rgb2.samples[i] * 2, places=5)
Example #2
0
    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)
Example #3
0
    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)
Example #4
0
    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())
Example #5
0
    def test_Y_rgb(self):
        mgr = ColorManager(False)
        runtime = Runtime()

        mgr.Y_asm([runtime], 'luminance')
        spec1 = mgr.create_spectrum((0.66,0.88, 0.11))

        mc = create_assembler().assemble(self.asm_code1(mgr))
        ds = runtime.load("test", mc)
        ds["sp1.values"] = spec1.to_ds()
        runtime.run("test")
        
        self.assertAlmostEqual(mgr.Y(spec1), ds["Y"], 4)
Example #6
0
    def test_Y_rgb(self):
        mgr = ColorManager(False)
        runtime = Runtime()

        mgr.Y_asm([runtime], 'luminance')
        spec1 = mgr.create_spectrum((0.66, 0.88, 0.11))

        mc = create_assembler().assemble(self.asm_code1(mgr))
        ds = runtime.load("test", mc)
        ds["sp1.values"] = spec1.to_ds()
        runtime.run("test")

        self.assertAlmostEqual(mgr.Y(spec1), ds["Y"], 4)
    def test_chromacity_to_spectrum2(self):
        mgr = ColorManager(spectral=True)
        runtime = Runtime()

        mgr.chromacity_to_spectrum_asm([runtime], 'chromacity_to_spectrum')
        mc = create_assembler().assemble(self.asm_code1(mgr))
        ds = runtime.load("test", mc)
        ds['x'] = 0.45
        ds['y'] = 0.41

        spec = mgr.chromacity_to_spectrum(0.45, 0.41)
        runtime.run("test")

        vals = ds['sp1.values']
        for i in range(len(vals)):
            self.assertAlmostEqual(vals[i], spec.samples[i], 4)
Example #8
0
    def test_Y(self):
        mgr = ColorManager(False)
        runtime = Runtime()

        mgr.XYZ_to_RGB_asm([runtime], 'XYZ_to_RGB')
        mc = create_assembler().assemble(self.asm_code1())
        ds = runtime.load("test", mc)

        ds["XYZ"] = (0.69, 0.78, 0.88, 0.00)
        runtime.run("test")
        ret1 = ds["RGB"]
        ret2 = mgr.XYZ_to_RGB(0.69, 0.78, 0.88)

        self.assertAlmostEqual(ret1[0], ret2[0], 4)
        self.assertAlmostEqual(ret1[1], ret2[1], 4)
        self.assertAlmostEqual(ret1[2], ret2[2], 4)
Example #9
0
    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)
Example #10
0
    def test_arith1(self):

        code = """
spec3 = spec1 + spec2
spec4 = spec1 * 4
spec5 = 8 * spec2
        """
        rgb = RGBSpectrum(0.2, 0.3, 0.2)
        rgb2 = RGBSpectrum(0.1, 0.2, 0.3)
        rgb3 = RGBSpectrum(0.0, 0.0, 0.0)
        rgb4 = RGBSpectrum(0.0, 0.0, 0.0)
        rgb5 = RGBSpectrum(0.0, 0.0, 0.0)
        props = {'spec1':rgb, 'spec2':rgb2, 'spec3':rgb3, 'spec4':rgb4,
                'spec5':rgb5}
        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('spec3')
        self.assertAlmostEqual(val1.r, 0.2+0.1, places=5)
        self.assertAlmostEqual(val1.g, 0.3+0.2, places=5)
        self.assertAlmostEqual(val1.b, 0.2+0.3, places=5)
        val1 = bs.shader.get_value('spec4')
        self.assertAlmostEqual(val1.r, 0.2*4, places=5)
        self.assertAlmostEqual(val1.g, 0.3*4, places=5)
        self.assertAlmostEqual(val1.b, 0.2*4, places=5)
        val1 = bs.shader.get_value('spec5')
        self.assertAlmostEqual(val1.r, 0.1*8, places=5)
        self.assertAlmostEqual(val1.g, 0.2*8, places=5)
        self.assertAlmostEqual(val1.b, 0.3*8, places=5)
Example #11
0
    def test_spectrum_to_rgb2(self):
        mgr = ColorManager(spectral=True)
        runtime = Runtime()

        mgr.rgb_to_sampled_asm([runtime], 'rgb_to_spectrum')
        spec1 = mgr.create_spectrum((0.66,0.88, 0.11))

        mc = create_assembler().assemble(self.asm_code1(mgr))
        ds = runtime.load("test", mc)

        ds["rgb"] = (0.66, 0.88, 0.11, 0.00)
        runtime.run("test")
        
        vals = ds['sp1.values']
        
        for i in range(len(vals)):
            self.assertAlmostEqual(vals[i], spec1.samples[i], 4)
Example #12
0
    def test_lum2(self):

        code = """
ret = luminance(spec1)
        """
        rgb = RGBSpectrum(0.2, 0.3, 0.2)
        props = {'spec1': rgb, 'ret': 0.0}
        col_mgr = ColorManager(spectral=False)
        bs = BasicShader(code, props, col_mgr=col_mgr)
        runtime = Runtime()
        bs.prepare([runtime])
        #print (bs.shader._code)

        bs.execute()
        lum1 = col_mgr.Y(rgb)
        lum2 = bs.shader.get_value('ret')
        self.assertAlmostEqual(lum1, lum2, places=5)
Example #13
0
    def test_chromacity_to_spectrum(self):
        mgr = ColorManager(spectral=False)
        runtime = Runtime()

        mgr.chromacity_to_spectrum_asm([runtime], 'chromacity_to_spectrum')
        mc = create_assembler().assemble(self.asm_code1(mgr))
        ds = runtime.load("test", mc)
        ds['x'] = 0.45
        ds['y'] = 0.41

        spec = mgr.chromacity_to_spectrum(0.45, 0.41)

        runtime.run("test")
        rgb = ds['sp1.values']

        self.assertAlmostEqual(spec.r, rgb[0], 4)
        self.assertAlmostEqual(spec.g, rgb[1], 4)
        self.assertAlmostEqual(spec.b, rgb[2], 4)
Example #14
0
    def test_lum3(self):

        code = """
ret = luminance(spec1)
        """
        col_mgr = ColorManager(spectral=True)
        rgb = col_mgr.create_spectrum((0.2, 0.3, 0.2))
        props = {'spec1':rgb, 'ret':0.0}

        bs = BasicShader(code, props, col_mgr=col_mgr)
        runtime = Runtime()
        bs.prepare([runtime])
        #print (bs.shader._code)

        bs.execute()
        lum1 = col_mgr.Y(rgb)
        lum2 = bs.shader.get_value('ret')
        self.assertAlmostEqual(lum1, lum2, places=5)
Example #15
0
    def test_spec2(self):

        code = """
spec = spectrum(0.2)
        """
        col_mgr = ColorManager(spectral=True)
        rgb = col_mgr.create_spectrum((0.2, 0.3, 0.2))
        props = {'spec': rgb}
        bs = BasicShader(code, props, col_mgr=col_mgr)
        runtime = Runtime()
        bs.prepare([runtime])
        #print (bs.shader._code)

        bs.execute()
        val = bs.shader.get_value('spec')
        nsamples = col_mgr.nsamples
        for i in range(nsamples):
            self.assertAlmostEqual(val.samples[i], 0.2, places=5)
Example #16
0
    def test_spectrum_to_rgb2(self):
        mgr = ColorManager()
        runtime = Runtime()

        mgr.to_RGB_asm([runtime], 'spectrum_to_rgb')
        spec1 = mgr.create_spectrum((0.66,0.88, 0.11))

        mc = create_assembler().assemble(self.asm_code1(mgr))
        ds = runtime.load("test", mc)
        ds["sp1.values"] = spec1.to_ds()
        runtime.run("test")
        
        rgb = mgr.to_RGB(spec1)
        rgb2 = ds['rgb']

        self.assertAlmostEqual(rgb.r, rgb2[0], 4)
        self.assertAlmostEqual(rgb.g, rgb2[1], 4)
        self.assertAlmostEqual(rgb.b, rgb2[2], 4)
Example #17
0
    def test_spectrum_to_rgb1(self):
        mgr = ColorManager(False)
        runtime = Runtime()

        mgr.rgb_to_sampled_asm([runtime], 'rgb_to_spectrum')
        spec1 = mgr.create_spectrum((0.66,0.88, 0.11))

        mc = create_assembler().assemble(self.asm_code1(mgr))
        ds = runtime.load("test", mc)

        ds["rgb"] = spec1.to_ds()

        runtime.run("test")

        rgb = ds["sp1.values"]

        self.assertAlmostEqual(spec1.r, rgb[0], 4)
        self.assertAlmostEqual(spec1.g, rgb[1], 4)
        self.assertAlmostEqual(spec1.b, rgb[2], 4)
Example #18
0
    def test_chromacity_to_spec(self):

        code = """
spec1 = chromacity_to_spectrum(0.41, 0.45)

        """
        col_mgr = ColorManager(spectral=True)
        rgb = col_mgr.black()
        props = {'spec1': rgb}
        bs = BasicShader(code, props, col_mgr=col_mgr)

        runtime = Runtime()
        bs.prepare([runtime])
        #print (bs.shader._code)

        bs.execute()
        spec2 = col_mgr.chromacity_to_spectrum(0.41, 0.45)

        val = bs.shader.get_value('spec1')
        for i in range(len(val.samples)):
            self.assertAlmostEqual(val.samples[i], spec2.samples[i], places=4)
Example #19
0
    def test_chromacity_to_spec(self):

        code = """
spec1 = chromacity_to_spectrum(0.41, 0.45)

        """
        col_mgr = ColorManager(spectral=True)
        rgb = col_mgr.black()
        props = {"spec1": rgb}
        bs = BasicShader(code, props, col_mgr=col_mgr)

        runtime = Runtime()
        bs.prepare([runtime])
        # print (bs.shader._code)

        bs.execute()
        spec2 = col_mgr.chromacity_to_spectrum(0.41, 0.45)

        val = bs.shader.get_value("spec1")
        for i in range(len(val.samples)):
            self.assertAlmostEqual(val.samples[i], spec2.samples[i], places=4)
Example #20
0
    def test_rgb_to_spec2(self):

        code = """
spec1 = rgb_to_spectrum(vec)

        """
        vec = Vector3(0.2, 0.3, 0.2)
        col_mgr = ColorManager(spectral=True)
        rgb = col_mgr.black()
        props = {'spec1': rgb, 'vec': vec}
        bs = BasicShader(code, props, col_mgr=col_mgr)

        runtime = Runtime()
        bs.prepare([runtime])
        #print (bs.shader._code)

        bs.execute()

        val = bs.shader.get_value('spec1')
        val2 = col_mgr.create_spectrum((0.2, 0.3, 0.2), illum=False)
        for i in range(len(val2.samples)):
            self.assertAlmostEqual(val.samples[i], val2.samples[i], places=5)
Example #21
0
    def test_sampled_spec_to_rgb(self):

        code = """
vec = spectrum_to_rgb(spec1)
        """
        col_mgr = ColorManager(spectral=True)
        rgb = col_mgr.create_spectrum((0.2, 0.3, 0.2))

        vec = Vector3(0.0, 0.0, 0.0)
        props = {'spec1': rgb, 'vec': vec}
        bs = BasicShader(code, props, col_mgr=col_mgr)
        runtime = Runtime()
        bs.prepare([runtime])
        #print (bs.shader._code)

        bs.execute()

        val = bs.shader.get_value('vec')
        val2 = col_mgr.to_RGB(rgb)
        self.assertAlmostEqual(val.x, val2.r, places=5)
        self.assertAlmostEqual(val.y, val2.g, places=5)
        self.assertAlmostEqual(val.z, val2.b, places=5)
Example #22
0
    def test_sampled_spec_to_rgb(self):

        code = """
vec = spectrum_to_rgb(spec1)
        """
        col_mgr = ColorManager(spectral=True)
        rgb = col_mgr.create_spectrum((0.2, 0.3, 0.2))

        vec = Vector3(0.0, 0.0, 0.0)
        props = {'spec1':rgb, 'vec':vec}
        bs = BasicShader(code, props, col_mgr=col_mgr)
        runtime = Runtime()
        bs.prepare([runtime])
        #print (bs.shader._code)

        bs.execute()

        val = bs.shader.get_value('vec')
        val2 = col_mgr.to_RGB(rgb)
        self.assertAlmostEqual(val.x, val2.r, places=5)
        self.assertAlmostEqual(val.y, val2.g, places=5)
        self.assertAlmostEqual(val.z, val2.b, places=5)
Example #23
0
    def test_chromacity_to_rgb(self):

        code = """
spec1 = chromacity_to_spectrum(0.41, 0.45)

        """
        rgb = RGBSpectrum(0.0, 0.0, 0.0)
        props = {"spec1": rgb}
        col_mgr = ColorManager(spectral=False)
        bs = BasicShader(code, props, col_mgr=col_mgr)

        runtime = Runtime()
        bs.prepare([runtime])
        # print (bs.shader._code)

        bs.execute()
        spec2 = col_mgr.chromacity_to_spectrum(0.41, 0.45)

        val = bs.shader.get_value("spec1")
        self.assertAlmostEqual(spec2.r, val.r, places=4)
        self.assertAlmostEqual(spec2.g, val.g, places=4)
        self.assertAlmostEqual(spec2.b, val.b, places=4)
Example #24
0
    def test_rgb_to_spec2(self):

        code = """
spec1 = rgb_to_spectrum(vec)

        """
        vec = Vector3(0.2, 0.3, 0.2)
        col_mgr = ColorManager(spectral=True)
        rgb = col_mgr.black()
        props = {'spec1':rgb, 'vec':vec}
        bs = BasicShader(code, props, col_mgr=col_mgr)

        runtime = Runtime()
        bs.prepare([runtime])
        #print (bs.shader._code)

        bs.execute()

        val = bs.shader.get_value('spec1')
        val2 = col_mgr.create_spectrum((0.2, 0.3, 0.2), illum=False)
        for i in range(len(val2.samples)):
            self.assertAlmostEqual(val.samples[i], val2.samples[i], places=5)
Example #25
0
    def test_chromacity_to_rgb(self):

        code = """
spec1 = chromacity_to_spectrum(0.41, 0.45)

        """
        rgb = RGBSpectrum(0.0, 0.0, 0.0)
        props = {'spec1': rgb}
        col_mgr = ColorManager(spectral=False)
        bs = BasicShader(code, props, col_mgr=col_mgr)

        runtime = Runtime()
        bs.prepare([runtime])
        #print (bs.shader._code)

        bs.execute()
        spec2 = col_mgr.chromacity_to_spectrum(0.41, 0.45)

        val = bs.shader.get_value('spec1')
        self.assertAlmostEqual(spec2.r, val.r, places=4)
        self.assertAlmostEqual(spec2.g, val.g, places=4)
        self.assertAlmostEqual(spec2.b, val.b, places=4)
Example #26
0
    def test_assign2(self):

        code = """
p = spec1
spec2 = p

        """
        nsamples = 32
        rgb = SampledSpectrum([0.1] * nsamples)
        rgb2 = SampledSpectrum([0.2] * nsamples)
        col_mgr = ColorManager(spectral=True)
        col_mgr._nsamples = 32  #NOTE HACK - just for testing spectrum asm commands

        props = {'spec1': rgb, 'spec2': rgb2}
        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('spec2')
        for i in range(nsamples):
            self.assertAlmostEqual(val1.samples[i], val2.samples[i], places=5)
Example #27
0
    def test_spec1(self):

        code = """
spec = spectrum(0.1)
        """
        rgb = RGBSpectrum(0.0, 0.0, 0.0)
        props = {'spec': rgb}
        col_mgr = ColorManager(spectral=False)
        bs = BasicShader(code, props, col_mgr=col_mgr)
        runtime = Runtime()
        bs.prepare([runtime])
        #print (bs.shader._code)

        bs.execute()

        val = bs.shader.get_value('spec')
        self.assertAlmostEqual(val.r, 0.1, 4)
        self.assertAlmostEqual(val.g, 0.1, 4)
        self.assertAlmostEqual(val.b, 0.1, 4)
Example #28
0
    def test_assign1(self):

        code = """
p = spec1
spec2 = p

        """
        rgb = RGBSpectrum(0.2, 0.3, 0.2)
        rgb2 = RGBSpectrum(0.1, 0.8, 0.9)
        props = {'spec1': rgb, 'spec2': rgb2}
        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('spec2')
        self.assertAlmostEqual(val1.r, val2.r, places=5)
        self.assertAlmostEqual(val1.g, val2.g, places=5)
        self.assertAlmostEqual(val1.b, val2.b, places=5)
Example #29
0
    def test_rgb_to_spec(self):

        code = """
spec1 = rgb_to_spectrum(vec)

        """
        rgb = RGBSpectrum(0.0, 0.0, 0.0)
        vec = Vector3(0.2, 0.3, 0.2)
        props = {'spec1': rgb, 'vec': vec}
        col_mgr = ColorManager(spectral=False)
        bs = BasicShader(code, props, col_mgr=col_mgr)

        runtime = Runtime()
        bs.prepare([runtime])
        #print (bs.shader._code)

        bs.execute()

        val = bs.shader.get_value('spec1')
        self.assertAlmostEqual(vec.x, val.r, places=5)
        self.assertAlmostEqual(vec.y, val.g, places=5)
        self.assertAlmostEqual(vec.z, val.b, places=5)
Example #30
0
    def test_spectrum_to_rgb2(self):
        mgr = ColorManager()
        runtime = Runtime()

        mgr.to_RGB_asm([runtime], 'spectrum_to_rgb')
        spec1 = mgr.create_spectrum((0.66, 0.88, 0.11))

        mc = create_assembler().assemble(self.asm_code1(mgr))
        ds = runtime.load("test", mc)
        ds["sp1.values"] = spec1.to_ds()
        runtime.run("test")

        rgb = mgr.to_RGB(spec1)
        rgb2 = ds['rgb']

        self.assertAlmostEqual(rgb.r, rgb2[0], 4)
        self.assertAlmostEqual(rgb.g, rgb2[1], 4)
        self.assertAlmostEqual(rgb.b, rgb2[2], 4)
Example #31
0
import time
from renmas3.base import ColorManager

start = time.clock()
mgr = ColorManager()
end = time.clock()
print(end-start)
print(mgr.create_spectrum((0.2, 0.3, 0.4)))

print(mgr.wavelengths())
print(len(mgr.wavelengths()))
print(mgr.wavelength_intervals())
print(len(mgr.wavelength_intervals()))

Example #32
0
from tdasm import Runtime
from renmas3.base import ColorManager
from renmas3.renderer import LightManager
from renmas3.renderer import SunSky
from renmas3.base import BasicShader, Vector3

col_mgr = ColorManager(spectral=False)
lgt_mgr = LightManager()

sun_sky = SunSky(col_mgr)

lgt_mgr.add("sunce", sun_sky)
runtimes = [Runtime()]
shader = lgt_mgr.prepare_illuminate("light_radiance", runtimes)

# light_radiance(hitpoint, shadepoint, 0)

code = """

hitpoint = Hitpoint()
shadepoint = Shadepoint()
shadepoint.wo = float3(-0.2, 0.3, 0.5)

light_radiance(hitpoint, shadepoint, 0)
spec = shadepoint.light_intensity
ret = hitpoint.t

"""
spec = col_mgr.create_spectrum((0.3, 0.2, 0.8))
props = {"spec": spec, "ret": 0.0}
bs = BasicShader(code=code, props=props, col_mgr=col_mgr)
Example #33
0
import time
from renmas3.base import ColorManager

start = time.clock()
mgr = ColorManager()
end = time.clock()
print(end - start)
print(mgr.create_spectrum((0.2, 0.3, 0.4)))

print(mgr.wavelengths())
print(len(mgr.wavelengths()))
print(mgr.wavelength_intervals())
print(len(mgr.wavelength_intervals()))
Example #34
0
from tdasm import Runtime
from renmas3.base import ColorManager
from renmas3.renderer import LightManager
from renmas3.renderer import SunSky
from renmas3.base import BasicShader, Vector3

col_mgr = ColorManager(spectral=False)
lgt_mgr = LightManager()

sun_sky = SunSky(col_mgr)

lgt_mgr.add('sunce', sun_sky)
runtimes = [Runtime()]
shader = lgt_mgr.prepare_illuminate('light_radiance', runtimes)

#light_radiance(hitpoint, shadepoint, 0)

code = """

hitpoint = Hitpoint()
shadepoint = Shadepoint()
shadepoint.wo = float3(-0.2, 0.3, 0.5)

light_radiance(hitpoint, shadepoint, 0)
spec = shadepoint.light_intensity
ret = hitpoint.t

"""
spec = col_mgr.create_spectrum((0.3, 0.2, 0.8))
props = {'spec': spec, 'ret': 0.0}
bs = BasicShader(code=code, props=props, col_mgr=col_mgr)