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 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 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)