def exportSubmechanisms(model, path): """This function exports the submechanisms contained in a robot model. Args: model(dict): The robot model to export path(str): The filepath to export the submechanisms data to Returns: """ log("Phobos Submechanisms export: Creating submechanisms data at " + path, "INFO") for submechanism in model['submechanisms']: root = sUtils.getObjectByProperty('submechanism/name', submechanism['contextual_name']) linkobjs = [root] + root['submechanism/spanningtree'] if 'submechanism/freeloader' in root: linkobjs += root['submechanism/freeloader'] objects = [ o for link in linkobjs for o in link.children if o.phobostype in ['visual', 'collision', 'inertial'] ] + linkobjs model = deriveModelDictionary(root, root['submechanism/name'], objects) jointname = nUtils.getObjectName(root, 'joint') if jointname in model['joints']: del model['joints'][jointname] log('Removed joint which is not part of submodel: ' + jointname, 'DEBUG') exportModel(model, path, ['urdf'])
def exportSubmechanisms(model, path): """This function exports the submechanisms contained in a robot model. Args: model(dict): The robot model to export path(str): The filepath to export the submechanisms data to Returns: """ log("Phobos Submechanisms export: Creating submechanisms data at " + path, "INFO") for submechanism in model['submechanisms']: root = sUtils.getObjectByProperty('submechanism/name', submechanism['contextual_name']) linkobjs = [root] + root['submechanism/spanningtree'] if 'submechanism/freeloader' in root: linkobjs += root['submechanism/freeloader'] objects = [ o for link in linkobjs for o in link.children if o.phobostype in ['visual', 'collision', 'inertial'] ] + linkobjs model = deriveModelDictionary(root, root['submechanism/name'], objects) jointname = nUtils.getObjectName(root, 'joint') if jointname in model['joints']: del model['joints'][jointname] log('Removed joint which is not part of submodel: ' + jointname, 'DEBUG') exportModel(model, path, ['urdf'])
def execute(self, context): # identify all entities' roots in the scene rootobjects = ioUtils.getEntityRoots() if not rootobjects: log("There are no entities to export!", "WARNING") # derive entities and export if necessary modellist = [] for root in rootobjects: log("Adding entity '" + str(root["entity/name"]) + "' to scene.", "INFO") if root["entity/type"] in entity_types: # TODO delete me? # try: if (self.exportModels and 'export' in entity_types[root['entity/type']] and root['modelname'] not in models): modelpath = os.path.join(ioUtils.getExportPath(), self.sceneName, root['modelname']) exportModel(models.deriveModelDictionary(root), modelpath) models.add(root['modelname']) # known entity export entity = entity_types[root["entity/type"]]['derive']( root, os.path.join(ioUtils.getExportPath(), self.sceneName)) # TODO delete me? # except KeyError: # log("Required method ""deriveEntity"" not implemented for type " + entity["entity/type"], "ERROR") # continue # generic entity export else: entity = deriveGenericEntity(root) exportlist.append(entity) return {'FINISHED'}
def execute(self, context): """ Args: context: Returns: """ # identify all entities' roots in the scene rootobjects = ioUtils.getEntityRoots() if not rootobjects: log("There are no entities to export!", "WARNING") # derive entities and export if necessary models = set() for root in entities: log("Adding entity '" + str(root["entity/name"]) + "' to scene.", "INFO") if root["entity/type"] in entity_types: # TODO delete me? # try: if ( self.exportModels and 'export' in entity_types[root['entity/type']] and root['model/name'] not in models ): modelpath = os.path.join( ioUtils.getExportPath(), self.sceneName, root['model/name'] ) exportModel(models.deriveModelDictionary(root), modelpath) models.add(root['model/name']) # known entity export entity = entity_types[root["entity/type"]]['derive']( root, os.path.join(ioUtils.getExportPath(), self.sceneName) ) # TODO delete me? # except KeyError: # log("Required method ""deriveEntity"" not implemented for type " + entity["entity/type"], "ERROR") # continue # generic entity export else: entity = deriveGenericEntity(root) exportlist.append(entity) for scenetype in scene_types: typename = "export_scene_" + scenetype # check if format exists and should be exported if getattr(bpy.context.scene, typename): scene_types[scenetype]['export']( exportlist, os.path.join(ioUtils.getExportPath(), self.sceneName) ) return {'FINISHED'}
def execute(self, context): messages = {} root = sUtils.getRoot(context.selected_objects[0]) model, objectlist = models.deriveModelDictionary(root) vUtils.check_dict(model, defs.definitions['model'], messages) vUtils.checkMessages = messages if len(list( messages.keys())) > 0 else { "NoObject": [] } for entry in messages: log("Errors in object " + entry + ":", 'INFO') for error in messages[entry]: log(error, 'INFO') return {'FINISHED'}
def execute(self, context): roots = ioUtils.getExportModels() if not roots: log("No properly defined models selected or present in scene.", 'ERROR') return {'CANCELLED'} elif not self.exportall: roots = [ root for root in roots if root['modelname'] == self.modelname ] if len(roots) > 1: log( "Ambiguous model definitions: " + self.modelname + " exists " + str(len(roots)) + " times.", "ERROR") return {'CANCELLED'} for root in roots: # setup paths exportpath = ioUtils.getExportPath() if not securepath(exportpath): log("Could not secure path to export to.", "ERROR") continue log("Export path: " + exportpath, "DEBUG") ioUtils.exportModel(models.deriveModelDictionary(root), exportpath) # select all exported models after export is done if ioUtils.getExpSettings().selectedOnly: for root in roots: objectlist = sUtils.getChildren(root, selected_only=True, include_hidden=False) sUtils.selectObjects(objectlist, clear=False) else: bpy.ops.object.select_all(action='DESELECT') for root in roots: sUtils.selectObjects(list([root]), False) bpy.ops.phobos.select_model() # report success to user log("Export successful.", "INFO") return {'FINISHED'}
def exportSubmechanisms(model, path): """This function exports the submechanisms contained in a robot model. Args: model(dict): The robot model to export path(str): The filepath to export the submechanisms data to Returns: """ log("Phobos Submechanisms export: Creating submechanisms data at " + path, "INFO") for submechanism in model['submechanisms']: root = sUtils.getObjectsByProperty('submechanism/name', submechanism['contextual_name']) linkobjs = [ root ] + root['submechanism/freeloader'] + root['submechanism/spanningtree'] objects = [ o for link in linkobjs for o in link.children if o.phobostype in ['visual', 'collision', 'inertial'] ] + linkobjs model = deriveModelDictionary(root, root['submechanism/name'], objects) exportModel(model, path, ['urdf'])
def execute(self, context): """ Args: context: Returns: """ roots = ioUtils.getExportModels() if not roots: log("No properly defined models selected or present in scene.", 'ERROR') return {'CANCELLED'} elif not self.exportall: roots = [ root for root in roots if nUtils.getModelName(root) == self.modelname ] if len(roots) > 1: log( "Ambiguous model definitions: " + self.modelname + " exists " + str(len(roots)) + " times.", "ERROR", ) return {'CANCELLED'} for root in roots: # setup paths exportpath = ioUtils.getExportPath() if not securepath(exportpath): log("Could not secure path to export to.", "ERROR") continue log("Export path: " + exportpath, "DEBUG") ioUtils.exportModel(models.deriveModelDictionary(root), exportpath) # select all exported models after export is done if ioUtils.getExpSettings().selectedOnly: for root in roots: objectlist = sUtils.getChildren(root, selected_only=True, include_hidden=False) sUtils.selectObjects(objectlist, clear=False) else: bpy.ops.object.select_all(action='DESELECT') for root in roots: sUtils.selectObjects(list([root]), False) bpy.ops.phobos.select_model() # TODO: Move mesh export to individual formats? This is practically SMURF # export meshes in selected formats # for meshtype in meshes.mesh_types: # mesh_path = ioUtils.getOutputMeshpath(meshtype) # try: # typename = "export_mesh_" + meshtype # if getattr(bpy.data.worlds[0], typename): # securepath(mesh_path) # for meshname in model['meshes']: # meshes.mesh_types[meshtype]['export'](model['meshes'][meshname], mesh_path) # except KeyError: # log("No export function available for selected mesh function: " + meshtype, # "ERROR", "ExportModelOperator") # print(sys.exc_info()[0]) # TODO: Move texture export to individual formats? This is practically SMURF # export textures # if ioUtils.textureExportEnabled(): # texture_path = '' # for materialname in model['materials']: # mat = model['materials'][materialname] # for texturetype in ['diffuseTexture', 'normalTexture', 'displacementTexture']: # if texturetype in mat: # texpath = os.path.join(os.path.expanduser(bpy.path.abspath('//')), mat[texturetype]) # if os.path.isfile(texpath): # if texture_path == '': # texture_path = securepath(os.path.join(export_path, 'textures')) # log("Exporting textures to " + texture_path, "INFO", "ExportModelOperator") # try: # shutil.copy(texpath, os.path.join(texture_path, os.path.basename(mat[texturetype]))) # except shutil.SameFileError: # log("{} already in place".format(texturetype), "INFO", "ExportModelOperator") # report success to user log("Export successful.", "INFO", end="\n\n") return {'FINISHED'}
def execute(self, context): """ Args: context: Returns: """ roots = ioUtils.getExportModels() if not roots: log("No properly defined models selected or present in scene.", 'ERROR') return {'CANCELLED'} elif not self.exportall: roots = [root for root in roots if nUtils.getModelName(root) == self.modelname] if len(roots) > 1: log( "Ambiguous model definitions: " + self.modelname + " exists " + str(len(roots)) + " times.", "ERROR", ) return {'CANCELLED'} for root in roots: # setup paths exportpath = ioUtils.getExportPath() if not securepath(exportpath): log("Could not secure path to export to.", "ERROR") continue log("Export path: " + exportpath, "DEBUG") ioUtils.exportModel(models.deriveModelDictionary(root), exportpath) # select all exported models after export is done if ioUtils.getExpSettings().selectedOnly: for root in roots: objectlist = sUtils.getChildren(root, selected_only=True, include_hidden=False) sUtils.selectObjects(objectlist, clear=False) else: bpy.ops.object.select_all(action='DESELECT') for root in roots: sUtils.selectObjects(list([root]), False) bpy.ops.phobos.select_model() # TODO: Move mesh export to individual formats? This is practically SMURF # export meshes in selected formats # for meshtype in meshes.mesh_types: # mesh_path = ioUtils.getOutputMeshpath(meshtype) # try: # typename = "export_mesh_" + meshtype # if getattr(bpy.data.worlds[0], typename): # securepath(mesh_path) # for meshname in model['meshes']: # meshes.mesh_types[meshtype]['export'](model['meshes'][meshname], mesh_path) # except KeyError: # log("No export function available for selected mesh function: " + meshtype, # "ERROR", "ExportModelOperator") # print(sys.exc_info()[0]) # TODO: Move texture export to individual formats? This is practically SMURF # export textures # if ioUtils.textureExportEnabled(): # texture_path = '' # for materialname in model['materials']: # mat = model['materials'][materialname] # for texturetype in ['diffuseTexture', 'normalTexture', 'displacementTexture']: # if texturetype in mat: # texpath = os.path.join(os.path.expanduser(bpy.path.abspath('//')), mat[texturetype]) # if os.path.isfile(texpath): # if texture_path == '': # texture_path = securepath(os.path.join(export_path, 'textures')) # log("Exporting textures to " + texture_path, "INFO", "ExportModelOperator") # try: # shutil.copy(texpath, os.path.join(texture_path, os.path.basename(mat[texturetype]))) # except shutil.SameFileError: # log("{} already in place".format(texturetype), "INFO", "ExportModelOperator") # report success to user log("Export successful.", "INFO", end="\n\n") return {'FINISHED'}