def test_import_igsdf(scene_name, scene_source):
hdr_texture = os.path.join(
gibson2.ig_dataset_path, 'scenes', 'background', 'probe_02.hdr')
hdr_texture2 = os.path.join(
gibson2.ig_dataset_path, 'scenes', 'background', 'probe_03.hdr')
if scene_source == "IG":
scene_dir = get_ig_scene_path(scene_name)
elif scene_source == "CUBICASA":
scene_dir = get_cubicasa_scene_path(scene_name)
else:
scene_dir = get_3dfront_scene_path(scene_name)
light_modulation_map_filename = os.path.join(
scene_dir, 'layout', 'floor_lighttype_0.png')
background_texture = os.path.join(
gibson2.ig_dataset_path, 'scenes', 'background',
'urban_street_01.jpg')
scene = InteractiveIndoorScene(
scene_name,
texture_randomization=False,
object_randomization=False,
scene_source=scene_source)
settings = MeshRendererSettings(env_texture_filename=hdr_texture,
env_texture_filename2=hdr_texture2,
env_texture_filename3=background_texture,
light_modulation_map_filename=light_modulation_map_filename,
enable_shadow=True, msaa=True,
light_dimming_factor=1.0)
s = Simulator(mode='iggui', image_width=960,
image_height=720, device_idx=0, rendering_settings=settings)
s.import_ig_scene(scene)
fpss = []
np.random.seed(0)
_,(px,py,pz) = scene.get_random_point()
s.viewer.px = px
s.viewer.py = py
s.viewer.pz = 1.7
s.viewer.update()
for i in range(3000):
if i == 2500:
logId = p.startStateLogging(loggingType=p.STATE_LOGGING_PROFILE_TIMINGS, fileName='trace_beechwood')
start = time.time()
s.step()
end = time.time()
print("Elapsed time: ", end - start)
print("Frequency: ", 1 / (end - start))
fpss.append(1 / (end - start))
p.stopStateLogging(logId)
s.disconnect()
print("end")
plt.plot(fpss)
plt.show()
def generate_trav_map(scene_name, scene_source, load_full_scene=True):
if scene_source not in SCENE_SOURCE:
raise ValueError('Unsupported scene source: {}'.format(scene_source))
if scene_source == "IG":
scene_dir = get_ig_scene_path(scene_name)
elif scene_source == "CUBICASA":
scene_dir = get_cubicasa_scene_path(scene_name)
else:
scene_dir = get_3dfront_scene_path(scene_name)
random.seed(0)
scene = InteractiveIndoorScene(scene_name,
build_graph=False,
texture_randomization=False,
scene_source=scene_source)
if not load_full_scene:
scene._set_first_n_objects(3)
s = Simulator(mode='headless',
image_width=512,
image_height=512,
device_idx=0)
s.import_ig_scene(scene)
if load_full_scene:
scene.open_all_doors()
for i in range(20):
s.step()
vertices_info, faces_info = s.renderer.dump()
s.disconnect()
if load_full_scene:
trav_map_filename_format = 'floor_trav_{}.png'
obstacle_map_filename_format = 'floor_{}.png'
else:
trav_map_filename_format = 'floor_trav_no_obj_{}.png'
obstacle_map_filename_format = 'floor_no_obj_{}.png'
gen_trav_map(vertices_info,
faces_info,
output_folder=os.path.join(scene_dir, 'layout'),
trav_map_filename_format=trav_map_filename_format,
obstacle_map_filename_format=obstacle_map_filename_format)
def __init__(self,
scene_id,
trav_map_resolution=0.1,
trav_map_erosion=2,
trav_map_type='with_obj',
build_graph=True,
num_waypoints=10,
waypoint_resolution=0.2,
pybullet_load_texture=False,
texture_randomization=False,
link_collision_tolerance=0.03,
object_randomization=False,
object_randomization_idx=None,
should_open_all_doors=False,
load_object_categories=None,
load_room_types=None,
load_room_instances=None,
seg_map_resolution=0.1,
scene_source="IG",
):
"""
:param scene_id: Scene id
:param trav_map_resolution: traversability map resolution
:param trav_map_erosion: erosion radius of traversability areas, should be robot footprint radius
:param trav_map_type: type of traversability map, with_obj | no_obj
:param build_graph: build connectivity graph
:param num_waypoints: number of way points returned
:param waypoint_resolution: resolution of adjacent way points
:param pybullet_load_texture: whether to load texture into pybullet. This is for debugging purpose only and does not affect robot's observations
:param texture_randomization: whether to randomize material/texture
:param link_collision_tolerance: tolerance of the percentage of links that cannot be fully extended after object randomization
:param object_randomization: whether to randomize object
:param object_randomization_idx: index of a pre-computed object randomization model that guarantees good scene quality
:param should_open_all_doors: whether to open all doors after episode reset (usually required for navigation tasks)
:param load_object_categories: only load these object categories into the scene (a list of str)
:param load_room_types: only load objects in these room types into the scene (a list of str)
:param load_room_instances: only load objects in these room instances into the scene (a list of str)
:param seg_map_resolution: room segmentation map resolution
:param scene_source: source of scene data; among IG, CUBICASA, THREEDFRONT
"""
super().__init__(
scene_id,
trav_map_resolution,
trav_map_erosion,
trav_map_type,
build_graph,
num_waypoints,
waypoint_resolution,
pybullet_load_texture,
)
self.texture_randomization = texture_randomization
self.object_randomization = object_randomization
self.should_open_all_doors = should_open_all_doors
if object_randomization:
if object_randomization_idx is None:
fname = scene_id
else:
fname = '{}_random_{}'.format(scene_id,
object_randomization_idx)
else:
fname = '{}_best'.format(scene_id)
if scene_source not in SCENE_SOURCE:
raise ValueError(
'Unsupported scene source: {}'.format(scene_source))
if scene_source == "IG":
scene_dir = get_ig_scene_path(scene_id)
elif scene_source == "CUBICASA":
scene_dir = get_cubicasa_scene_path(scene_id)
else:
scene_dir = get_3dfront_scene_path(scene_id)
self.scene_source = scene_source
self.scene_dir = scene_dir
self.scene_file = os.path.join(
scene_dir, "urdf", "{}.urdf".format(fname))
self.scene_tree = ET.parse(self.scene_file)
self.first_n_objects = np.inf
self.random_groups = {}
self.objects_by_category = {}
self.objects_by_name = {}
self.objects_by_id = {}
self.category_ids = get_ig_category_ids()
# Current time string to use to save the temporal urdfs
timestr = time.strftime("%Y%m%d-%H%M%S")
# Create the subfolder
self.scene_instance_folder = os.path.join(
gibson2.ig_dataset_path, "scene_instances",
'{}_{}_{}'.format(timestr, random.getrandbits(64), os.getpid()))
os.makedirs(self.scene_instance_folder, exist_ok=True)
# Load room semantic and instance segmentation map
self.load_room_sem_ins_seg_map(seg_map_resolution)
# Decide which room(s) and object categories to load
self.filter_rooms_and_object_categories(
load_object_categories, load_room_types, load_room_instances)
# Load average object density if exists
self.avg_obj_dims = self.load_avg_obj_dims()
# load overlapping bboxes in scene annotation
self.overlapped_bboxes = self.load_overlapped_bboxes()
# percentage of objects allowed that CANNOT extend their joints by >66%
self.link_collision_tolerance = link_collision_tolerance
# Parse all the special link entries in the root URDF that defines the scene
for link in self.scene_tree.findall('link'):
if 'category' in link.attrib:
# Extract category and model from the link entry
category = link.attrib["category"]
model = link.attrib["model"]
# An object can in multiple rooms, seperated by commas,
# or None if the object is one of the walls, floors or ceilings
in_rooms = link.attrib.get('room', None)
if in_rooms is not None:
in_rooms = in_rooms.split(',')
# Find the urdf file that defines this object
if category in ["walls", "floors", "ceilings"]:
model_path = self.scene_dir
filename = os.path.join(
model_path, "urdf", model + "_" + category + ".urdf")
# For other objects
else:
# This object does not belong to one of the selected object categories, skip
if self.load_object_categories is not None and \
category not in self.load_object_categories:
continue
# This object is not located in one of the selected rooms, skip
if self.load_room_instances is not None and \
len(set(self.load_room_instances) & set(in_rooms)) == 0:
continue
category_path = get_ig_category_path(category)
assert len(os.listdir(category_path)) != 0, \
"There are no models in category folder {}".format(
category_path)
if model == 'random':
# Using random group to assign the same model to a group of objects
# E.g. we want to use the same model for a group of chairs around the same dining table
if "random_group" in link.attrib:
# random_group is a unique integer within the category
random_group = link.attrib["random_group"]
random_group_key = (category, random_group)
# if the model of this random group has already been selected
# use that model.
if random_group_key in self.random_groups:
model = self.random_groups[random_group_key]
# otherwise, this is the first instance of this random group
# select a random model and cache it
else:
model = random.choice(
os.listdir(category_path))
self.random_groups[random_group_key] = model
else:
# Using a random instance
model = random.choice(os.listdir(category_path))
else:
model = link.attrib['model']
model_path = get_ig_model_path(category, model)
filename = os.path.join(model_path, model + ".urdf")
if "bounding_box" in link.keys() and "scale" in link.keys():
logging.error(
"You cannot define both scale and bounding box size to embed a URDF")
exit(-1)
bounding_box = None
scale = None
if "bounding_box" in link.keys():
bounding_box = np.array(
[float(val) for val in link.attrib["bounding_box"].split(" ")])
elif "scale" in link.keys():
scale = np.array([float(val)
for val in link.attrib["scale"].split(" ")])
else:
scale = np.array([1., 1., 1.])
object_name = link.attrib['name']
# The joint location is given wrt the bounding box center but we need it wrt to the base_link frame
joint_connecting_embedded_link = \
[joint for joint in self.scene_tree.findall("joint")
if joint.find("child").attrib["link"]
== object_name][0]
joint_xyz = np.array([float(val) for val in joint_connecting_embedded_link.find(
"origin").attrib["xyz"].split(" ")])
joint_type = joint_connecting_embedded_link.attrib['type']
if 'rpy' in joint_connecting_embedded_link.find("origin").attrib:
joint_rpy = \
np.array([float(val) for val in
joint_connecting_embedded_link.find("origin").attrib["rpy"].split(" ")])
else:
joint_rpy = np.array([0., 0., 0.])
joint_name = joint_connecting_embedded_link.attrib['name']
joint_parent = joint_connecting_embedded_link.find(
"parent").attrib["link"]
self.add_object(category,
model=model,
model_path=model_path,
filename=filename,
bounding_box=bounding_box,
scale=scale,
object_name=object_name,
joint_type=joint_type,
position=joint_xyz,
orientation_rpy=joint_rpy,
joint_name=joint_name,
joint_parent=joint_parent,
in_rooms=in_rooms)
elif link.attrib["name"] != "world":
logging.error(
"iGSDF should only contain links that represent embedded URDF objects")
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--scene',
type=str,
help='Name of the scene in the iG Dataset')
parser.add_argument('--save_dir',
type=str,
help='Directory to save the frames.',
default='misc')
parser.add_argument('--seed', type=int, default=15, help='Random seed.')
parser.add_argument('--domain_rand',
dest='domain_rand',
action='store_true')
parser.add_argument('--domain_rand_interval',
dest='domain_rand_interval',
type=int,
default=50)
parser.add_argument('--object_rand',
dest='object_rand',
action='store_true')
args = parser.parse_args()
# hdr_texture1 = os.path.join(
# gibson2.ig_dataset_path, 'scenes', 'background', 'photo_studio_01_2k.hdr')
hdr_texture1 = os.path.join(gibson2.ig_dataset_path, 'scenes',
'background', 'probe_03.hdr')
hdr_texture2 = os.path.join(gibson2.ig_dataset_path, 'scenes',
'background', 'probe_02.hdr')
light_map = os.path.join(get_ig_scene_path(args.scene), 'layout',
'floor_lighttype_0.png')
background_texture = os.path.join(gibson2.ig_dataset_path, 'scenes',
'background', 'urban_street_01.jpg')
settings = MeshRendererSettings(env_texture_filename=hdr_texture1,
env_texture_filename2=hdr_texture2,
env_texture_filename3=background_texture,
light_modulation_map_filename=light_map,
enable_shadow=True,
msaa=True,
skybox_size=36.,
light_dimming_factor=0.8)
s = Simulator(mode='headless',
image_width=1080,
image_height=720,
vertical_fov=60,
rendering_settings=settings)
random.seed(args.seed)
scene = InteractiveIndoorScene(args.scene,
texture_randomization=args.domain_rand,
object_randomization=args.object_rand)
s.import_ig_scene(scene)
traj_path = os.path.join(get_ig_scene_path(args.scene), 'misc',
'tour_cam_trajectory.txt')
save_dir = os.path.join(get_ig_scene_path(args.scene), args.save_dir)
os.makedirs(save_dir, exist_ok=True)
tmp_dir = os.path.join(save_dir, 'tmp')
os.makedirs(tmp_dir, exist_ok=True)
with open(traj_path, 'r') as fp:
points = [l.rstrip().split(',') for l in fp.readlines()]
for _ in range(60):
s.step()
s.sync()
for i in range(len(points)):
if args.domain_rand and i % args.domain_rand_interval == 0:
scene.randomize_texture()
x, y, dir_x, dir_y = [float(p) for p in points[i]]
z = 1.7
tar_x = x + dir_x
tar_y = y + dir_y
tar_z = 1.4
# cam_loc = np.array([x, y, z])
s.renderer.set_camera([x, y, z], [tar_x, tar_y, tar_z], [0, 0, 1])
with Profiler('Render'):
frame = s.renderer.render(modes=('rgb'))
img = Image.fromarray(
(255 * np.concatenate(frame, axis=1)[:, :, :3]).astype(np.uint8))
img.save(os.path.join(tmp_dir, '{:05d}.png'.format(i)))
cmd = 'ffmpeg -i {t}/%5d.png -y -an -c:v libx264 -crf 18 -preset veryslow -r 30 {s}/tour.mp4'.format(
t=tmp_dir, s=save_dir)
subprocess.call(cmd, shell=True)
cmd = 'rm -r {}'.format(tmp_dir)
subprocess.call(cmd, shell=True)
s.disconnect()