Esempio n. 1
0
 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 loadScene():
    # Get a reference to the thread's file resolver
    fileResolver = Thread.getThread().getFileResolver()
    fileResolver.appendPath('cbox')

    paramMap = StringMap()
    paramMap['myParameter'] = 'value'

    scene = SceneHandler.loadScene(fileResolver.resolve("cbox.xml"), paramMap)

    return scene
Esempio n. 3
0
            def set_scene(self, export_context):
                if export_context.EXPORT_API_TYPE == 'FILE':
                    scene_path, scene_file = os.path.split(efutil.filesystem_path(export_context.file_names[0]))
                    self.fresolver.appendPath(scene_path)
                    self.scene = SceneHandler.loadScene(self.fresolver.resolve(scene_file))

                elif export_context.EXPORT_API_TYPE == 'API':
                    self.scene = export_context.scene

                else:
                    raise Exception('Unknown exporter type')
Esempio n. 4
0
            def set_scene(self, export_context):
                if export_context.EXPORT_API_TYPE == 'FILE':
                    scene_path, scene_file = os.path.split(
                        efutil.filesystem_path(export_context.file_names[0]))
                    self.fresolver.appendPath(scene_path)
                    self.scene = SceneHandler.loadScene(
                        self.fresolver.resolve(scene_file))

                elif export_context.EXPORT_API_TYPE == 'API':
                    self.scene = export_context.scene

                else:
                    raise Exception('Unknown exporter type')
def loadScene(filename, vpls_location):
    # Get a reference to the thread's file resolver
    fileResolver = Thread.getThread().getFileResolver()

    # Optional: supply parameters that can be accessed
    # by the scene (e.g. as $myParameter)
    paramMap = StringMap()

    paramMap['mesh'] = str(vpls_location[:-13] + 'mesh.ply')
    paramMap['envmap'] = str(vpls_location[:-14] + '.exr')

    # Load the scene from an XML file
    scene = SceneHandler.loadScene(fileResolver.resolve(filename), paramMap)

    return (scene)
Esempio n. 6
0
def sample_mesh(mesh_file, n_samples, density=None, blue_noise_radius=None, resource_dir='./resources'):
    fileResolver = Thread.getThread().getFileResolver()
    fileResolver.appendPath(resource_dir)
    fileResolver.appendPath(os.path.split(mesh_file)[0])
    paramMap = StringMap()
    paramMap['meshfile'] = mesh_file
    scene = SceneHandler.loadScene(fileResolver.resolve(resource_dir + '/scene_shape_template.xml'), paramMap)
    scene.initialize()
    shape = scene.getShapes()[0]
    if density is not None:
        n_samples = max(int(shape.getSurfaceArea() * density), 32)

    use_blue_noise = blue_noise_radius is not None
    if not use_blue_noise:
        blue_noise_radius = 10
    sampled_p, sampled_n = scene.sampleSurface(shape, n_samples, use_blue_noise, blue_noise_radius)
    n_samples = len(sampled_p) // 3
    return np.reshape(np.array(sampled_p), [n_samples, 3]), np.reshape(np.array(sampled_n), [n_samples, 3])
