def generate_xml_dict(self):
''' Get the mujoco header XML dict. It contains compiler, size and option nodes. '''
compiler = OrderedDict()
compiler['@angle'] = 'radian'
compiler['@coordinate'] = 'local'
compiler['@meshdir'] = worldgen_path('assets/stls')
compiler['@texturedir'] = worldgen_path('assets/textures')
option = OrderedDict()
option["flag"] = OrderedDict([("@warmstart", "enable")])
return OrderedDict([('compiler', compiler), ('option', option)])
def make_shape(name, points):
''' Make the STL and XML, and save both to the proper directories. '''
# Make the STL and XML
shape, size = build_stl(name, points)
xml_dict = build_xml(name, size)
# Make the directory to save files to if we have to
xml_dirname = worldgen_path('assets', 'xmls', 'shapes', name)
stl_dirname = worldgen_path('assets', 'stls', 'shapes', name)
os.makedirs(xml_dirname, exist_ok=True)
os.makedirs(stl_dirname, exist_ok=True)
# Save the STL and XML to our new directories
shape.save(os.path.join(stl_dirname, name + '.stl'))
with open(os.path.join(xml_dirname, 'main.xml'), 'w') as f:
f.write(xmltodict.unparse(xml_dict, pretty=True))
def set_absolute_paths(xml_dict, root_xml_path):
dirnames = ["@meshdir", "@texturedir"]
if "compiler" in xml_dict:
for drname in dirnames:
if drname in xml_dict["compiler"]:
asset_dir = worldgen_path('assets') + '/'
path = xml_dict["compiler"][drname]
if path[0] != "/":
relative_path = os.path.dirname(root_xml_path) + "/" + path
xml_dict["compiler"][drname] = os.path.abspath(
relative_path)
elif path.find(asset_dir) > -1:
xml_dict["compiler"][drname] = worldgen_path(
'assets',
path.split(asset_dir)[-1])
def generate(self, random_state, world_params, placement_size):
if os.path.exists(self.path):
self.local_path = self.path
else:
self.local_path = worldgen_path("assets/stls", self.path)
if not isinstance(self.local_path, list):
self.local_path = [self.local_path]
self.objs = []
max_ = np.zeros(3) - np.inf
min_ = np.zeros(3) + np.inf
for path in self.local_path:
obj = stl.mesh.Mesh.from_file(path)
for i in range(3):
max_[i] = max(max_[i], obj.max_[i])
min_[i] = min(min_[i], obj.min_[i])
self.objs.append(obj)
self.placements = OrderedDict()
self.size = max_ - min_
self.min_ = min_
def main(argv):
'''
examine.py is used to display environments
Example uses:
bin/examine.py simple_particle
bin/examine.py examples/particle_gather.py
bin/examine.py particle_gather n_food=5 floorsize=5
bin/examine.py example_env_examine.jsonnet
'''
env_names, env_kwargs = parse_arguments(argv)
assert len(
env_names) == 1, 'You must provide exactly 1 environment to examine.'
env_name = env_names[0]
examine_env(env_name,
env_kwargs,
core_dir=worldgen_path(),
envs_dir='examples',
xmls_dir='xmls',
env_viewer=EnvViewer)
print(main.__doc__)
def _get_xml_dir_path(self, *args):
'''
If you want to use custom XMLs, subclass this class and overwrite this
method to return the path to your 'xmls' folder
'''
return worldgen_path('assets/xmls', *args)
def load_env(pattern,
core_dir=worldgen_path(),
envs_dir='examples',
xmls_dir='xmls',
return_args_remaining=False,
**kwargs):
"""
Flexible load of an environment based on `pattern`.
Passes args to make_env().
:param pattern: tries to match environment to the pattern.
:param core_dir: Absolute path to the core code directory for the project containing
the environments we want to examine. This is usually the top-level git repository
folder - in the case of the mujoco-worldgen repo, it would be the 'mujoco-worldgen'
folder.
:param envs_dir: relative path (from core_dir) to folder containing all environment files.
:param xmls_dir: relative path (from core_dir) to folder containing all xml files.
:param return_remaining_kwargs: returns arguments from kwargs that are not used.
:param kwargs: arguments passed to the environment function.
:return: mujoco_worldgen.Env
"""
# Loads environment based on XML.
env = None
args_remaining = {}
if pattern.endswith(".xml"):
if len(kwargs) > 0:
print("Not passing any argument to environment, "
"because environment is loaded from XML. XML doesn't "
"accept any extra input arguments")
def get_sim(seed):
model = load_model_from_path_fix_paths(xml_path=pattern)
return MjSim(model)
env = Env(get_sim=get_sim)
# Loads environment based on mjb.
elif pattern.endswith(".mjb"):
if len(kwargs) != 0:
print("Not passing any argument to environment, "
"because environment is loaded from MJB. MJB doesn't "
"accept any extra input arguments")
def get_sim(seed):
model = load_model_from_mjb(pattern)
return MjSim(model)
env = Env(get_sim=get_sim)
# Loads environment from a python file
elif pattern.endswith("py") and os.path.exists(pattern):
print("Loading env from the module: %s" % pattern)
module = run_path(pattern)
make_env = module["make_env"]
args_to_pass, args_remaining = extract_matching_arguments(
make_env, kwargs)
env = make_env(**args_to_pass)
elif pattern.endswith(".jsonnet") and os.path.exists(pattern):
env_data = json.loads(_jsonnet.evaluate_file(pattern))
make_env = get_function(env_data['make_env'])
args_to_pass, args_remaining = extract_matching_arguments(
make_env, kwargs)
env = make_env(**args_to_pass)
else:
# If couldn't load based on easy search, then look
# into predefined subdirectories.
matching = (
glob(join(core_dir, envs_dir, "**", "*.py"), recursive=True) +
glob(join(core_dir, xmls_dir, "**", "*.xml"), recursive=True))
matching = [match for match in matching if match.find(pattern) > -1]
matching = [
match for match in matching
if not os.path.basename(match).startswith('test_')
]
assert len(
matching
) < 2, "Found multiple environments matching %s" % str(matching)
if len(matching) == 1:
return load_env(matching[0],
return_args_remaining=return_args_remaining,
**kwargs)
if return_args_remaining:
return env, args_remaining
else:
return env