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