Esempio n. 7
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")
Esempio n. 8
0
    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 sample_scattering_mesh(mesh_file, n_samples, batch_size, n_abs_samples,
                           media, seed, kdtree, extra_options):
    assert (mesh_file)
    resource_dir = './resources'
    fileResolver = Thread.getThread().getFileResolver()
    fileResolver.appendPath(resource_dir)
    fileResolver.appendPath(os.path.split(mesh_file)[0])
    paramMap = StringMap()
    paramMap['meshfile'] = mesh_file
    scene = SceneHandler.loadScene(
        fileResolver.resolve(resource_dir + '/scene_shape_template.xml'),
        paramMap)
    scene.initialize()
    shape = scene.getShapes()[0]
    ignore_zero_scatter = get_default(extra_options, 'ignore_zero_scatter',
                                      True)
    fixed_in_dir = get_default(extra_options, 'fixed_in_dir', False)

    poly_fit_cfg = PolyFitConfig()
    set_obj_from_dict(poly_fit_cfg, extra_options)
    poly_fit_cfg.useLightspace = False
    importanceSamplePolys = get_default(extra_options,
                                        'importance_sample_polys', False)

    if kdtree is not None:
        tmp_result = mitsuba.render.Volpath3D.samplePoly(
            shape, media, n_samples, batch_size, n_abs_samples,
            ignore_zero_scatter, False, importanceSamplePolys, kdtree,
            fixed_in_dir, seed, poly_fit_cfg)
    else:
        compute_sh_coefficients = get_default(extra_options,
                                              'compute_sh_coefficients', False)
        if compute_sh_coefficients:
            tmp_result = mitsuba.render.Volpath3D.sampleShCoeffs(
                scene, shape, media, n_samples, batch_size, n_abs_samples,
                ignore_zero_scatter, False, seed)
        else:
            tmp_result = mitsuba.render.Volpath3D.sample(
                scene, shape, media, n_samples, batch_size, n_abs_samples,
                ignore_zero_scatter, False, seed)
    return tmp_result
Esempio n. 10
0
        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)
Esempio n. 11
0
    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)
Esempio n. 12
0
    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()
sys.path.append(MITSUBA_PATH + 'python/2.7')
os.environ['PATH'] = MITSUBA_PATH + os.pathsep + os.environ['PATH']

import mitsuba
import multiprocessing

from mitsuba.core import *
from mitsuba.render import SceneHandler, RenderQueue, RenderJob

fileResolver = Thread.getThread().getFileResolver()
fileResolver.appendPath('cbox/')

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)
Esempio n. 14
0
    def forest_generate_according_tree_pos_file_for3d(config_file_path):
        import mitsuba
        from mitsuba.core import Vector, Point, Ray, Thread
        from mitsuba.render import SceneHandler
        from mitsuba.render import RenderQueue, RenderJob
        from mitsuba.render import Scene
        from mitsuba.render import Intersection

        f = open(config_file_path, 'r')
        cfg = json.load(f)
        tree_pos = combine_file_path(session.get_input_dir(),
                                     cfg["scene"]["forest"]["tree_pos_file"])
        if cfg["scene"]["forest"]["tree_pos_file"] == "" or (
                not os.path.exists(tree_pos)):
            return

        # 读取地形数据 计算每个树的高程
        if cfg["scene"]["terrain"]["terrain_type"] != "PLANE" and cfg["scene"][
                "terrain"]["terrain_type"] == "RASTER":
            demfile = combine_file_path(session.get_input_dir(),
                                        cfg["scene"]["terrain"]["terr_file"])
            img_w, img_h, dem_arr = RasterHelper.read_dem_as_array(demfile)
            dem_arr = dem_arr - dem_arr.min()

        scenepath = session.get_scenefile_path()
        if "Windows" in platform.system():
            scenepath = str(scenepath.replace('\\', '\\\\'))
        # 得到高程信息 通过光线跟踪的方法精确得到高程信息
        fileResolver = Thread.getThread().getFileResolver()
        logger = Thread.getThread().getLogger()
        logger.clearAppenders()
        fileResolver.appendPath(scenepath)
        # 由于batch模式不会改变地形几何结构,因此在用地形打点计算树木的高程时,用第一个terrain文件即可,所以加上了_0_

        scene = SceneHandler.loadScene(
            fileResolver.resolve(str(terr_scene_file)))
        scene.configure()
        scene.initialize()
        tf = open(tree_pos)

        objectPosFile = open(
            os.path.join(session.get_input_dir(), "object_pos_3dView.txt"),
            'w')

        # 创建一个虚拟根节点,最后再删除
        for line in tf:
            arr = line.replace("\n", "").split(" ")
            objectName = arr[0]
            x = float(arr[1])
            y = float(arr[2])
            xScale = cfg["scene"]["terrain"]["extent_width"]
            zScale = cfg["scene"]["terrain"]["extent_height"]
            treeX = 0.5 * xScale - x
            treeZ = 0.5 * zScale - y
            if cfg["scene"]["terrain"]["terrain_type"] != "PLANE":
                ray = Ray()
                ray.setOrigin(Point(treeX, 9999, treeZ))
                ray.setDirection(Vector(0, -1, 0))
                its = scene.rayIntersect(ray)
                if not its is None:
                    linestr = objectName + " " + str(treeX) + " " + str(
                        its.p[1]) + " " + str(treeZ) + "\n"
                else:
                    # log("warning: precise height not found.")
                    if cfg["scene"]["terrain"]["terrain_type"] == "RASTER":
                        im_r = int((y / float(zScale)) * img_h)
                        im_c = int((x / float(xScale)) * img_w)
                        if im_r >= img_h:
                            im_r = img_h - 1
                        if im_c >= img_w:
                            im_c = img_w - 1
                        linestr = objectName + " " + str(treeX) + " " + str(
                            dem_arr[im_r][im_c]) + " " + str(treeZ) + "\n"
                    else:
                        linestr = objectName + " " + str(treeX) + " " + str(
                            0) + " " + str(treeZ) + "\n"
            else:
                linestr = objectName + " " + str(treeX) + " " + str(
                    0) + " " + str(treeZ) + "\n"
            objectPosFile.write(linestr)
        objectPosFile.close()
