Python toMap示例

示例#1

directory = args[0]

dataset = Dataset(directory)
testset = dataset.testSet()

if options.directOnly:
    idirpath = directory + "/renders/direct-targets"
else:
    idirpath = directory + "/renders/indirect-targets"

if not os.path.exists(idirpath):
    os.mkdir(idirpath)

meshfile = testset.targetMeshPath
paramlist = testset.parameterList()
bsdf = toMap(paramlist, testset.targetBSDF())

for k in range(dataset.testSet().numLights()):
    print "Light ", k, "/", dataset.testSet().numLights(), "\r",
    sys.stdout.flush()

    testset.renderables[k].setEmbeddedParameter("sampleCount", options.directSamples)
    testset.renderables[k].setParameter("blockSize", 8)
    copyfile(meshfile,
                        "/tmp/mts_mesh_intensity_slot_" + format(k) + ".ply")
    merl_io.merl_write("/tmp/tabular-bsdf-" + format(k) + ".binary", testset.targetTabularBSDF())

    testset.renderables[k].setEmbeddedParameter("depth", 2)
    testset.renderables[k].setEmbeddedParameter("meshSlot", k)

    directIntensity = testset.renderables[k].renderReadback(

示例#2

文件： render-bsdf-sphere.py 项目： cmu-ci-lab/multibounce_reflectometry

renderable = testset.renderables[0]
renderable.setFile(sphereXMLP)
renderable.setEmbeddedParameter("envmap", "doge.exr")

if options.distribution is not None:
    localThreads = 2
else:
    localThreads = 8

sphereImage = renderable.renderReadback(
    readmode="hds",
    distribution=options.distribution,
    output="/tmp/sphere-bsdf-testing.hds",
    embedded=mergeMaps({"sampleCount": options.sampleCount},
                       toMap(testset.parameterList(), targetBSDF)),
    localThreads=localThreads,
    quiet=False)

print(testset.targetBSDF())
sphereImageTarget = renderable.renderReadback(
    readmode="hds",
    distribution=options.distribution,
    output="/tmp/sphere-bsdf-testing.hds",
    embedded=mergeMaps({"sampleCount": options.sampleCount},
                       toMap(testset.parameterList(), testset.targetBSDF())),
    localThreads=localThreads,
    quiet=False)

fullImage = np.concatenate([sphereImage, sphereImageTarget], axis=1)
print(fullImage.shape)

示例#3

        os.mkdir(gsubdir)

    if options.superiteration >= 1:
        meshfile = dataset.meshfileAt(iteration=0,
                                      superiteration=options.superiteration -
                                      1)
    else:
        meshfile = dataset.testset.initialMeshPath()

    if meshfile is None:
        print("Couldn't find mesh for ", options.superiteration, "-", i)
        break

    paramlist = testset.parameterList()
    bsdf = toMap(
        paramlist,
        dataset.BSDFAt(iteration=i, superiteration=options.superiteration))
    if options.adaptiveMode is None:
        bsdfSamples = toMap(
            dataset.bsdfAdaptiveSamplingParameterList,
            dataset.BSDFAt(iteration=i, superiteration=options.superiteration))
    elif options.adaptiveMode == "invAlpha":
        epsilon = 1e-3
        wts = []
        for element in testset.bsdfDictionaryElements:
            if element["type"] == "roughconductor":
                wts.append(1 / (element["alpha"] + epsilon))
            elif element["type"] == "diffuse":
                wts.append(1.0)
            else:
                wts.append(1.0)

示例#4

文件： render-indirect-current.py 项目： cmu-ci-lab/multibounce_reflectometry

        continue

    if dataset.meshfileAt(iteration=ii, superiteration=options.superiteration
                          ) is None and dataset.testSet().numIterations() != 0:
        print("Couldn't find ", options.superiteration, "-", i)
        break

    if dataset.testSet().numIterations() == 0:
        meshfile = dataset.testSet().initialMeshPath()
    else:
        meshfile = dataset.meshfileAt(iteration=ii,
                                      superiteration=options.superiteration)

    paramlist = testset.parameterList()
    bsdf = toMap(
        paramlist,
        dataset.BSDFAt(iteration=bi, superiteration=options.superiteration))

    for k in range(dataset.testSet().numLights()):
        print "Iteration ", i, "/", testset.numIterations(
        ), ", Light ", k, "/", dataset.testSet().numLights(), "\r",
        sys.stdout.flush()

        testset.renderables[k].setEmbeddedParameter("sampleCount",
                                                    options.directSamples)
        testset.renderables[k].setParameter("blockSize", 8)
        copyfile(meshfile,
                 "/tmp/mts_mesh_intensity_slot_" + format(k) + ".ply")
        merl_io.merl_write(
            "/tmp/tabular-bsdf-" + format(k) + ".binary",
            dataset.tabularBSDFAt(iteration=bi,

示例#5

文件： patch-error-plot.py 项目： cmu-ci-lab/multibounce_reflectometry

parser.add_option("-c", "--distribution", dest="distribution", default=None, type="string")
parser.add_option("-s", "--samples", dest="samples", default=4, type="int")
parser.add_option("-r", "--resolution", dest="resolution", default=10, type="int")
parser.add_option("-x", "--nx", dest="nx", default=0.0, type="float")
parser.add_option("-y", "--ny", dest="ny", default=0.0, type="float")
parser.add_option("-z", "--nz", dest="nz", default=1.0, type="float")

(options, args) = parser.parse_args()

directory = args[0]

testset = Testset(directory)

paramlist = testset.parameterList()
adaptiveList = testset.bsdfAdaptiveSamplingParameterList
bsdf = toMap(paramlist, testset.targetBSDF())
adaptiveDistr = toMap(adaptiveList, testset.targetBSDF())
bsdf = mergeMaps(bsdf, adaptiveDistr)

numVertices = load_normals.load_normals(testset.initialMeshPath()).shape[0]


targets = []
for k in range(testset.numLights()):
    print "Light ", k, "/", testset.numLights(), "\r",
    sys.stdout.flush()

    testset.gradientRenderables[k].setEmbeddedParameter("sampleCount", options.samples)
    testset.gradientRenderables[k].setParameter("blockSize", 8)
    testset.renderables[k].setEmbeddedParameter("sampleCount", options.samples)
    testset.renderables[k].setParameter("blockSize", 8)