def render(argv):
# Set the desired mitsuba variant
filename = 'scene.xml'
# Add the scene directory to the FileResolver's search path
Thread.thread().file_resolver().append(os.path.dirname(filename))
# Load the actual scene
scene = load_file(filename, pos_x = argv[0], pos_y = argv[1], pos_z = argv[2])
# Call the scene's integrator to render the loaded scene
scene.integrator().render(scene, scene.sensors()[0])
# After rendering, the rendered data is stored in the film
film = scene.sensors()[0].film()
# Write out rendering as high dynamic range OpenEXR file
film.set_destination_file('output.exr')
film.develop()
# Write out a tonemapped JPG of the same rendering
bmp = film.bitmap(raw=True)
bmp.convert(Bitmap.PixelFormat.RGB, Struct.Type.UInt8, srgb_gamma=True).write('output_{}.jpg'.format(argv[3]))
# Get linear pixel values as a numpy array for further processing
bmp_linear_rgb = bmp.convert(Bitmap.PixelFormat.RGB, Struct.Type.Float32, srgb_gamma=False)
image_np = np.array(bmp_linear_rgb)
def getCameraAltitudeHeight(self, main_scene_xml_file_prifix, pos_x,
pos_z):
currdir = os.path.split(os.path.realpath(__file__))[0]
sys.path.append(currdir + '/bin/rt/' + current_rt_program +
'/python/2.7/')
os.environ[
'PATH'] = currdir + '/bin/rt/' + current_rt_program + os.pathsep + os.environ[
'PATH']
import mitsuba
from mitsuba.core import Vector, Point, Ray, Thread
from mitsuba.render import SceneHandler
import platform
scenepath = session.get_scenefile_path()
fileResolver = Thread.getThread().getFileResolver()
logger = Thread.getThread().getLogger()
logger.clearAppenders()
scenepath = scenepath.encode('utf-8')
fileResolver.appendPath(scenepath)
filepath = os.path.join(session.get_scenefile_path(),
main_scene_xml_file_prifix +
terr_scene_file).encode("utf-8")
scene = SceneHandler.loadScene(fileResolver.resolve(filepath))
scene.configure()
scene.initialize()
ray = Ray()
ray.setOrigin(Point(pos_x, 999999999, pos_z))
ray.setDirection(Vector(0, -1, 0))
its = scene.rayIntersect(ray)
if not its is None:
return its.p[1]
else:
print("Camera is outside of the scene, do not use relative height")
return 0
def compute_sh(obj_file, cam_pos, cam_lookat):
light_radiance = 1.0
register_integrator('auxintegrator', lambda props: AuxIntegrator(props))
scene_template_file = './scene_template.xml'
Thread.thread().file_resolver().append(
os.path.dirname(scene_template_file))
scene = load_file(scene_template_file, integrator='auxintegrator', fov="40", tx=cam_lookat[0], ty=cam_lookat[1], tz=cam_lookat[2], \
spp="100", width=200, height=200, obj_file=obj_file)
# scene.integrator().light = load_string(LIGHT_TEMPLATE, lsx="1", lsy="1", lsz="1", lrx="0", lry="0", lrz="0", ltx="-1", lty="0", ltz="0", l=light_radiance)
# scene.integrator().light_radiance = light_radiance
scene.integrator().render(scene, scene.sensors()[0])
film = scene.sensors()[0].film()
film.set_destination_file('./render_output.exr')
film.develop()
sh_channels_list = []
for i in range(0, 9):
for c in ['r', 'g', 'b']:
sh_channels_list.append('sh_%s_%d' % (c, i))
f_sh = np.zeros((200, 200, 27), dtype=np.float)
exrfile = pyexr.open('render_output.exr')
for i, channel in enumerate(sh_channels_list):
ch = exrfile.get(channel)
f_sh[:, :, i:i + 1] += ch
return f_sh
def test22_fileresolver_unchanged(variant_scalar_rgb):
from mitsuba.core import xml, Thread
fs_backup = Thread.thread().file_resolver()
xml.load_string("""<scene version="2.0.0">
<path value="/tmp"/>
</scene>""")
assert fs_backup == Thread.thread().file_resolver()
def main():
"""
Generate reference images for all the scenes contained within the TEST_SCENE_DIR directory,
and for all the color mode having their `scalar_*` mode enabled.
"""
parser = argparse.ArgumentParser(prog='RenderReferenceImages')
parser.add_argument(
'--overwrite',
action='store_true',
help=
'Force rerendering of all reference images. Otherwise, only missing references will be rendered.'
)
parser.add_argument('--spp',
default=256,
type=int,
help='Samples per pixel')
args = parser.parse_args()
ref_spp = args.spp
overwrite = args.overwrite
for scene_fname in scenes:
scene_dir = dirname(scene_fname)
for variant in mitsuba.variants():
if not variant.split('_')[0] == 'scalar' or variant.endswith(
'double'):
continue
mitsuba.set_variant(variant)
from mitsuba.core import Bitmap, Struct, Thread
ref_fname = get_ref_fname(scene_fname)
if os.path.exists(ref_fname) and not overwrite:
continue
Thread.thread().file_resolver().append(scene_dir)
scene = mitsuba.core.xml.load_file(scene_fname,
parameters=[('spp',
str(ref_spp))])
scene.integrator().render(scene, scene.sensors()[0])
film = scene.sensors()[0].film()
cur_bitmap = film.bitmap(raw=True).convert(Bitmap.PixelFormat.RGB,
Struct.Type.Float32,
False)
# Write rendered image to a file
cur_bitmap.write(ref_fname)
print('Saved rendered image to: ' + ref_fname)
def test13_xml_multiple_defaults(variant_scalar_rgb):
from mitsuba.python.xml import dict_to_xml
from mitsuba.core.xml import load_file
from mitsuba.core import Thread
fr = Thread.thread().file_resolver()
mts_root = str(fr[len(fr) - 1])
filepath = os.path.join(mts_root, 'resources/data/scenes/dict13/dict.xml')
fr.append(os.path.dirname(filepath))
scene_dict = {
'type': 'scene',
'cam1': {
'type': 'perspective',
'sampler': {
'type': 'independent',
'sample_count': 150
}
},
'cam2': {
'type': 'perspective',
'sampler': {
'type': 'independent',
'sample_count': 250
}
}
}
dict_to_xml(scene_dict, filepath)
scene = load_file(filepath, spp=45)
assert scene.sensors()[0].sampler().sample_count() == scene.sensors(
)[1].sampler().sample_count()
assert scene.sensors()[1].sampler().sample_count() == 45
rmtree(os.path.split(filepath)[0])
def _get_logger():
"""
Get Mitsuba Logger instance
"""
from mitsuba.core import Thread
return Thread.thread().logger()
def initializeMitsuba(self):
# Start up the scheduling system with one worker per local core
self.scheduler = Scheduler.getInstance()
for i in range(0, multiprocessing.cpu_count()):
self.scheduler.registerWorker(LocalWorker(i, 'wrk%i' % i))
self.scheduler.start()
# Create a queue for tracking render jobs
self.queue = RenderQueue()
# Get a reference to the plugin manager
self.pmgr = PluginManager.getInstance()
# Process Mitsuba log and progress messages within Python
class CustomAppender(Appender):
def append(self2, logLevel, message):
print(message)
def logProgress(self2, progress, name, formatted, eta):
# Asynchronously notify the main thread
self.renderProgress.emit(progress)
logger = Thread.getThread().getLogger()
logger.setLogLevel(EWarn) # Display warning & error messages
logger.clearAppenders()
logger.addAppender(CustomAppender())
def closeEvent(self, e):
self.job.cancel()
self.queue.join()
self.scheduler.stop()
def test01_xml_save_plugin(variant_scalar_rgb):
from mitsuba.core import xml
from mitsuba.core import Thread
from mitsuba.python.xml import dict_to_xml
fr = Thread.thread().file_resolver()
# Add the path to the mitsuba root folder, so that files are always saved in mitsuba/resources/...
# This way we know where to look for the file in case the unit test fails
mts_root = str(fr[len(fr) - 1])
filepath = os.path.join(mts_root, 'resources/data/scenes/dict01/dict.xml')
fr.append(os.path.dirname(filepath))
scene_dict = {
"type": "sphere",
"center": [0, 0, -10],
"radius": 10.0,
}
dict_to_xml(scene_dict, filepath)
s1 = xml.load_dict({
'type': 'scene',
'sphere': {
"type": "sphere",
"center": [0, 0, -10],
"radius": 10.0,
}
})
s2 = xml.load_file(filepath)
assert str(s1) == str(s2)
rmtree(os.path.split(filepath)[0])
def test05_xml_split(variant_scalar_rgb):
from mitsuba.core import xml, Point3f
from mitsuba.python.xml import dict_to_xml
from mitsuba.core import Thread
import numpy as np
fr = Thread.thread().file_resolver()
mts_root = str(fr[len(fr) - 1])
filepath = os.path.join(mts_root, 'resources/data/scenes/dict05/dict.xml')
fr.append(os.path.dirname(filepath))
scene_dict = {
'type': 'scene',
'bsdf1': {
'type': 'diffuse'
},
'envmap': {
'type': 'envmap',
'filename': 'resources/data/common/textures/museum.exr'
},
'shape': {
'type': 'sphere',
'bsdf': {
'type': 'ref',
'id': 'bsdf1'
}
}
}
dict_to_xml(scene_dict, filepath)
s1 = xml.load_file(filepath)
dict_to_xml(scene_dict, filepath, split_files=True)
s2 = xml.load_file(filepath)
assert str(s1) == str(s2)
rmtree(os.path.split(filepath)[0])
def test09_xml_decompose_transform(variant_scalar_rgb):
from mitsuba.python.xml import dict_to_xml
from mitsuba.core.xml import load_dict, load_file
from mitsuba.core import Transform4f, Vector3f, Thread
fr = Thread.thread().file_resolver()
mts_root = str(fr[len(fr) - 1])
filepath = os.path.join(mts_root, 'resources/data/scenes/dict09/dict.xml')
fr.append(os.path.dirname(filepath))
scene_dict = {
'type': 'scene',
'cam': {
'type':
'perspective',
'fov_axis':
'x',
'fov':
35,
'to_world':
Transform4f.look_at(Vector3f(15, 42.3,
25), Vector3f(1.0, 0.0, 0.5),
Vector3f(1.0, 0.0, 0.0))
}
}
dict_to_xml(scene_dict, filepath)
s1 = load_file(filepath)
s2 = load_dict(scene_dict)
vects = [Vector3f(0, 0, 1), Vector3f(0, 1, 0), Vector3f(1, 0, 0)]
tr1 = s1.sensors()[0].world_transform().eval(0)
tr2 = s2.sensors()[0].world_transform().eval(0)
for vec in vects:
assert tr1.transform_point(vec) == tr2.transform_point(vec)
rmtree(os.path.split(filepath)[0])
def test12_xml_duplicate_files(variants_scalar_all):
from mitsuba.python.xml import dict_to_xml
from mitsuba.core import Thread
fr = Thread.thread().file_resolver()
mts_root = str(fr[len(fr) - 1])
filepath = os.path.join(mts_root, 'resources/data/scenes/dict12/dict.xml')
fr.append(os.path.dirname(filepath))
spectrum_path = os.path.join(mts_root, 'resources/data/ior/Al.eta.spd')
#Export the same file twice, this should only copy it once
scene_dict = {
'type': 'scene',
'light': {
"type": "point",
"intensity": {
"type": "spectrum",
"filename": spectrum_path
}
},
'light2': {
"type": "point",
"intensity": {
"type": "spectrum",
"filename": spectrum_path
}
}
}
dict_to_xml(scene_dict, filepath)
spectra_files = os.listdir(
os.path.join(os.path.split(filepath)[0], 'spectra'))
assert len(spectra_files) == 1 and spectra_files[0] == "Al.eta.spd"
spectrum_path2 = os.path.join(mts_root,
'resources/data/scenes/dict12/Al.eta.spd')
copy(spectrum_path, spectrum_path2)
#Export two files having the same name
scene_dict = {
'type': 'scene',
'light': {
"type": "point",
"intensity": {
"type": "spectrum",
"filename": spectrum_path
}
},
'light2': {
"type": "point",
"intensity": {
"type": "spectrum",
"filename": spectrum_path2
}
}
}
dict_to_xml(scene_dict, filepath)
spectra_files = os.listdir(
os.path.join(os.path.split(filepath)[0], 'spectra'))
assert len(spectra_files) == 2 and spectra_files[
0] == "Al.eta.spd" and spectra_files[1] == "Al.eta(1).spd"
rmtree(os.path.split(filepath)[0])
def redirect_logger(write_function=print, log_level=EInfo, tqdm_progressbar=None):
"""
Redirect Mitsuba's Logger output to a custom function (so it can be used with e.g. tqdm).
Additionally, can be used to control the log level
:param write_function: A function like print() or tqdm.write() that is used to write log messages and progess bars
:param log_level: The Mitsuba log level (mitsuba.EError, ...)
:param tqdm_progressbar: Optionally, pass a tqdm progress bar. The Mitsuba rendering bar will be set as that bar's description
:return:
"""
class RedirectedAppender(Appender):
def __init__(self, write_function, tqdm_progressbar):
self.write_function = write_function
self.tqdm_progressbar = tqdm_progressbar
super().__init__()
def append(self, log_level, message):
self.write_function(message)
def logProgress(self, progress, name, formatted, eta):
if self.tqdm_progressbar is not None:
self.tqdm_progressbar.set_description_str(formatted.replace('\r', ''), refresh=True)
else:
self.write_function(f"\r{formatted}", end='')
logger = Thread.getThread().getLogger()
logger.clearAppenders()
logger.addAppender(RedirectedAppender(write_function, tqdm_progressbar))
logger.setLogLevel(log_level)
def __init__(self):
super().__init__()
self.thread = Thread.registerUnmanagedThread('exporter')
self.thread.setFileResolver(main_fresolver)
self.thread.setLogger(main_logger)
self.pmgr = PluginManager.getInstance()
self.scene = Scene()
def __init__(self):
super().__init__()
self.thread = Thread.registerUnmanagedThread('exporter')
self.thread.setFileResolver(main_fresolver)
self.thread.setLogger(main_logger)
self.pmgr = PluginManager.getInstance()
self.scene = Scene()
def getScene(self):
if (project_dir == "null"):
print("No simulation.")
return
fileResolver = Thread.getThread().getFileResolver()
logger = Thread.getThread().getLogger()
logger.clearAppenders()
scenepath = session.get_scenefile_path_according_to_basedir(
project_dir)
fileResolver.appendPath(str(scenepath))
main_xml = str(os.path.join(scenepath, main_scene_xml_file))
if not os.path.exists(main_xml):
print("Simulation not generated.")
return
scene = SceneHandler.loadScene(main_xml)
scene.configure()
scene.initialize()
return LessScene(scene, self.XSize, self.YSize)
def test10_xml_rgb(variants_scalar_all):
from mitsuba.python.xml import dict_to_xml
from mitsuba.core.xml import load_dict, load_file
from mitsuba.core import Thread, ScalarColor3f
fr = Thread.thread().file_resolver()
mts_root = str(fr[len(fr) - 1])
filepath = os.path.join(mts_root, 'resources/data/scenes/dict10/dict.xml')
fr.append(os.path.dirname(filepath))
d1 = {
'type': 'scene',
'point': {
"type": "point",
"intensity": {
"type": "rgb",
"value": ScalarColor3f(0.5, 0.2, 0.5)
}
}
}
d2 = {
'type': 'scene',
'point': {
"type": "point",
"intensity": {
"type": "rgb",
"value": [0.5, 0.2, 0.5] # list -> ScalarColor3f
}
}
}
dict_to_xml(d1, filepath)
s1 = load_file(filepath)
dict_to_xml(d2, filepath)
s2 = load_file(filepath)
s3 = load_dict(d1)
assert str(s1) == str(s2)
assert str(s1) == str(s3)
d1 = {
'type': 'scene',
'point': {
"type": "point",
"intensity": {
"type": "rgb",
"value": 0.5 # float -> ScalarColor3f
}
}
}
dict_to_xml(d1, filepath)
s1 = load_file(filepath)
s2 = load_dict(d1)
assert str(s1) == str(s2)
rmtree(os.path.split(filepath)[0])
def load_scene(filename, *args, **kwargs):
"""Prepares the file resolver and loads a Mitsuba scene from the given path."""
fr = Thread.thread().file_resolver()
here = os.path.dirname(__file__)
fr.append(here)
fr.append(os.path.join(here, filename))
fr.append(os.path.dirname(filename))
scene = load_file(filename, *args, **kwargs)
assert scene is not None
return scene
def main():
# Register MeasuredBTF
register_bsdf('measuredbtf', lambda props: MeasuredBTF(props))
# Filename
filename_src = args.input
filename_dst = args.output
# Load an XML file
Thread.thread().file_resolver().append(os.path.dirname(filename_src))
scene = load_file(filename_src)
# Rendering
scene.integrator().render(scene, scene.sensors()[0])
# Save image
film = scene.sensors()[0].film()
bmp = film.bitmap(raw=True)
bmp.convert(Bitmap.PixelFormat.RGB, Struct.Type.UInt8,
srgb_gamma=True).write(filename_dst)
def test_render(variants_all, scene_fname):
from mitsuba.core import Bitmap, Struct, Thread
scene_dir = dirname(scene_fname)
if os.path.split(scene_dir)[1] in EXCLUDE_FOLDERS:
pytest.skip(f"Skip rendering scene {scene_fname}")
Thread.thread().file_resolver().append(scene_dir)
ref_fname = get_ref_fname(scene_fname)
assert os.path.exists(ref_fname)
scene = mitsuba.core.xml.load_file(scene_fname,
parameters=[('spp', str(32))])
scene.integrator().render(scene, scene.sensors()[0])
film = scene.sensors()[0].film()
cur_bitmap = film.bitmap(raw=True).convert(Bitmap.PixelFormat.RGB,
Struct.Type.Float32, False)
cur_image = np.array(cur_bitmap, copy=False)
ref_bitmap = Bitmap(ref_fname).convert(Bitmap.PixelFormat.RGB,
Struct.Type.Float32, False)
ref_image = np.array(ref_bitmap, copy=False)
error = np.mean(np.mean(np.abs(ref_image - cur_image)))
threshold = 0.5 * np.mean(np.mean(ref_image))
success = error < threshold
if not success:
print("Failed. error: {} // threshold: {}".format(error, threshold))
# Write rendered image to a file
cur_fname = os.path.splitext(
scene_fname)[0] + '_render_' + mitsuba.variant() + '.exr'
cur_bitmap.write(cur_fname)
print('Saved rendered image to: ' + cur_fname)
assert False
def test02_xml_missing_type(variant_scalar_rgb):
from mitsuba.python.xml import dict_to_xml
from mitsuba.core import Thread
fr = Thread.thread().file_resolver()
mts_root = str(fr[len(fr) - 1])
filepath = os.path.join(mts_root, 'resources/data/scenes/dict02/dict.xml')
fr.append(os.path.dirname(filepath))
scene_dict = {'my_bsdf': {'type': 'diffuse'}}
with pytest.raises(ValueError) as e:
dict_to_xml(scene_dict, filepath)
e.match("Missing key: 'type'!")
rmtree(os.path.split(filepath)[0])
def test03_xml_references(variant_scalar_rgb):
from mitsuba.core import xml
from mitsuba.python.xml import dict_to_xml
from mitsuba.core import Thread
fr = Thread.thread().file_resolver()
mts_root = str(fr[len(fr) - 1])
filepath = os.path.join(mts_root, 'resources/data/scenes/dict03/dict.xml')
fr.append(os.path.dirname(filepath))
scene_dict = {
'type': 'scene',
'bsdf1': {
'type': 'diffuse',
'reflectance': {
'type': 'rgb',
'value': [1.0, 0.0, 0.0]
}
},
'texture1': {
'type': 'checkerboard'
},
'bsdf4': {
'type': 'dielectric',
'specular_reflectance': {
'type': 'ref',
'id': 'texture1'
},
'id': 'bsdf2'
},
'shape1': {
'type': 'sphere',
'bsdf': {
'type': 'ref',
'id': 'bsdf1'
}
},
'shape2': {
'type': 'cylinder',
'bsdf': {
'type': 'ref',
'id': 'bsdf2'
}
}
}
s1 = xml.load_dict(scene_dict)
dict_to_xml(scene_dict, filepath)
s2 = xml.load_file(filepath)
assert str(s1.shapes()[0].bsdf()) == str(s2.shapes()[0].bsdf())
rmtree(os.path.split(filepath)[0])
def __initialize_mitsuba_setting(self):
self.plgr = PluginManager.getInstance()
self.output_dir = self.scene.output_dir
mitsuba_module_path = os.path.dirname(inspect.getfile(MitsubaRenderer))
self.file_resolver = Thread.getThread().getFileResolver()
self.file_resolver.appendPath(
os.path.join(mitsuba_module_path, "xml_files/"))
self.file_resolver.appendPath(
os.path.join(mitsuba_module_path, "textures/"))
self.file_resolver.appendPath(
os.path.join(mitsuba_module_path, "shapes/"))
self.mitsuba_scene = Scene()
def getTerrainBoundingAABB(self, main_scene_xml_file_prifix):
# get bounding sphere
currdir = os.path.split(os.path.realpath(__file__))[0]
import platform
if platform.system() == "Windows":
sys.path.append(
os.path.join(currdir, "bin", "rt", current_rt_program,
"python", "3.6"))
else:
sys.path.append(
os.path.join(currdir, "bin", "rt", current_rt_program,
"python", "3.5"))
os.environ['PATH'] = os.path.join(
currdir, "bin", "rt",
current_rt_program) + os.pathsep + os.environ['PATH']
import mitsuba
from mitsuba.core import Vector, Point, Ray, Thread
from mitsuba.render import SceneHandler
import platform
scenepath = session.get_scenefile_path()
# if "Windows" in platform.system():
# scenepath = str(scenepath.replace('\\', '\\\\'))
# 得到高程信息 通过光线跟踪的方法精确得到高程信息
fileResolver = Thread.getThread().getFileResolver()
logger = Thread.getThread().getLogger()
logger.clearAppenders()
scenepath = scenepath.encode('utf-8')
fileResolver.appendPath(scenepath)
filepath = os.path.join(session.get_scenefile_path(),
main_scene_xml_file_prifix +
terr_scene_file).encode("utf-8")
scene = SceneHandler.loadScene(fileResolver.resolve(filepath))
scene.configure()
scene.initialize()
return scene.getKDTree().getAABB()
def __init__(self):
self.fresolver = main_fresolver.clone()
self.thread = Thread.registerUnmanagedThread('renderer')
self.thread.setFileResolver(self.fresolver)
self.thread.setLogger(main_logger)
self.render_engine = MtsManager.RenderEngine
self.render_scene = MtsManager.CurrentScene
if self.render_engine.is_preview:
verbosity = 'quiet'
else:
verbosity = self.render_scene.mitsuba_engine.log_verbosity
main_logger.setLogLevel(self.log_level[verbosity])
def test13_duplicate_parameter(variant_scalar_rgb):
from mitsuba.core import xml
from mitsuba.core import Thread, LogLevel
logger = Thread.thread().logger()
l = logger.error_level()
try:
logger.set_error_level(LogLevel.Warn)
with pytest.raises(Exception) as e:
xml.load_string("""<scene version="2.0.0">
<integer name="a" value="1"/>
<integer name="a" value="1"/>
</scene>""")
finally:
logger.set_error_level(l)
e.match('Property "a" was specified multiple times')
def __init__(self):
self.fresolver = main_fresolver.clone()
self.thread = Thread.registerUnmanagedThread('renderer')
self.thread.setFileResolver(self.fresolver)
self.thread.setLogger(main_logger)
self.render_engine = MtsManager.RenderEngine
self.render_scene = MtsManager.CurrentScene
if self.render_engine.is_preview:
verbosity = 'quiet'
else:
verbosity = self.render_scene.mitsuba_engine.log_verbosity
main_logger.setLogLevel(self.log_level[verbosity])
def test08_xml_defaults(variant_scalar_rgb):
from mitsuba.python.xml import dict_to_xml
from mitsuba.core import Thread
from mitsuba.core.xml import load_dict, load_file
fr = Thread.thread().file_resolver()
mts_root = str(fr[len(fr) - 1])
filepath = os.path.join(mts_root, 'resources/data/scenes/dict08/dict.xml')
fr.append(os.path.dirname(filepath))
spp = 250
resx = 1920
resy = 1080
scene_dict = {
'type': 'scene',
'cam': {
'type': 'perspective',
'fov_axis': 'x',
'fov': 35,
'sampler': {
'type': 'independent',
'sample_count': spp # --> default
},
'film': {
'type': 'hdrfilm',
'width': resx, # --> default
'height': resy # --> default
}
}
}
dict_to_xml(scene_dict, filepath)
# Load a file using default values
s1 = load_file(filepath)
s2 = load_dict(scene_dict)
assert str(s1.sensors()[0].film()) == str(s2.sensors()[0].film())
assert str(s1.sensors()[0].sampler()) == str(s2.sensors()[0].sampler())
# Set new parameters
spp = 45
resx = 2048
resy = 485
# Load a file with options for the rendering parameters
s3 = load_file(filepath, spp=spp, resx=resx, resy=resy)
scene_dict['cam']['sampler']['sample_count'] = spp
scene_dict['cam']['film']['width'] = resx
scene_dict['cam']['film']['height'] = resy
s4 = load_dict(scene_dict)
assert str(s3.sensors()[0].film()) == str(s4.sensors()[0].film())
assert str(s3.sensors()[0].sampler()) == str(s4.sensors()[0].sampler())
rmtree(os.path.split(filepath)[0])
def do_simulation_multi_spectral_py():
currdir = os.path.split(os.path.realpath(__file__))[0]
sys.path.append(currdir + '/bin/rt/' + current_rt_program + '/python/2.7/')
os.environ['PATH'] = currdir + '/bin/rt/' + current_rt_program + os.pathsep + os.environ['PATH']
import mitsuba
from mitsuba.core import Vector, Point, Ray, Thread, Scheduler, LocalWorker, PluginManager, Transform
from mitsuba.render import SceneHandler
from mitsuba.render import RenderQueue, RenderJob
from mitsuba.render import Scene
import multiprocessing
scheduler = Scheduler.getInstance()
for i in range(0, multiprocessing.cpu_count()):
scheduler.registerWorker(LocalWorker(i, 'wrk%i' % i))
scheduler.start()
cfgfile = session.get_config_file()
f = open(cfgfile, 'r')
cfg = json.load(f)
distFileName = spectral_img_prefix + "_VZ=" + str(cfg["observation"]["obs_zenith"]) + \
"_VA=" + str(cfg["observation"]["obs_azimuth"])
distFile = os.path.join(session.get_output_dir(), distFileName).encode("utf-8")
scene_file_path = os.path.join(session.get_scenefile_path(), main_scene_xml_file).encode("utf-8")
scene_path = session.get_scenefile_path().encode("utf-8")
fileResolver = Thread.getThread().getFileResolver()
fileResolver.appendPath(scene_path)
scene = SceneHandler.loadScene(fileResolver.resolve(scene_file_path))
scene.setDestinationFile(distFile)
scene.configure()
scene.initialize()
queue = RenderQueue()
sceneResID = scheduler.registerResource(scene)
job = RenderJob(('Simulation Job '+distFileName).encode("utf-8"), scene, queue, sceneResID)
job.start()
queue.waitLeft(0)
queue.join()
if output_format not in ("npy", "NPY") and os.path.exists(distFile + ".npy"):
data = np.load(distFile + ".npy")
bandlist = cfg["sensor"]["bands"].split(",")
RasterHelper.saveToHdr_no_transform(data, distFile, bandlist, output_format)
os.remove(distFile + ".npy")
log("INFO: Finished")
def f(*args, **kwargs):
# New file resolver
thread = Thread.thread()
fres_old = thread.file_resolver()
fres = FileResolver(fres_old)
# Append current test directory and project root to the
# search path.
fres.append(caller_path)
fres.append(root_path)
thread.set_file_resolver(fres)
# Run actual function
res = func(*args, **kwargs)
# Restore previous file resolver
thread.set_file_resolver(fres_old)
return res
def test06_xml_duplicate_id(variant_scalar_rgb):
from mitsuba.python.xml import dict_to_xml
from mitsuba.core import Thread
fr = Thread.thread().file_resolver()
mts_root = str(fr[len(fr) - 1])
filepath = os.path.join(mts_root, 'resources/data/scenes/dict06/dict.xml')
fr.append(os.path.dirname(filepath))
scene_dict = {
'type': 'scene',
'my-bsdf': {
'type': 'diffuse'
},
'bsdf1': {
'type': 'roughdielectric',
'id': 'my-bsdf'
}
}
with pytest.raises(ValueError) as e:
dict_to_xml(scene_dict, filepath)
e.match("Id: my-bsdf is already used!")
rmtree(os.path.split(filepath)[0])
def test04_xml_point(variant_scalar_rgb):
from mitsuba.core import xml, Point3f
from mitsuba.python.xml import dict_to_xml
from mitsuba.core import Thread
import numpy as np
fr = Thread.thread().file_resolver()
mts_root = str(fr[len(fr) - 1])
filepath = os.path.join(mts_root, 'resources/data/scenes/dict04/dict.xml')
fr.append(os.path.dirname(filepath))
scene_dict = {
'type': 'scene',
'light': {
'type': 'point',
'position': [0.0, 1.0, 2.0]
}
}
dict_to_xml(scene_dict, filepath)
s1 = xml.load_file(filepath)
scene_dict = {
'type': 'scene',
'light': {
'type': 'point',
'position': Point3f(0, 1, 2)
}
}
dict_to_xml(scene_dict, filepath)
s2 = xml.load_file(filepath)
scene_dict = {
'type': 'scene',
'light': {
'type': 'point',
'position': np.array([0, 1, 2])
}
}
dict_to_xml(scene_dict, filepath)
s3 = xml.load_file(filepath)
assert str(s1) == str(s2)
assert str(s1) == str(s3)
rmtree(os.path.split(filepath)[0])
def test01_custom(variant_scalar_rgb):
from mitsuba.core import Thread, Appender, Formatter, Log, LogLevel
# Install a custom formatter and appender and process a log message
messages = []
logger = Thread.thread().logger()
formatter = logger.formatter()
appenders = []
while logger.appender_count() > 0:
app = logger.appender(0)
appenders.append(app)
logger.remove_appender(app)
try:
class MyFormatter(Formatter):
def format(self, level, theClass, thread, filename, line, msg):
return "%i: class=%s, thread=%s, text=%s, filename=%s, ' \
'line=%i" % (level, str(theClass), thread.name(), msg,
filename, line)
class MyAppender(Appender):
def append(self, level, text):
messages.append(text)
logger.set_formatter(MyFormatter())
logger.add_appender(MyAppender())
Log(LogLevel.Info, "This is a test message")
assert len(messages) == 1
assert messages[0].startswith(
'200: class=None, thread=main, text=test01_custom(): This is a'
' test message, filename=')
finally:
logger.clear_appenders()
for app in appenders:
logger.add_appender(app)
logger.set_formatter(formatter)
if sys.platform == 'linux':
sys.setdlopenflags(oldflags)
from mitsuba.core import (
Scheduler, LocalWorker, Thread, Bitmap, Point2i, Vector2i, FileStream,
PluginManager, Spectrum, InterpolatedSpectrum, BlackBodySpectrum, Vector, Point,
Matrix4x4, Transform, AnimatedTransform,
Appender, EInfo, EWarn, EError,
)
from mitsuba.render import (
RenderQueue, RenderJob, RenderListener, Scene, SceneHandler, TriMesh
)
import multiprocessing
main_thread = Thread.getThread()
main_fresolver = main_thread.getFileResolver()
main_logger = main_thread.getLogger()
class CustomAppender(Appender):
def append(self, logLevel, message):
MtsLog(message)
def logProgress(self, progress, name, formatted, eta):
render_engine = MtsManager.RenderEngine
if not render_engine.is_preview:
percent = progress / 100
render_engine.update_progress(percent)
render_engine.update_stats('', 'Progress: %s - ETA: %s' % ('{:.2%}'.format(percent), eta))
def __init__(self):
self.thread = Thread.registerUnmanagedThread('serializer')
self.thread.setFileResolver(main_fresolver)
self.thread.setLogger(main_logger)