Esempio n. 15
0
if not exists("result"):
    mkdir("result")
#  Get  a  reference  to  the  thread's  file  resolver
fileResolver = Thread.getThread().getFileResolver()
#  Register  any  searchs  path  needed  to  load  scene  resources  (optional)
#fileResolver.appendPath('<path  to  scene  directory>')
#  Optional:  supply  parameters  that  can  be  accessed
#  by  the  scene  (e.g.  as  $myParameter)
paramMap = StringMap()
scene_name = argv[1]
print "Rendering scene #%s#" % scene_name
paramMap['myParameter'] = 'value'
#  Load  the  scene  from  an  XML  file
scene = SceneHandler.loadScene(
    fileResolver.resolve(
        expanduser("/home/xhg/Desktop/kujiale_files/mitsuba/" + scene_name +
                   "_full_new_diffuse_twosided.xml")), paramMap)

scheduler = Scheduler.getInstance()
#  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()

sensor = scene.getSensor()

shapes = scene.getShapes()
Esempio n. 16
0
import mitsuba
from mitsuba.core import *
from mitsuba.render import SceneHandler
fileResolver = Thread.getThread().getFileResolver()
fileResolver.appendPath('~/CONF/QUIJIBO/renders/python')
paramMap = StringMap()
scene = SceneHandler.loadScene(
    fileResolver.resolve(
        "/Users/tkim/CONF/QUIJIBO/renders/python/bunny_zoom_0_1.xml"),
    paramMap)

from mitsuba.core import *
from mitsuba.render import RenderQueue, RenderJob
import multiprocessing

scheduler = Scheduler.getInstance()
# Start up the scheduling system with one worker per local core
for i in range(0, 4):
    scheduler.registerWorker(LocalWorker(i, 'wrk%i' % i))
scheduler.start()
queue = RenderQueue()

import numpy as np
from scipy import *

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)
Esempio n. 17
0

fileResolver = Thread.getThread().getFileResolver()
paramMap = StringMap()

scheduler = Scheduler.getInstance()
for i in range(0, multiprocessing.cpu_count()):
    scheduler.registerWorker(LocalWorker(i, 'wrk%i' % i))
