def __init__(self, headless, run_sim, filepath, blender_path, port=None):
self.blender_path = blender_path
self.filepath = filepath
if run_sim:
if port is None:
self.port = random.randint(10000, 31900)
else:
self.port = port
print("Starting up simu...")
fp = cutil.findFile("run_sim.py",
os.path.dirname(os.path.realpath(__file__)))
cmd = [blender_path]
if headless:
cmd.append("--background")
cmd.append("--python")
cmd.append(fp)
cmd.append("--")
if not headless:
cmd.append("--threaded")
cmd.append("--port")
cmd.append(str(self.port))
print("Starting blender with the following command:")
print(' '.join(cmd))
self.p = subprocess.Popen(cmd)
print("Sim running.")
else:
self.p = None
self.port = settings.TCP_PORT
self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.connected = False
start = cutil.get_time_ms()
while True:
try:
self.s.connect((settings.TCP_IP, self.port))
self.connected = True
break
except socket.error:
time.sleep(0.1)
# if cutil.get_time_ms() - start > 5000:
# raise Exception("Timed out trying to connect to simulator. Are you sure it's running?")
print("Took " + str(cutil.get_time_ms() - start) +
"ms to connect to the simulator.")
self.s.settimeout(settings.CMD_RESPONSE_TIMEOUT)
if filepath is not None:
self.loadScene(filepath)
else:
self.unlinkObject("Cube")
self.unlinkObject("Lamp")
def construct_job(render):
job = {}
job['code_dir'] = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'simulator')
job['exec'] = 'simulate_pouring.py'
job['args'] = [x.strip() for x in render[1].split()]
job['dep_dirs'] = [
cutil.findFile("fluid_sim_deps",
cutil.file_dirnames(os.path.abspath(__file__))[-2]),
cutil.__path__[0]
]
job['dep_env_vars'] = ['PYTHONPATH', 'BLENDERPATH']
job['input_dir'] = os.path.join(INPUT_DATA_DIR, render[0].split('/')[0])
job['output_dir'] = os.path.join(OUTPUT_DATA_DIR, render[0])
return job
def init():
ret = Queue.Queue()
for name, args in JOBS:
job = {}
job['code_dir'] = os.path.join(
os.path.dirname(os.path.abspath(__file__)), 'simulator')
job['exec'] = 'simulate_pouring.py'
job['args'] = ['--bake'] + [x.strip() for x in args.split()]
job['dep_dirs'] = [
cutil.findFile("fluid_sim_deps",
cutil.file_dirnames(os.path.abspath(__file__))[-2]),
cutil.__path__[0]
]
job['dep_env_vars'] = ['PYTHONPATH', 'BLENDERPATH']
job['output_dir'] = os.path.join(DATA_DIR, name)
print("FOUND JOB:" + str(job))
ret.put(job)
return ret
def main():
blend_file = "/media/robolab/arthus/fluid_sim_output/scene18/scene.blend"
env = TableEnvironment(filepath=blend_file,
blender_path=os.path.join(
cutil.findFile(
"blender-2.69",
os.path.join(os.path.expanduser("~"),
"proj")), "blender"),
pouring_object="bottle")
#env = AlternateBowlTableEnvironment(blender_path=os.path.join(cutil.findFile("blender-2.69", os.path.expanduser("~")), "blender"), pouring_object="cup", alternate_bowl="cup")
#env.sim.renderStillImage("/home/robolab/temp/test.png")
#env.setCameraAngle(-3.0*math.pi/4.0)
#env.addBackgroundVideo('/home/robolab/temp/oni2avi/test-img.avi', 0.0)
#env.setDuration(1.0)
# env.fillCup(0.6)
# t = 0.0
# while t <= 3.0:
# env.setCupAngle(t/3.0*math.pi, t)
# t += 0.1
#env.setCupAngle(0.0, 0.0)
#env.setCupAngle(math.pi/2.0, 3.0)
#env.sim.hideObject("FluidDomain")
env.replaceCupForRender("bottle", glass=True, surface_subsample=True)
env.setLighting()
#env.generateOutput(render_path="/home/robolab/temp/render", bake_path=os.path.join(os.path.dirname(blend_file), "bake_files"), render=True, bake=False, dry_run=False, data_prefix=None)
# env.sim.addCube("Inflow", (0,0,TableEnvironment.DOMAIN_HEIGHT - 1), (1,1,1))
# env.sim.addAsFluidObj("Inflow")
# env.sim.setFluidModType("Inflow", FluidSim.FLUID_FLUID)
# env.sim.setVolumeInitialization("Inflow", True, True)
# env.sim.bakeFluidAnimations()
# #cutil.keyboard()
env.sim.saveScene('/home/robolab/temp/test.blend')
args.render_path = "/dev/null"
else:
args.load = True
args.blend_file = os.path.join(input_dir, 'scene.blend')
args.bake_path = os.path.join(input_dir, 'bake_files')
args.render_path = output_dir
#TODO hack
args.render = True
BLENDERPATHS = [os.path.expanduser('~')]
if 'BLENDERPATH' in os.environ:
BLENDERPATHS += os.environ['BLENDERPATH'].split(':')
for path in BLENDERPATHS:
if not os.path.exists(path):
continue
bp = cutil.findFile("blender-2.69", path)
if bp is not None:
blender_path = os.path.join(bp, "blender")
break
if blender_path is None:
raise Exception("Can't find blender executable!")
env_args = {'blender_path':blender_path, 'pouring_object':args.pouring_object, 'bowl_object':args.bowl_object}
if args.alternate_bowl is not None:
env_args['alternate_bowl'] = args.alternate_bowl
constructor = AlternateBowlTableEnvironment
else:
constructor = TableEnvironment
if args.dry_run:
def generateOutput(self,
render_path,
bake_path,
render=True,
bake=True,
dry_run=False,
data_prefix="data",
gt_prefix="ground_truth",
composite_video_plane=False,
render_water=True):
if bake:
if not dry_run:
self.sim.setFluidResolution(TableEnvironment.FLUID_RESOLUTION)
print("Baking fluid simulation, this may take awhile...")
self.sim.bakeFluidAnimations(filepath=bake_path)
self.sim.smoothObject('FluidDomain')
self.sim.subsurfObject('FluidDomain')
else:
fp = open(os.path.join(bake_path, "bake_file.txt"), "w")
fp.write("test")
fp.close()
if render:
if not dry_run:
self.sim.setCameraResolution(self.RENDER_RES)
self.sim.setFluidCachePath(filepath=bake_path)
render_data = data_prefix is not None
render_gt = gt_prefix is not None
dirpath = tempfile.mkdtemp()
self.sim.saveScene(os.path.join(dirpath, "scene.blend"))
if not render_water:
self.sim.unlinkObject("FluidDomain")
self.sim.reloadScene()
try:
out = None
if render_data:
# First render full scene.
self.sim.renderAnimation(os.path.join(dirpath, "full"),
save_images=True,
make_video=False)
out = imageio.get_writer(os.path.join(
render_path, "%s.avi" % data_prefix),
fps=self.FPS)
if "VideoPlane" in self.sim.getObjects():
fp, offset = self.sim.getVideoTextureSettings(
"VideoPlane")
vp = imageio.get_reader(
cutil.findFile(
fp,
os.path.dirname(
os.path.realpath(__file__))))
i = 0
while i < offset:
vp.get_next_data()
i += 1
else:
vp = None
# Now render black/white scene for getting ground truth of water.
objs_to_render = [("Cup", 0), ("Bowl", 1), ("Table", None)]
if render_water:
objs_to_render.append(("FluidDomain", 2))
self.sim.enableLights(enable=False)
for obj in self.sim.getObjects():
self.sim.removeMaterial(obj)
self.sim.hideObject(obj, hide=True)
self.sim.hideObject("Background", hide=False)
for obj, ch in objs_to_render:
if ch is None:
color = [1.0, 1.0, 1.0]
else:
color = [0.0, 0.0, 0.0]
color[ch] = 1.0
self.sim.setMaterial(obj,
diffuse_color=color,
diffuse_intensity=1.0)
self.sim.setMaterialEmit(obj, 1.0)
self.sim.hideObject(obj, hide=False)
# Render only obj
self.sim.renderAnimation(os.path.join(
dirpath, obj + "_only"),
save_images=True,
make_video=False)
self.sim.removeMaterial(obj)
self.sim.hideObject(obj, hide=True)
# Render one more time to figure out the overlap ordering.
for obj, ch in objs_to_render:
if ch is None:
continue
color = [0.0, 0.0, 0.0]
color[ch] = 1.0
self.sim.setMaterial(obj,
diffuse_color=color,
diffuse_intensity=1.0)
self.sim.setMaterialEmit(obj, 1.0)
self.sim.hideObject(obj, hide=False)
self.sim.renderAnimation(os.path.join(
dirpath, "overlap_ordering"),
save_images=True,
make_video=False)
ii = None
# Now combine the color channels.
pub = cutil.SingleLineUpdater()
ret_all = {}
ret_visible = {}
for i in range(self.sim.getNumberFrames()):
pub.publish("Stitching images %d of %d." %
(i, self.sim.getNumberFrames()))
gt = np.zeros((
self.RENDER_RES[1],
self.RENDER_RES[0],
4,
),
dtype=np.float32)
sim = np.zeros((
self.RENDER_RES[1],
self.RENDER_RES[0],
3,
),
dtype=np.float32)
for obj, ch in objs_to_render:
fp = cutil.find_file_by_index(
os.path.join(dirpath, obj + "_only%0*d.png"),
i)
img = imageio.imread(fp)
if ch is not None:
gt[..., ch] = img[..., ch]
sim += img[..., :3]
# Use the alpha channel to indicate overlap ordering.
fp = cutil.find_file_by_index(
os.path.join(dirpath, "overlap_ordering%0*d.png"),
i)
img = imageio.imread(fp)
for obj, ch in objs_to_render:
if ch is None:
continue
idxs = np.where(img[..., ch] > 128)
gt[idxs +
(-1 * np.ones((idxs[0].shape[0], ), dtype=int),
)] = 255.0 * ch / 2.0
if render_gt:
imageio.imwrite(
os.path.join(render_path,
"%s%04d.png" % (gt_prefix, i)),
gt)
if render_data:
full_img = imageio.imread(
cutil.find_file_by_index(
os.path.join(dirpath, "full%0*d.png"), i))
if vp is not None and composite_video_plane:
pxls = np.where(np.max(sim, axis=2) < 128)
try:
ii = vp.get_next_data()
except:
if ii is None:
raise
full_img[pxls[0], pxls[1], :ii.shape[-1]] = ii[
pxls[0], pxls[1], :]
imageio.imwrite(
os.path.join(render_path,
"%s%04d.png" % (data_prefix, i)),
full_img)
out.append_data(full_img)
# Finally, compute the bounding boxes from the gt.
computeBoundingBoxesInImage(gt, i, ret_all,
ret_visible)
# Write out bounding box files.
BB_FILENAME_ALL = 'bounding_boxes_all.txt'
BB_FILENAME_VISIBLE = 'bounding_boxes_visible.txt'
fp_all = open(os.path.join(render_path, BB_FILENAME_ALL),
'w')
fp_visible = open(
os.path.join(render_path, BB_FILENAME_VISIBLE), 'w')
for ii in sorted(ret_all.keys()):
fp_all.write("(%d, %s)\n" % (ii, str(ret_all[ii])))
fp_visible.write("(%d, %s)\n" %
(ii, str(ret_visible[ii])))
fp_all.close()
fp_visible.close()
if vp is not None:
vp.close()
if out is not None:
out.close()
finally:
# Reset scene
self.sim.loadScene(os.path.join(dirpath, "scene.blend"))
shutil.rmtree(dirpath)
print("Finished rendering.")
else:
fp = open(os.path.join(render_path, "render_file.txt"), "w")
fp.write("test")
fp.close()