def render(scene, filename): scheduler = Scheduler.getInstance() for i in range(multiprocessing.cpu_count()): scheduler.registerWorker(LocalWorker(i, "wrk{}".format(i))) scheduler.start() queue = RenderQueue() scene.setDestinationFile(filename) job = RenderJob("myRenderJob", scene, queue) job.start() queue.waitLeft(0) queue.join() print(Statistics.getInstance().getStats())
def renderScene(scene, index, sceneResID): # Create a queue for tracking render jobs queue = RenderQueue() # Create a render job and insert it into the queue. Note how the resource # ID of the original scene is provided to avoid sending the full scene # contents over the network multiple times. job = RenderJob('myRenderJob' + str(index), scene, queue, sceneResID) job.start() # Wait for all jobs to finish and release resources queue.waitLeft(0) queue.join()
def render_trajectory_frames(mesh_path: Tuple[Path, Path], trajectory: List[Transform], queue: RenderQueue, shutter_time: float, width: int = 1920, height: int = 1440, fov: float = 60., num_samples: int = 32) -> None: """ Render a camera trajectory through a mesh loaded from mesh_path[0] at the Transformations given in trajectory :param mesh_path: Path tuple (input_filepath, output_dirpath) of the mesh to render :param trajectory: List of Mitsuba Transformations, corresponding to cameras in the trajectory :param shutter_time: The camera shutter time. Controls the amount of motion blur between every pair of consecutive frames :param width: Parameter passed to cameras.create_sensor_from_transform :param height: Parameter passed to cameras.create_sensor_from_transform :param fov: The field of view :param num_samples: Parameter passed to cameras.create_sensor_from_transform :param queue: The Mitsuba render queue to use for all the frames :return: """ input_path, output_path = mesh_path # Make Mesh mesh_obj = mesh.prepare_ply_mesh( input_path, util.get_predefined_spectrum('light_blue')) # Create sensors with animation transforms sensors = cameras.create_animated_sensors(trajectory, shutter_time, width, height, fov, num_samples) scene = util.construct_simple_scene([mesh_obj], sensors[0]) with tqdm( total=len(sensors), bar_format= 'Total {percentage:3.0f}% {n_fmt}/{total_fmt} [{elapsed}<{remaining}, {rate_fmt}{postfix}] {desc}', dynamic_ncols=True) as t: util.redirect_logger(tqdm.write, EError, t) t.write(input_path.stem) for idx, sensor in enumerate(sensors): # Make Scene scene.setSensor(sensor) scene.setDestinationFile( str(output_path / f'{input_path.stem}-{idx}.png')) # Make Result job = RenderJob(f'Render-{input_path.stem}-{idx}', scene, queue) job.start() queue.waitLeft(0) queue.join() t.update()
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 __run_mitsuba(self): self.mitsuba_scene.configure() scheduler = Scheduler.getInstance() for i in range(multiprocessing.cpu_count()): scheduler.registerWorker(LocalWorker(i, "worker_{}".format(i))) scheduler.start() queue = RenderQueue() self.mitsuba_scene.setDestinationFile(self.image_name) job = RenderJob("render job: {}".format(self.image_name), self.mitsuba_scene, queue) job.start() queue.waitLeft(0) queue.join() print(Statistics.getInstance().getStats()) scheduler.stop()
def main(): scene = makeScene() #print(scene) scheduler = Scheduler.getInstance() for i in range(0, multiprocessing.cpu_count()): scheduler.registerWorker(LocalWorker(i, "wrk{}".format(i))) scheduler.start() queue = RenderQueue() scene.setDestinationFile("renderedResult") job = RenderJob("MyRenderJob", scene, queue) job.start() queue.waitLeft(0) queue.join() print(Statistics.getInstance().getStats())
paramMap = StringMap() scene = SceneHandler.loadScene(fileResolver.resolve("cbox.xml"), paramMap) #print(scene) for nb_cores in range(1, multiprocessing.cpu_count()): scheduler = Scheduler.getInstance() for i in range(0, nb_cores): scheduler.registerWorker(LocalWorker(i, 'wrk%i' % i)) scheduler.start() queue = RenderQueue() scene.setDestinationFile('rendererResult_c'+str(nb_cores)) job = RenderJob('testJob', scene, queue) job.start() time.sleep(60) job.cancel() queue.waitLeft(0) queue.join() scheduler.stop() #print(Statistics.getInstance().getStats())
target0 = Vector(0.681017, 0.344339, 0.841651) origin0 = Vector(1.06275, -0.147389, 1.62427) up0 = Vector(-0.180728, -0.870101, -0.458544) target1 = Vector(0.0329559, 0.23162, 0.731513) origin1 = Vector(0.975366, 0.0865425, 0.430146) up1 = Vector(-0.0605996, -0.960187, 0.272722) sensor = scene.getSensor() frames = 60 for x in range(0, frames): frac = float(x) / float(frames - 1) target = (1.0 - frac) * target0 + frac * target1 origin = (1.0 - frac) * origin0 + frac * origin1 up = (1.0 - frac) * up0 + frac * up1 #xform = Transform.lookAt(Point(target), Point(origin), up) xform = Transform.lookAt(Point(origin), Point(target), up) sensor.setWorldTransform(xform) # below here seems to be what needs to be in the inner loop filename = "result_" + str(x) + ".exr" scene.setDestinationFile(filename) job = RenderJob('myRenderJob', scene, queue) job.start() queue.waitLeft(0) queue.join() print(Statistics.getInstance().getStats())
class MitsubaDemo(QMainWindow): renderProgress = Signal(int) def __init__(self): super(MitsubaDemo, self).__init__() # Initialize Mitsuba self.initializeMitsuba() self.job = self.createRenderJob() self.job.setInteractive(True) # Initialize the user interface status = self.statusBar() self.rwidget = RenderWidget(self, self.queue, self.scene.getFilm().getSize()) progress = QProgressBar(status) status.setContentsMargins(0,0,5,0) status.addPermanentWidget(progress) status.setSizeGripEnabled(False) self.setWindowTitle('Mitsuba/PyQt demo') self.setCentralWidget(self.rwidget) # Hide the scroll bar once the rendering is done def renderingUpdated(event): if event == MitsubaRenderBuffer.RENDERING_FINISHED: status.showMessage("Done.") progress.hide() self.renderProgress.connect(progress.setValue, Qt.QueuedConnection) self.rwidget.renderingUpdated.connect(renderingUpdated, Qt.QueuedConnection) # Start the rendering process status.showMessage("Rendering ..") self.job.start() 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 createRenderJob(self): self.scene = self.pmgr.create({ 'type' : 'scene', 'sphere' : { 'type' : 'sphere', }, 'envmap' : { 'type' : 'sky' }, 'sensor' : { 'type' : 'perspective', 'toWorld' : Transform.translate(Vector(0, 0, -5)), 'sampler' : { 'type' : 'halton', 'sampleCount' : 64 } } }) return RenderJob('rjob', self.scene, self.queue) def keyPressEvent(self, e): if e.key() == Qt.Key_Escape: self.close()
class Mitsuba(object): # Constructor def __init__(self, base_path,scene_name,params): self.params = params self.light = [] # Get a reference to the thread's file resolver self.fileResolver = Thread.getThread().getFileResolver() scenes_path = base_path + '/' + scene_name + '/mitsuba' self.fileResolver.appendPath(scenes_path) paramMap = StringMap() paramMap['myParameter'] = 'value' # Load the scene from an XML file self.scene = SceneHandler.loadScene(self.fileResolver.resolve(scene_name + '.xml'), paramMap) self.scheduler = Scheduler.getInstance() # Start up the scheduling system with one worker per local core 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() self.sceneResID = self.scheduler.registerResource(self.scene) # ----------------------SET SUNSKY ----------------------- def SetSunSky(self, dir_vec, radiance=1): pmgr = PluginManager.getInstance() obj = pmgr.create({ 'type' : 'sun', 'radiance' : Spectrum(radiance) }) self.light.append(obj) #self.light = obj # ----------------------SET SPOTLIGHT ----------------------- def SetSpotlight(self, dir_vec): pmgr = PluginManager.getInstance() obj = pmgr.create({ 'type' : 'spot', 'cutoffAngle' : 40.0, 'intensity' : Spectrum(50), 'toWorld' : Transform.lookAt( Point( dir_vec[0,0] , dir_vec[0,1] , dir_vec[0,2]), Point( dir_vec[0,3] , dir_vec[0,4] , dir_vec[0,5]), Vector(dir_vec[0,6] , dir_vec[0,7] , dir_vec[0,8]) ) }) self.light.append(obj) # self.light = obj # ----------------------SET SCREEN ----------------------- def SetRectangleScreen(self, screenPos, radiance, dx, dy): pmgr = PluginManager.getInstance() resctScreen = pmgr.create({ 'type' : 'rectangle', 'bsdf': { 'type': 'diffuse', 'reflectance' : Spectrum(0.78) }, 'toWorld' : Transform.translate(Vector (screenPos[0], screenPos[1], screenPos[2])) * Transform.rotate (Vector(1, 0,0), 180.0) * Transform .scale(Vector(dx / 2, dy / 2, 1)), 'emitter': { 'type': 'area', 'radiance': Spectrum(radiance) } }) self.light.append(resctScreen) # ----------------------SET WIDE SCREEN ----------------------- def SetWideScreen(self, width = 50.0 , height = 20.0, resX = 1, resY = 1, distance = 2, rand = False): screenXCorners = width/2* np.array([-1 , 1]) screenYCorners = height/2*np.array([-1 , 1]) dx = width / resX dy = height / resY screenX = np.linspace( screenXCorners [0] + dx / 2, screenXCorners [1] - dx / 2, num=resX) screenY = np.linspace( screenYCorners [0] + dy / 2, screenYCorners [1] - dy / 2, num=resY) for x in screenX: for y in screenY: curRadiance = np.random.uniform(0.0, 1.0) if rand else 1.0 self.SetRectangleScreen( np.array([x, y, distance]), curRadiance, dx, dy) # ----------------------SET CAMERA ----------------------- def SetCamera(self,dir_vec): pmgr = PluginManager.getInstance() obj = pmgr.create({ 'type' : 'perspective', 'toWorld' : Transform.lookAt( Point( dir_vec[0,0] , dir_vec[0,1] , dir_vec[0,2]), Point( dir_vec[0,3] , dir_vec[0,4] , dir_vec[0,5]), Vector(dir_vec[0,6] , dir_vec[0,7] , dir_vec[0,8]) ), #'focalLength': self.params['focalLength'], 'fov': self.params['fov'], 'fovAxis': self.params['fovAxis'], 'film' : { 'type' : 'hdrfilm', #'mfilm', #'ldrfilm', 'width' : self.params['camWidth'], 'height' : self.params['camHeight'], }, 'sampler' : { 'type' :'ldsampler', 'sampleCount' : self.params['sampleCount'] }, 'medium' : { 'type' : 'homogeneous', 'id': 'underwater', 'scale': 0.5, 'sigmaS' : Spectrum([0.4, 0.3, 0.3]), #[0.02, 0.02, 0.02]), 'sigmaA' : Spectrum([0.45, 0.06, 0.05]), #[0.3, 0.3, 0.3]), #'thikness': 1, 'phase' : { 'type' : 'hg', 'g' : 0.9 } } }) self.cam = obj def __createSampler(self,sampleCount): pmgr = PluginManager.getInstance() obj = pmgr.create({ 'type' : 'ldsampler', #'independent', 'sampleCount' : sampleCount }) self.sampler = obj # ----------------------RENDER----------------------- def Render(self,sampleCount): currScene = Scene(self.scene) for light in self.light: currScene.addChild(light) currScene.configure() currScene.addSensor(self.cam) currScene.setSensor(self.cam) self.__createSampler(sampleCount) # sample count currScene.setSampler(self.sampler) currScene.setDestinationFile('') # Create a render job and insert it into the queue job = RenderJob('myRenderJob', currScene, self.queue ) job.start() self.queue.waitLeft(0) self.queue.join() film = currScene.getFilm() size = film.getSize() bitmap = Bitmap(Bitmap.ERGBA, Bitmap.EFloat16, size) film.develop(Point2i(0, 0), size, Point2i(0, 0), bitmap) # End of render - get result result_image = np.array(bitmap.getNativeBuffer()) currSceneInfo = currScene.getAABB return result_image, currSceneInfo
def do_simulation_multiangle_seq(seqname): 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() scene_path = session.get_scenefile_path() fileResolver = Thread.getThread().getFileResolver() fileResolver.appendPath(str(scene_path)) scene = SceneHandler.loadScene(fileResolver.resolve( str(os.path.join(session.get_scenefile_path(), main_scene_xml_file)))) scene.configure() scene.initialize() queue = RenderQueue() sceneResID = scheduler.registerResource(scene) bsphere = scene.getKDTree().getAABB().getBSphere() radius = bsphere.radius targetx, targety, targetz = bsphere.center[0], bsphere.center[1], bsphere.center[2] f = open(seqname + ".conf", 'r') params = json.load(f) obs_azimuth = params['seq1']['obs_azimuth'] obs_zenith = params['seq2']['obs_zenith'] cfgfile = session.get_config_file() f = open(cfgfile, 'r') cfg = json.load(f) viewR = cfg["sensor"]["obs_R"] mode = cfg["sensor"]["film_type"] azi_arr = map(lambda x: float(x), obs_azimuth.strip().split(":")[1].split(",")) zeni_arr = map(lambda x: float(x), obs_zenith.strip().split(":")[1].split(",")) seq_header = multi_file_prefix + "_" + seqname index = 0 for azi in azi_arr: for zeni in zeni_arr: distFile = os.path.join(session.get_output_dir(), seq_header + ("_VA_%.2f" % azi).replace(".", "_") + ("_VZ_%.2f" % zeni).replace(".", "_")) newScene = Scene(scene) pmgr = PluginManager.getInstance() newSensor = pmgr.createObject(scene.getSensor().getProperties()) theta = zeni / 180.0 * math.pi phi = (azi - 90) / 180.0 * math.pi scale_x = radius scale_z = radius toWorld = Transform.lookAt( Point(targetx - viewR * math.sin(theta) * math.cos(phi), targety + viewR * math.cos(theta), targetz - viewR * math.sin(theta) * math.sin(phi)), # original Point(targetx, targety, targetz), # target Vector(0, 0, 1) # up ) * Transform.scale( Vector(scale_x, scale_z, 1) # 视场大小 ) newSensor.setWorldTransform(toWorld) newFilm = pmgr.createObject(scene.getFilm().getProperties()) newFilm.configure() newSensor.addChild(newFilm) newSensor.configure() newScene.addSensor(newSensor) newScene.setSensor(newSensor) newScene.setSampler(scene.getSampler()) newScene.setDestinationFile(str(distFile)) job = RenderJob('Simulation Job' + "VA_"+str(azi)+"_VZ_"+str(zeni), newScene, queue, sceneResID) job.start() queue.waitLeft(0) queue.join() # handle npy if mode == "spectrum" and (output_format not in ("npy", "NPY")): for azi in azi_arr: for zeni in zeni_arr: distFile = os.path.join(session.get_output_dir(), seq_header + ("_VA_%.2f" % azi).replace(".", "_") + ("_VZ_%.2f" % zeni).replace( ".", "_")) data = np.load(distFile + ".npy") bandlist = cfg["sensor"]["bands"].split(",") RasterHelper.saveToHdr_no_transform(data, distFile, bandlist, output_format) os.remove(distFile + ".npy")
class MitsubaDemo(QDialog): renderProgress = Signal(int) def __init__(self, parent, width, height, barHeight, progressHeight, folderPath, sceneName, mitsubaPath, frameNumber, scenePath, renderWindowPosX, renderWindowPosY, pluginPath): QDialog.__init__( self, parent ) #global isWindowExist #isWindowExist = True #global window #window = self self.startRender = True self.folderPath = folderPath self.mitsubaPath = mitsubaPath self.frameNumber = frameNumber self.scenePath = scenePath # Initialize Mitsuba if renderWindowPosX == -1 and renderWindowPosY == -1: self.setGeometry((GetSystemMetrics(0) - width - 20) / 2,(GetSystemMetrics(1) - height - barHeight - progressHeight - 40)/2, width + 20, height + barHeight + progressHeight + 40) else: self.setGeometry(renderWindowPosX, renderWindowPosY, width + 20, height + barHeight + progressHeight + 40) self.Colorize() btnStop = QtGui.QPushButton("Stop", self) btnStop.setMaximumSize(70, barHeight) btnRefresh = QtGui.QPushButton("Refresh", self) btnRefresh.setMaximumSize(80, barHeight) btnSave = QtGui.QPushButton("Save", self) btnSave.setMaximumSize(70, barHeight) self.connect(btnStop, SIGNAL('clicked()'), self.stopMethod) self.connect(btnRefresh, SIGNAL('clicked()'), self.refreshMethod) self.connect(btnSave, SIGNAL('clicked()'), self.saveMethod) doneLabel = QLabel() font = QtGui.QFont('Tahoma', 14) font.setBold(True) doneLabel.setFont(font) doneLabel.setText("Rendering...") doneLabel.setStyleSheet("QLabel { color: #d37700; }"); sIcon = QIcon(pluginPath + "\\icons\\" + "save_3118.png") btnSave.setIcon(sIcon) stopIcon = QIcon(pluginPath + "\\icons\\" + "stop_32_1340.png") btnStop.setIcon(stopIcon) rIcon = QIcon(pluginPath + "\\icons\\" + "view-refresh_2730.png") btnRefresh.setIcon(rIcon) imgLabel = QLabel() qp = QtGui.QPainter() layout = QGridLayout(self) layout.setSpacing(10) layout.addWidget(btnSave, 1, 0) layout.addWidget(btnRefresh, 1, 1) layout.addWidget(btnStop, 1, 2) layout.addWidget(imgLabel, 2, 0, 1, 4) self.initializeMitsuba() self.scene = SceneHandler.loadScene(folderPath + "\\" + sceneName) self.show() self.job = RenderJob('rjob', self.scene, self.queue) self.job.setInteractive(True) # Initialize the user interface progress = QtGui.QProgressBar(self) layout.addWidget(doneLabel, 3, 0, 1, 3) layout.addWidget(progress, 3, 3) self.rwidget = RenderWidget(self, self.queue, self.scene.getFilm().getSize()) self.setWindowTitle('Mitsuba render window') # Hide the scroll bar once the rendering is done def renderingUpdated(event): progress.setValue(100 * self.rwidget.extProgress / (self.rwidget.extIMG.width() * self.rwidget.extIMG.height())) imgLabel.setPixmap(QPixmap.fromImage(self.rwidget.extIMG)); if event == MitsubaRenderBuffer.RENDERING_FINISHED: lm("FINISH!!!") self.startRender = False #progress.hide() doneLabel.setText("Done!") doneLabel.setStyleSheet("QLabel { color: #00d328; }"); self.rwidget.renderingUpdated.connect(renderingUpdated, Qt.QueuedConnection) # Start the rendering process self.job.start() def initializeMitsuba(self): # Start up the scheduling system with one worker per local core self.scheduler = Scheduler.getInstance() if self.scheduler.isRunning() == True: self.scheduler.stop() 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 stopMethod(self): lm("stop workers=" + str(self.scheduler.getWorkerCount())) i = self.scheduler.getWorkerCount() - 1 while (i > 0 or i == 0): worker = self.scheduler.getWorker(i) self.scheduler.unregisterWorker(worker) i = i - 1 self.queue.join() self.scheduler.stop() def closeEvent(self, e): self.stopMethod() def keyPressEvent(self, e): if e.key() == Qt.Key_Escape: self.close() def refreshMethod(self): Refresh(self.frameNumber, self, self.geometry().x(), self.geometry().y()) def saveMethod(self): if self.startRender == False: filename = QtGui.QFileDialog.getSaveFileName(self, 'Open file', self.folderPath, "Images (*.png *.jpg)") self.rwidget.extIMG.save(filename) def Colorize(self): self.strStyleSheet = """ QDialog { background-color: #222; color: #FFF; } QLabel { background-color: #222; } QPushButton { background: QLinearGradient( x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #555, stop: 1 #444 ); border: 3; border-radius: 3px; color: #EEE; padding: 20px 10px; } QPushButton:hover { background: QLinearGradient( x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #666, stop: 1 #555 ); border: 0.5px outset #444; } QPushButton:pressed { background: QLinearGradient( x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #666, stop: 1 #444 ); border: 0.5px outset #444; } QProgressBar{ border: 2px solid grey; border-radius: 5px; text-align: center } """ self.setStyleSheet(self.strStyleSheet)
class Mitsuba(object): # Constructor def __init__(self, base_path, scene_name, params, screenParams): self.params = params self.screenParams = screenParams self.light = [] # Get a reference to the thread's file resolver self.fileResolver = Thread.getThread().getFileResolver() scenes_path = base_path + '/' + scene_name + '/mitsuba' self.fileResolver.appendPath(scenes_path) paramMap = StringMap() paramMap['myParameter'] = 'value' ## Load the scene from an XML file self.scene = SceneHandler.loadScene( self.fileResolver.resolve(scene_name + '.xml'), paramMap) ## Setting & adding emmiters to scene - diffusive screen, created out of multiple sub-screens # self.SetWideScreen() # mitsuba.SetSunSky(np.array([[3, 300,3, 0,0,0, 0,0,1]])) # TODO : fix overidin of : self.SetWideScreen(params['screenWidth'] , params['screenHeight'],params['resXScreen'],params['resYScreen'], params['screenZPos'],params['variantRadiance']) self.addSceneLights() ## Simultaneously rendering multiple versions of a scene self.scene.initialize() self.scheduler = Scheduler.getInstance() ## Start up the scheduling system with one worker per local core if 'SYS_NAME' in os.environ and os.environ['SYS_NAME'] == 'AWS': maxThreads = multiprocessing.cpu_count() else: maxThreads = min(multiprocessing.cpu_count(), 30) for i in range(0, maxThreads): self.scheduler.registerWorker(LocalWorker(i, 'wrk%i' % i)) self.scheduler.start() ## Create a queue for tracking render jobs self.queue = RenderQueue() self.sceneResID = self.scheduler.registerResource(self.scene) # ----------------------SET SUNSKY ----------------------- def SetSunSky(self, dir_vec, radiance=1): pmgr = PluginManager.getInstance() obj = pmgr.create({'type': 'sun', 'radiance': Spectrum(radiance)}) self.light.append(obj) # ----------------------SET SPOTLIGHT ----------------------- def SetSpotlight(self, dir_vec): pmgr = PluginManager.getInstance() obj = pmgr.create({ 'type': 'spot', 'cutoffAngle': 40.0, 'intensity': Spectrum(50), 'toWorld': Transform.lookAt( Point(dir_vec[0, 0], dir_vec[0, 1], dir_vec[0, 2]), Point(dir_vec[0, 3], dir_vec[0, 4], dir_vec[0, 5]), Vector(dir_vec[0, 6], dir_vec[0, 7], dir_vec[0, 8])) }) self.light.append(obj) # ----------------------SET SCREEN ----------------------- def SetRectangleScreen(self, screenPos, radiance, dx, dy): """Set a sub-screen (rectangle shape attached to area emitter) at screenPos, with dimentions of [dx X dy], With radiance radiance [Watt/(m^2*sr)] """ pmgr = PluginManager.getInstance() resctScreen = pmgr.create({ 'type': 'rectangle', 'bsdf': { 'type': 'diffuse', 'illuminant': Spectrum(1.0) #'reflectance' : Spectrum(0.78) # this is causing peaks noise in the result image - from reflections }, 'toWorld': Transform.translate( Vector(screenPos[0], screenPos[1], screenPos[2])) * Transform.rotate(Vector(1, 0, 0), 180.0) * Transform.scale(Vector(dx / 2, dy / 2, 1)), 'emitter': { 'type': 'constant', #'area',#,'constant',#'area', 'radiance': Spectrum(radiance), 'samplingWeight': 10.0 } }) self.light.append(resctScreen) # ----------------------SET WIDE SCREEN ----------------------- def SetWideScreen(self): # TODO : fix SetWideScreen() overriding #def SetWideScreen(self, width = 50.0 , height = 20.0, resX = 1, resY = 1, screenZPos = 2, rand = False): """Set a screen of light at Z = screenZPos, with dimentions of [width X height], containing [resX X resY] sub-surfaces of screens. The radiance [Watt/(m^2*sr)] of screeen can be either constant [1] of variant unifomily [0,1] """ width = self.screenParams['screenWidth'] height = self.screenParams['screenHeight'] resX = self.screenParams['resXScreen'] resY = self.screenParams['resYScreen'] screenZPos = self.screenParams['screenZPos'] rand = self.screenParams['variantRadiance'] maxRadiance = self.screenParams['maxRadiance'] screenXCorners = width / 2 * np.array([-1, 1]) screenYCorners = height / 2 * np.array([-1, 1]) dx = width / resX dy = height / resY screenX = np.linspace(screenXCorners[0] + dx / 2, screenXCorners[1] - dx / 2, num=resX) screenY = np.linspace(screenYCorners[0] + dy / 2, screenYCorners[1] - dy / 2, num=resY) for x in screenX: for y in screenY: curRadiance = np.random.uniform( 0.0, maxRadiance) if rand else maxRadiance self.SetRectangleScreen(np.array([x, y, screenZPos]), curRadiance, dx, dy) #def SetWideScreen(self): #"""Set a screen of light at Z = screenZPos, with dimentions of [width X height], containing [resX X resY] sub-surfaces of screens. #The radiance [Watt/(m^2*sr)] of screeen can be either constant [1] of variant unifomily [0,1] """ #width = self.params['screenWidth'] #height = self.params['screenHeight'] #resX = self.params['resXScreen'] #resY = self.params['resYScreen'] #screenZPos = self.params['screenZPos'] #rand = self.params['variantRadiance'] #self.SetWideScreen() = SetWideScreen(width , height , resX , resY, screenZPos, rand ) # ----------------------SET CAMERA ----------------------- def SetCamera(self, dir_vec): """Create and pre-set a new sensor according to dir_vec""" pmgr = PluginManager.getInstance() obj = pmgr.create({ 'type': 'perspective', 'toWorld': Transform.lookAt( Point(dir_vec[0, 0], dir_vec[0, 1], dir_vec[0, 2]), Point(dir_vec[0, 3], dir_vec[0, 4], dir_vec[0, 5]), Vector(dir_vec[0, 6], dir_vec[0, 7], dir_vec[0, 8])), #'focalLength': self.params['focalLength'], # focalLength can be achived by 'fov' & 'fovAxis' 'fov': self.params['fov'], 'fovAxis': self.params['fovAxis'], #'farClip':100.0, 'film': { 'type': 'hdrfilm', #'mfilm', #'ldrfilm', 'width': self.params['nWidth'], 'height': self.params['nHeight'], }, 'sampler': { 'type': 'ldsampler', #'independent',#'ldsampler', 'sampleCount': self.params['sampleCount'], 'dimension': self.params['samplerDimention'] }, 'medium': { # commented out only for debugging - 'type': 'homogeneous', 'id': 'underwater', #'sigmaS' : Spectrum([0.4, 0.3, 0.3]), #[0.02, 0.02, 0.02]), #'sigmaS' : Spectrum([0.0, 0.0, 0.0]), # for simulations with no scattering bg_sigmaA / cloud_sigmaA /water_sigmaA #'sigmaA' : Spectrum([0.45, 0.06, 0.05]), #[0.3, 0.3, 0.3]), 'sigmaS': Spectrum( [0.133, 0.1, 0.1] ), # for simulations with no scattering bg_sigmaA / cloud_sigmaA /water_sigmaA 'sigmaA': Spectrum([0.45, 0.06, 0.05]), #[0.3, 0.3, 0.3]), 'phase': { 'type': 'hg', 'g': 0.9 } } }) self.cam = obj def createSampler(self, sampleCount): pmgr = PluginManager.getInstance() obj = pmgr.create({ 'type': 'ldsampler', #independent',#'sobol', 'sampleCount': sampleCount, #'sampleCount' : self.params['sampleCount'], # TODO: add function for updating self.params instead of passing them 'dimension': self.params['samplerDimention'] #, #'scramble':10 # not sure how this is working yet }) self.sampler = obj # ----------------------RENDER----------------------- def addSceneLights(self): """ Adding all the pre-setted lights to the scene""" currScene = Scene(self.scene) for light in self.light: currScene.addChild(light) self.scene = currScene # ----------------------RENDERhjk----------------------- def Render(self, sampleCount, i): ## Creating a copy of the base scene and add modifications regarding varaiant camera's properties (sensor position, sampler) currScene = Scene(self.scene) currScene.configure() pmgr = PluginManager.getInstance() currScene.addSensor(self.cam) currScene.setSensor(self.cam) self.createSampler(sampleCount) currScene.setSampler(self.sampler) #(self.sampler) currScene.setDestinationFile('') ## Create a render job and insert it into the queue #job = RenderJob('myRenderJob'+str(i), currScene, self.queue ) curSceneResID = self.scheduler.registerResource(currScene) job = RenderJob('myRenderJob' + str(i), currScene, self.queue, curSceneResID) #job = RenderJob('myRenderJob'+str(i), currScene, self.queue,self.sceneResID ) # passing self.sceneResID - in order to create shallow copy of the scene to all warkers job.start() self.queue.waitLeft(0) self.queue.join() ## Aquire Bitmap format of the rendered image: film = currScene.getFilm() size = film.getSize() bitmap = Bitmap(Bitmap.ERGBA, Bitmap.EFloat16, size) film.develop(Point2i(0, 0), size, Point2i(0, 0), bitmap) ## End of render - get result result_image = np.array( bitmap.buffer()) if sys.platform == 'linux2' else np.array( bitmap.getNativeBuffer()) # TODO : update Mitsuba version of Windows, with the updated API - bitmap.getNativeBuffer() doesn't exsists animore currSceneInfo = currScene.getAABB return result_image, currSceneInfo def shutDownMitsuba(self): self.queue.join() self.scheduler.stop()
class Mitsuba(object): def __init__(self): # add path for the Python extension module if 'MITSUBA_DIR' not in os.environ: raise Exception( 'Set MITSUBA_DIR env variable, or source Mitsuba setpath.sh') MITSUBA_DIR = os.path.join(os.environ['MITSUBA_DIR'], 'dist') sys.path.append(MITSUBA_DIR + os.sep + 'python' + os.sep + '2.7') # Ensure python can find Mitsuba core libraries os.environ['PATH'] = MITSUBA_DIR + os.pathsep + os.environ['PATH'] # set up logger FORMAT = '%(asctime)-15s [%(levelname)s] %(message)s' logging.basicConfig(format=FORMAT) self.log = logging.getLogger('mts-render') self.log.setLevel(logging.INFO) # default setup self.setup = { 'integrator': 'path', # choices: path, mlt, vpl, ao 'emitter': 'constant', 'sensor': 'perspective', 'film': 'ldrfilm', 'sampler': 'ldsampler', 'pixelFormat': 'rgba', 'exposure': 0.0, #Exposure value e, scales radiance by 2^e 'banner': False, 'camera_up': Vector(0, 1, 0), 'eye': Point(0, 0, 0), 'target': Point(0, 0, 0), 'sampleCount': 256, 'fov': 90.0, 'width': 640, 'height': 480, } # Start up the scheduling system self.scheduler = Scheduler.getInstance() for i in range(0, multiprocessing.cpu_count()): self.scheduler.registerWorker(LocalWorker(i, 'wrk%i' % i)) self.queue = RenderQueue() self.pmgr = PluginManager.getInstance() def set_fov(self, degree): self.setup['fov'] = degree def set_sampleCount(self, sampleCount): self.setup['sampleCount'] = sampleCount def set_camera_up(self, x, y, z): self.setup['camera_up'] = Vector(x, y, z) def set_eye(self, x, y, z): self.setup['eye'] = Point(x, y, z) def set_target(self, x, y, z): self.setup['target'] = Point(x, y, z) def set_width(self, width): self.setup['width'] = width def set_height(self, height): self.setup['height'] = height def load_mesh(self, mesh_filenames): self.mesh = [] self.mesh_meta = [] for mesh_filename in mesh_filenames: if mesh_filename.endswith('.ply'): self.mesh.append( self.pmgr.create({ 'type': 'ply', 'filename': mesh_filename, 'bsdf': { 'type': 'twosided', 'bsdf': { 'type': 'diffuse', 'reflectance': { 'type': 'vertexcolors' } } } })) elif mesh_filename.endswith('.obj'): self.mesh.append( pmgr.create({ 'type': 'obj', 'filename': mesh_filename })) else: raise RuntimeError('Unsupported file type: ' + meshfile) #metadata for mesh in self.mesh: aabb = mesh.getAABB() bsphere = aabb.getBSphere() self.mesh_meta.append({ 'bsphere': { 'center': bsphere.center, 'radius': bsphere.radius }, 'aabb': { 'min': aabb.min, 'max': aabb.max } }) self.log.info(aabb) self.log.info(bsphere) def render(self, filename): self.scheduler.start() # create globals integrator = self.pmgr.create({'type': self.setup['integrator']}) emitter = self.pmgr.create({'type': self.setup['emitter']}) sensor = self.pmgr.create({ 'type': self.setup['sensor'], 'film': { 'type': self.setup['film'], 'width': self.setup['width'], 'height': self.setup['height'], 'pixelFormat': self.setup['pixelFormat'], 'exposure': self.setup['exposure'], 'banner': self.setup['banner'] }, 'sampler': { 'type': self.setup['sampler'], 'sampleCount': self.setup['sampleCount'] }, 'fov': self.setup['fov'], }) scene = Scene() scene.addChild(integrator) scene.addChild(emitter) scene.addChild(sensor) for mesh in self.mesh: scene.addChild(mesh) scene.configure() scene.initialize() # needed to force build of kd-tree transformCurr = Transform.lookAt(self.setup['eye'], self.setup['target'], self.setup['camera_up']) sensor.setWorldTransform(transformCurr) scene.setDestinationFile(filename) job = RenderJob('job', scene, self.queue) job.start() self.queue.waitLeft(0) self.queue.join() self.scheduler.stop()
def renderVPLS(vpls, cam, scene, target): ''' render VPLS having the camera looking at the desired target the scene. The result will be an image that will be used to define the 3D space where the camera and object can be placed in the environment. Target can be either be 'roof' or 'floor' ''' pmgr = PluginManager.getInstance() scheduler = Scheduler.getInstance() if (target == 'roof'): target_height = scene.HeightRoof else: target_height = scene.HeightFloor # Start up the scheduling system with one worker per local core for i in range(0, multiprocessing.cpu_count()): scheduler.registerWorker(LocalWorker(i, 'wrk%i' % i)) scheduler.start() # Create a queue for tracking render jobs queue = RenderQueue() nVPLS = int(vpls[0][1]) * 4 scene = Scene() for i in xrange(1, nVPLS, 4): if (float(vpls[i][2]) == target_height): scene.addChild( pmgr.create({ 'type': 'sphere', 'center': Point(float(vpls[i][1]), float(vpls[i][2]), float(vpls[i][3])), 'radius': 1.0, 'emitter': pmgr.create({ 'type': 'area', 'radiance': Spectrum(10.), }) })) scene.addChild( pmgr.create({ 'type': 'perspective', 'toWorld': Transform.lookAt( Point(cam.origin[0], cam.origin[1], cam.origin[2]), Point(cam.target[0], cam.target[1], cam.target[2]), Vector(cam.up[0], cam.up[1], cam.up[2])), 'fov': cam.fov, 'film': { 'type': 'ldrfilm', 'width': cam.width, 'height': cam.height, 'banner': False, }, 'sampler': { 'type': 'halton', 'sampleCount': 1 }, })) scene.addChild(pmgr.create({'type': 'direct'})) scene.configure() if (target == 'roof'): filename = 'renderVPLSRoof' else: filename = 'renderVPLSFloor' scene.setDestinationFile(filename) # Create a render job and insert it into the queue job = RenderJob('myRenderJob', scene, queue) job.start() # Wait for all jobs to finish and release resources queue.waitLeft(0) queue.join() scheduler.stop()