scheduler.start()
totalFrames = 1111
# upper_filepath = os.path.abspath(os.path.join(os.getcwd(), "../.."))
for i in range(totalFrames):
    origin_now, target_now = bal.update("camera")
    processXML.changeXML_lookat(
        "scene_integrator_cam.xml", "perspective", origin_now, target_now)
    processXML.changeXML_translate(
        "scene_objs.xml", "cow.obj",  bal.update("cow.obj")[0])
    paramMap = StringMap()
    scene = SceneHandler.loadScene(
        fileResolver.resolve("scene_main.xml"), paramMap)
    queue = RenderQueue()
    scene.setDestinationFile('imgs/' + str(i) + '.jpg')
    # Create a render job and insert it into the queue
    job = RenderJob('myRenderJob', scene, queue)

    # render one img
    job.start()
    # Wait for all jobs to finish and release resources
    queue.waitLeft(0)
    queue.join()
Esempio n. 18
0
 print 'Starting frame', frame
 #
 # Scene parameters
 paramMap = StringMap()
 paramMap['target_x'] = str(target_x)
 paramMap['target_y'] = str(target_y)
 paramMap['target_z'] = str(target_z)
 paramMap['origin_x'] = str(origin_x)
 paramMap['origin_y'] = str(origin_y)
 paramMap['origin_z'] = str(origin_z)
 paramMap['up'] = '0, 1, 0'
 paramMap['sample_count'] = SampleCount
 #
 paramMap['mesh_filename'] = mesh_file
 paramMap['solid_filename'] = '../mesh/static_solids/levelset_solid.ply'
 scene = SceneHandler.loadScene(fileResolver.resolve(xml_name + '.xml'),
                                paramMap)
 #
 # Create a queue for tracking render jobs
 queue = RenderQueue()
 exr_path = img_path + '/' + str(frame) + '_' + xml_name + '.exr'
 scene.setDestinationFile(exr_path)
 #
 # 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()
 #
 # Print some statistics about the rendering process
Esempio n. 19
0
 #
 # Path to density files
 density_file = '../density/' + str(frame) + '_density.vol'
 #
 while (not os.path.exists(density_file)):
     time.sleep(1)
 #
 print 'Starting frame', frame
 #
 # Scene parameters
 paramMap = StringMap()
 paramMap['sample_count'] = SampleCount
 paramMap['volume_scale'] = VolumeScale
 paramMap['density_filename'] = density_file
 #
 scene = SceneHandler.loadScene(fileResolver.resolve("smoke.xml"),
                                paramMap)
 #
 # Create a queue for tracking render jobs
 queue = RenderQueue()
 scene.setDestinationFile(img_path + '/' + str(frame) + '_density.exr')
 #
 # 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()
 #
 # Print some statistics about the rendering process
 print(Statistics.getInstance().getStats())
Esempio n. 20
0
	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()
Esempio n. 21
0
    def forest_generate_according_tree_pos_file(config_file_path,
                                                forest_file_name,
                                                linestart,
                                                lineend,
                                                forest_prifix=""):
        import mitsuba
        from mitsuba.core import Vector, Point, Ray, Thread
        from mitsuba.render import SceneHandler
        from mitsuba.render import RenderQueue, RenderJob
        from mitsuba.render import Scene
        from mitsuba.render import Intersection

        f = open(config_file_path, 'r')
        cfg = json.load(f)
        tree_pos = combine_file_path(session.get_input_dir(),
                                     cfg["scene"]["forest"]["tree_pos_file"])
        if cfg["scene"]["forest"]["tree_pos_file"] == "" or (
                not os.path.exists(tree_pos)):
            return
        # 保存场景中树的位置 forest*.xml
        # f = open(os.path.join(session.get_scenefile_path(),forest_file_name),'w')
        f = codecs.open(
            os.path.join(session.get_scenefile_path(), forest_file_name), "w",
            "utf-8-sig")
        doc = minidom.Document()
        root = doc.createElement("scene")
        doc.appendChild(root)
        root.setAttribute("version", "0.5.0")

        #读取地形数据 计算每个树的高程
        if cfg["scene"]["terrain"]["terrain_type"] != "PLANE" and cfg["scene"][
                "terrain"]["terrain_type"] == "RASTER":
            demfile = combine_file_path(session.get_input_dir(),
                                        cfg["scene"]["terrain"]["terr_file"])
            img_w, img_h, dem_arr = RasterHelper.read_dem_as_array(demfile)
            dem_arr = dem_arr - dem_arr.min()

        #读取object boundingbox 数据
        bound_path = os.path.join(session.get_input_dir(),
                                  obj_bounding_box_file)
        if os.path.exists(bound_path):
            fobj = open(bound_path)
            bound_dict = dict()
            for line in fobj:
                arr = line.split(":")
                objName = arr[0]
                arr = list(map(lambda x: float(x), arr[1].split(" ")))
                bound_dict[objName] = [
                    arr[3] - arr[0], arr[4] - arr[1], arr[5] - arr[2]
                ]

        scenepath = session.get_scenefile_path()
        # if "Windows" in platform.system():
        #     scenepath = str(scenepath.replace('\\', '\\\\'))
        #得到高程信息 通过光线跟踪的方法精确得到高程信息
        fileResolver = Thread.getThread().getFileResolver()
        logger = Thread.getThread().getLogger()
        logger.clearAppenders()
        fileResolver.appendPath(str(scenepath))
        # 由于batch模式不会改变地形几何结构,因此在用地形打点计算树木的高程时,用第一个terrain文件即可,所以加上了_0_
        # if(forest_prifix != ""):
        #     forest_prifix = forest_prifix[0:len(forest_prifix)-1] +"_0_"
        scene = SceneHandler.loadScene(
            fileResolver.resolve(str(forest_prifix + terr_scene_file)))
        # scene = SceneHandler.loadScene(fileResolver.resolve(r"E:\Research\20-LESS\RealScene\SimProj\calLAI\Parameters\_scenefile\terrain1.xml"))
        scene.configure()
        scene.initialize()
        tf = open(tree_pos)

        hidden_objects = SceneGenerate.get_hidded_objects()

        #创建一个虚拟根节点,最后再删除
        treeIdx = 0
        for line in tf:
            if treeIdx >= linestart and treeIdx <= lineend:
                arr = line.replace("\n", "").strip().split(" ")
                objectName = arr[0]
                if objectName in hidden_objects:
                    continue

                shapenode = doc.createElement("shape")
                root.appendChild(shapenode)
                shapenode.setAttribute("type", "instance")
                refnode = doc.createElement("ref")
                shapenode.appendChild(refnode)
                refnode.setAttribute("id", objectName)
                trnode = doc.createElement("transform")
                shapenode.appendChild(trnode)
                trnode.setAttribute("name", "toWorld")
                if len(arr) == 6:  # fit with
                    scale_node = doc.createElement("scale")
                    trnode.appendChild(scale_node)
                    scale_node.setAttribute(
                        "x", str(float(arr[4]) / bound_dict[objectName][0]))
                    scale_node.setAttribute(
                        "z", str(float(arr[4]) / bound_dict[objectName][0]))
                    scale_node.setAttribute(
                        "y", str(float(arr[5]) / bound_dict[objectName][1]))

                if len(arr) == 5:  # for rotation of the tree
                    angle = arr[len(arr) - 1]
                    rotatenode = doc.createElement("rotate")
                    trnode.appendChild(rotatenode)
                    rotatenode.setAttribute("y", '1')
                    rotatenode.setAttribute("angle", angle)
                translatenode = doc.createElement("translate")
                trnode.appendChild(translatenode)
                x = float(arr[1])
                y = float(arr[2])
                z = float(arr[3])
                xScale = cfg["scene"]["terrain"]["extent_width"]
                zScale = cfg["scene"]["terrain"]["extent_height"]
                # treeX = xScale - x * (2 * xScale) / float(img_w)
                # treeZ = zScale - y * (2 * zScale) / float(img_h)
                treeX = 0.5 * xScale - x
                treeZ = 0.5 * zScale - y
                translatenode.setAttribute("x", str(treeX))
                translatenode.setAttribute("z", str(treeZ))
                if cfg["scene"]["terrain"]["terrain_type"] != "PLANE":
                    ray = Ray()
                    ray.setOrigin(Point(treeX, 9999, treeZ))
                    ray.setDirection(Vector(0, -1, 0))
                    its = scene.rayIntersect(ray)
                    if not its is None:
                        translatenode.setAttribute("y", str(its.p[1] + z))
                        # translatenode.setAttribute("y", str(z))
                    else:
                        # log("warning: precise height not found.")
                        if cfg["scene"]["terrain"]["terrain_type"] == "RASTER":
                            im_r = int((y / float(zScale)) * img_h)
                            im_c = int((x / float(xScale)) * img_w)
                            if im_r >= img_h:
                                im_r = img_h - 1
                            if im_c >= img_w:
                                im_c = img_w - 1

                            translatenode.setAttribute(
                                "y", str(dem_arr[im_r][im_c] + z))
                        else:
                            translatenode.setAttribute("y", str(z))
                else:
                    translatenode.setAttribute("y", str(z))

            treeIdx += 1

        xm = doc.toprettyxml()
        # xm = xm.replace('<?xml version="1.0" ?>', '')
        f.write(xm)
        f.close()

        log("INFO: Objects and positions generated.")
Esempio n. 22
0
def main(argv):
    scene_xml_name = ''
    camera_txt_name = ''
    output_folder = ''
    camera_indicate_name = ''

    # Read command line args
    opts, args = getopt.getopt(argv, "s:c:o:h:g:")
    for opt, arg in opts:
        if opt == '-h':
            print 'mitsuba_render.py -s <scene_xml> -c <camera_file> -g <good_camera_indicator_file> -o <output_directory>'
            sys.exit()
        elif opt in ("-s", "--scenefile"):
            scene_xml_name = arg
        elif opt in ("-c", "--camerafile"):
            camera_txt_name = arg
        elif opt in ("-o", "--outputdir"):
            output_folder = arg
        elif opt in ("-g", "--goodcamerafile"):
            camera_indicate_name = arg

    print('Render job for %s starts...\n' % scene_xml_name)

    if not os.path.exists(output_folder):
        os.makedirs(output_folder)
    camera = np.loadtxt(camera_txt_name)
    goodcam = np.loadtxt(camera_indicate_name)

    last_dest = output_folder + '%06i_mlt.png' % (len(camera) - 1)
    if os.path.isfile(last_dest):
        print('Job is done in the first round.\n')
        return

    tmp = scene_xml_name.split('/')
    work_path = '/'.join(tmp[0:-1])

    os.chdir(work_path)

    paramMap = StringMap()
    paramMap['emitter_scale'] = '75'
    paramMap['fov'] = '63.414969'
    paramMap['origin'] = '0 0 0'
    paramMap['target'] = '1 1 1'
    paramMap['up'] = '1 0 0'
    paramMap['sampler'] = '1024'
    paramMap['width'] = '640'
    paramMap['height'] = '480'
    paramMap['envmap_path'] = './util_data/HDR_111_Parking_Lot_2_Ref.hdr'
    paramMap['default_texture_path'] = './util_data/wallp_0.jpg'

    fileResolver = Thread.getThread().getFileResolver()
    scene = SceneHandler.loadScene(fileResolver.resolve(scene_xml_name),
                                   paramMap)

    scheduler = Scheduler.getInstance()
    # 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()

    from mitsuba.render import Scene
    sensor = scene.getSensor()
    scene.initialize()

    for i in range(0, len(camera)):
        if goodcam[i] < 0.5:
            continue

        destination = output_folder + '%06i_mlt' % i
        if os.path.isfile(destination + '.rgbe'):
            continue

        c = camera[i]
        t = Transform.lookAt(Point(c[0], c[1], c[2]),
                             Point(c[0] + c[3], c[1] + c[4], c[2] + c[5]),
                             Vector(c[6], c[7], c[8]))
        sensor.setWorldTransform(t)
        scene.setDestinationFile(destination)

        # # 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(i), scene, queue)
        job.start()
        queue.waitLeft(0)

    print('%d render jobs finished!\n' % len(camera))
Esempio n. 23
0
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")