def createDescription(self): # =======Params========= self.addParam("Pose", Element("skiros:TransformationPose"), ParamTypes.Required) self.addParam("Pose2", Element("skiros:TransformationPose"), ParamTypes.Required) self.addParam("Axis", float, ParamTypes.Required)
def createDescription(self): #=======Params========= self.addParam("PlacingLocation", Element("skiros:Location"), ParamTypes.Required) self.addParam("Object", Element("skiros:Product"), ParamTypes.Required) self.addParam("Arm", Element("rparts:ArmDevice"), ParamTypes.Required) self.addParam("Gripper", Element("rparts:GripperEffector"), ParamTypes.Required) #=======PreConditions========= self.addPreCondition( self.getRelationCond("RobotAt", "skiros:at", "Robot", "PlacingLocation", True)) self.addPreCondition( self.getRelationCond("Holding", "skiros:contain", "Gripper", "Object", True)) #self.addPreCondition(self.getPropCond("LocationEmpty", ":ContainerState", "PlacingLocation", "=", "Empty", True)); #=======PostConditions========= self.addPostCondition( self.getRelationCond("NotHolding", "skiros:contain", "Gripper", "Object", False)) #self.addPostCondition(self.getPropCond("LocationEmpty", ":ContainerState", "PlacingLocation", "=", "Empty", False)); self.addPostCondition( self.getPropCond("EmptyHanded", "skiros:ContainerState", "Gripper", "=", "Empty", True)) self.addPostCondition( self.getRelationCond("InPlace", "skiros:contain", "PlacingLocation", "Object", True))
def createDescription(self): #=======Params========= #self.addParam("Container", Element(":Location"), ParamTypes.World) #self.addParam("Object", Element(":Product"), ParamTypes.Optional) self.addParam("Pose", Element("skiros:TransformationPose"), ParamTypes.Optional) self.addParam("Pose2", Element("skiros:TransformationPose"), ParamTypes.Optional)
def createDescription(self): #=======Params========= self.addParam("Pose", Element("skiros:TransformationPose"), ParamTypes.Optional) self.addParam("Pose2", Element("skiros:TransformationPose"), ParamTypes.Optional) self.addParam("Pose3", Element("skiros:TransformationPose"), ParamTypes.Optional)
def createDescription(self): #=======Params========= self.addParam("Turtle", Element("cora:Robot"), ParamTypes.Required) self.addParam("Target", Element("sumo:Object"), ParamTypes.Required) self.addParam("Linear", float, ParamTypes.Optional) self.addParam("Angular", float, ParamTypes.Optional) self.addParam("MinVel", float, ParamTypes.Optional) self.addParam("MinDist", float, ParamTypes.Optional)
def createDescription(self): #=======Params========= self.addParam("StartLocation", Element("skiros:Location"), ParamTypes.Inferred) self.addParam("TargetLocation", Element("skiros:Location"), ParamTypes.Required) #=======PreConditions========= self.addPreCondition(self.getRelationCond("RobotAt", "skiros:at", "Robot", "StartLocation", True)) #=======PostConditions========= self.addPostCondition(self.getRelationCond("NoRobotAt", "skiros:at", "Robot", "StartLocation", False)) self.addPostCondition(self.getRelationCond("RobotAt", "skiros:at", "Robot", "TargetLocation", True))
def createDescription(self): #=======Params========= self.addParam("WorldModelObject", Element("skiros:TransformationPose"), ParamTypes.Required) self.addParam("WorldModelOptional", Element("skiros:TransformationPose"), ParamTypes.Optional) self.addParam("DictionaryOptional", dict, ParamTypes.Optional) self.addParam("Boolean", False, ParamTypes.Required) self.addParam("Number", 0.0, ParamTypes.Required)
def createDescription(self): #=======Params========= self.addParam("Container", Element("skiros:Location"), ParamTypes.Required) self.addParam("Object", Element("skiros:Product"), ParamTypes.Optional) self.addParam("Camera", Element("skiros:DepthCamera"), ParamTypes.Required, [ParamOptions.Lock]) #=======PreConditions========= self.addPreCondition(self.getRelationCond("RobotAt", "skiros:at", "Robot", "Container", True)) self.addPreCondition(self.getAbstractRelationCond("ContainerForObject", "skiros:partReference", "Container", "Object", True)) #=======PostConditions========= self.addPostCondition(self.getRelationCond("InContainer", "skiros:contain", "Container", "Object", True)) self.addPostCondition(self.getHasPropCond("HasPosition", "skiros:Position", "Object", True))
def createDescription(self): # =======Params========= self.addParam("StartLocation", Element("sumo:Object"), ParamTypes.Inferred) self.addParam("TargetLocation", Element("sumo:Object"), ParamTypes.Optional) self.addParam("Object", Element("sumo:Object"), ParamTypes.Required) self.addParam("Relation", "skiros:contain", ParamTypes.Required) # =======PreConditions========= self.addPreCondition( self.getRelationCond("StartContainObj", "skiros:spatiallyRelated", "StartLocation", "Object", True))
def test_setProperty(self): e = Element() e.setProperty("Integer", 1) self.assertEqual([1], e.getProperty("Integer").values) msg = """ setProperty should convert when setting the property if force_convertion is true""" e.setProperty("Integer", "2", force_convertion=True) self.assertEqual([2], e.getProperty("Integer").values, msg) msg = """ setProperty should convert when setting the property if value is a list and if force_convertion is true""" e.setProperty("Integer", ["1", "2"], force_convertion=True) self.assertEqual([1, 2], e.getProperty("Integer").values, msg) msg = """ setProperty should convert unicode values to str before creating new property""" e.setProperty("strKey", u"a") self.assertEqual(str, type(e.getProperty("strKey").value), msg) msg = """ setProperty should convert unicode values to str when setting the property""" e.setProperty("strKey", u"b") self.assertEqual(["b"], e.getProperty("strKey").values, msg)
def _register_agent(self, agent_name): res = self._wmi.resolve_element(Element("cora:Robot", agent_name)) if res: log.info("[{}]".format(self.__class__.__name__), "Found robot {}, skipping registration.".format(res)) self._robot = res for r in self._robot.getRelations("-1", "skiros:hasSkill"): self._wmi.remove_element(self._wmi.get_element(r['dst'])) self._robot = self._wmi.get_element(self._robot.id) else: self._robot = self._wmi.instanciate(agent_name, True) startLocUri = self._wmi.get_template_element( agent_name).getRelations(pred="skiros:hasStartLocation") if startLocUri: start_location = self._wmi.instanciate(startLocUri[0]["dst"], False, []) self._wmi.set_relation(self._robot._id, "skiros:at", start_location._id) self._robot = self._wmi.get_element(self._robot.id) log.info("[{}]".format(self.__class__.__name__), "Registered robot {}".format(self._robot)) self._robot.setProperty( "skiros:SkillMgr", self._agent_name[self._agent_name.rfind(":") + 1:]) self._wmi.update_element(self._robot)
def generateDefParams(self): """ @brief Some default params are added automatically """ if not self._params.hasParam('Robot'): self._params.addParam("Robot", Element("sumo:Agent"), params.ParamTypes.Inferred)
def createDescription(self): #=======Params========= self.addParam("Name", str, ParamTypes.Required) self.addParam("X", 0.0, ParamTypes.Required) self.addParam("Y", 0.0, ParamTypes.Required) self.addParam("Rotation", 0.0, ParamTypes.Required) self.addParam("Turtle", Element("cora:Robot"), ParamTypes.Optional)
def _autoParametrizeBB(self, skill): """ @brief ground undefined parameters with parameters in the Black Board """ to_resolve = [ key for key, param in skill._params.getParamMap().iteritems() if param.paramType != params.ParamTypes.Optional and param.dataTypeIs(Element) and param.getValue().getIdNumber() < 0 ] if not to_resolve: return True log.assertInfo(self._verbose, "[Autoparametrize]", "Resolving {}:{}".format(skill.type, to_resolve)) #self._importParentsConditions(skill, to_resolve) remap = {} cp = params.ParamHandler() cp.reset(skill._params.getCopy()) for c in skill._pre_conditions: c.setDesiredState(cp) for key in to_resolve: remap[key] = [] for k, p in self._params._params.iteritems(): if p.dataTypeIs(Element()): if p.getValue().isInstance(cp.getParamValue(key), self._wm): remap[key].append(k) else: pass # log.info("Not instance", "{} Model: {} Match: {}".format(key, cp.getParamValue(key).printState(True), p.getValue().printState(True))) return self._autoParametrizeWm(skill, to_resolve, cp)
def createDescription(self): # =======Params========= self.addParam("Pose", Element("skiros:TransformationPose"), ParamTypes.Required) self.addParam("Direction", 0, ParamTypes.Required, description="x: 0, y: 1, z: 2")
def test_hasProperty(self): e = Element() e.setProperty("Integer", "2", "xsd:int") self.assertEqual(False, e.hasProperty("NonExistingKey")) self.assertEqual(False, e.hasProperty("Integer", 1)) self.assertEqual(True, e.hasProperty("Integer", 2)) self.assertEqual(True, e.hasProperty("Integer")) e.setProperty("Type", int) self.assertEqual(False, e.hasProperty("Type", not_none=True))
def test_remove_element(skiros_bot): "test that an element can be removed from wm through the gui" element = Element(":testType") element_inst = skiros_bot.add_object(element) #test that element is there assert skiros_bot.gui_has_element(element_inst) skiros_bot.remove_object(element_inst) #test that it was removed assert not skiros_bot.gui_has_element(element_inst)
def printParams(self, params): to_ret = "\n" for _, p in params.getParamMap().iteritems(): if isinstance(Element(), p.dataType()): to_ret += p._key + ": " for e in p.getValues(): to_ret += e.printState() + "\n" else: to_ret += p.printState() + "\n" return to_ret
def test_element(self): e = Element() e.setProperty("Hello", float) e.setProperty("Hello", 0.0) self.assertEqual(e.getProperty("Hello").value, 0.0) e.getProperty("Hello").values = 1.0 self.assertEqual(e.getProperty("Hello").values, [1.0]) e.getProperty("Hello").value = 2.0 self.assertEqual(e.getProperty("Hello").values, [2.0])
def inferUnvalidParams(self, skill): #print '{}: {} '.format(skill._label, self.printParams(skill._params)) unvalid_params = skill.checkPreCond(self._verbose) if unvalid_params: log.info("[{}] Reset unvalid params {}".format(skill._label, unvalid_params)) for k in unvalid_params: skill._params.setDefault(k) p = skill._params.getParam(k) if p.dataTypeIs(Element()) and p.getValue().getIdNumber() >= 0: skill._params.specify(k, self._wm.get_element(p.getValue()._id)) return self._autoParametrizeBB(skill) return True
def reset(self, add_root=True, scene_name="skiros:blank_scene"): """ @brief Initialize the scene """ IndividualsDataset.reset(self) self._id_gen.clear() if add_root: if self.has_individual(scene_name): root = self.get_individual(scene_name) else: root = Element("skiros:Scene", scene_name) self.add_element(root, self.__class__.__name__)
def test_save_and_load_scene(skiros_bot): "Test saving a scene and loading it back" #setup a scene and save it scene_name = "test_scene.turtle" element = Element(":testType") element_inst = skiros_bot.add_object(element) skiros_bot.save_scene(scene_name) #reset the scene to clear the changes skiros_bot.reset_scene() assert not skiros_bot.gui_has_element(element_inst) #load the changes back in skiros_bot.load_scene(scene_name) assert skiros_bot.gui_has_element(element_inst)
def toElement(self): to_ret = Element(self._type) to_ret._label = self._label for _, p in self.params.items(): if p.dataTypeIs(Element): to_ret.addRelation(self, "skiros:hasParam", p.toElement()) for c in self._pre_conditions: to_ret.addRelation(self, "skiros:hasPreCondition", c.toElement()) for c in self._hold_conditions: to_ret.addRelation(self, "skiros:hasHoldCondition", c.toElement()) for c in self._post_conditions: to_ret.addRelation(self, "skiros:hasPostCondition", c.toElement()) return to_ret
def _updateRoutine(self, time): """ @brief Sync the modified parameters elements with wm @time The time to evaluate if a parameter was changed """ for k, p in self.params.iteritems(): if p.dataTypeIs(Element()) and p.hasChanges(time): vs = p.values for i, e in enumerate(vs): if not e.isAbstract(): self._wmi.update_element(e) else: vs[i] = self._wmi.add_element(e)
def toElement(self): to_ret = Element("skiros:Parameter", self._key) to_ret.setProperty("rdfs:comment", self._description) to_ret.setProperty("skiros:ParameterType", self._param_type.value - 1) if (not self.dataTypeIs(Element)): to_ret.setProperty("skiros:DataType", self._data_type) if self.hasSpecifiedDefault(): to_ret.setProperty("skiros:Default", self._default) if self.isSpecified(): to_ret.setProperty("skiros:Value", self._values) else: to_ret.setProperty("skiros:DataType", self._default[0]._type) if self.isSpecified(): for v in self._values: if v._id != "": to_ret.addRelation("-1", "skiros:hasValue", v._id) return to_ret
def generateDefConditions(self): """ @brief Some default preconditions are added automatically """ #self.addPreCondition(self.getRelationCond("HasSkill", "hasSkill", "Robot", "Skill", True)) # for key, param in self._params.getParamMapFiltered(params.ParamTypes.Hardware).iteritems(): # self.addPreCondition(self.getPropCond("DeviceIdle", "deviceState", key, "Idle", True)) for key, param in self._params.getParamMapFiltered( params.ParamTypes.Optional).items(): if isinstance(Element(), param.dataType()): c1 = self.getGenerateCond("Has" + key, key, True) dont_add = False for c2 in self._post_conditions: if c1.isEqual(c2) or c1.hasConflict(c2): dont_add = True if not dont_add: self._post_conditions = [c1] + self._post_conditions return True
def get_individual(self, name, context_id=""): """ @brief Builds an element from an individual @param context_id if defined look for the individual only in the context """ subject = self.lightstring2uri(name) if not self.uri_exists(subject, context_id): raise Exception( "Element {} doesn't exist in ontology. Uri: {}. Context: {}.". format(name, subject, context_id)) e = Element() for predicate, obj in self.ontology(context_id).predicate_objects( subject): if OWL.DatatypeProperty in self.ontology().objects( predicate, RDF.type) or predicate == RDFS.comment: e.setProperty(self.uri2lightstring(predicate), obj.value, self.uri2lightstring(obj.datatype), force_convertion=True) elif OWL.ObjectProperty in self.ontology().objects( predicate, RDF.type): e.addRelation("-1", self.uri2lightstring(predicate), self.uri2lightstring(obj)) elif predicate == RDF.type and obj != OWL.NamedIndividual: e._type = self.uri2lightstring(str(obj)) elif obj == OWL.NamedIndividual: pass elif predicate == RDFS.label: e._label = obj.value else: log.error( "[get_individual]", "Ignoring {}-{}-{}. Predicate is not defined in the ontology." .format(name, self.uri2lightstring(predicate), self.uri2lightstring(obj))) for subj, predicate in self.ontology(context_id).subject_predicates( subject): if (self.uri2lightstring(predicate) != "skiros:hasTemplate"): e.addRelation(self.uri2lightstring(subj), self.uri2lightstring(predicate), "-1") self._add_reasoners_prop(e) return e
def addParam(self, key, value, param_type, options=[], description=""): """ @brief Adds a parameter key: a unique string identifier value: the default value or type param_type: the type of parameter (see ParamTypes) options: see ParamOptions description: an optional verbose description """ self._params.addParam(key, value, param_type, description) if isinstance(value, type(Element())): for o in options: if o == ParamOptions.Consume: self._post_conditions += [ self.getGenerateCond("Consume" + key, key, False) ] elif o == ParamOptions.Unspecify: self._post_conditions += [ self.getIsSpecifiedCond("Unset" + key, key, False) ] elif o == ParamOptions.Lock: self._pre_conditions += [ self.getPropCond(key + 'Idle', "skiros:StateProperty", key, "=", "Idle", True) ] self._hold_conditions += [ self.getPropCond(key + 'Busy', "skiros:StateProperty", key, "=", "Idle", False) ] self._post_conditions += [ self.getPropCond(key + 'Idle', "skiros:StateProperty", key, "=", "Idle", True) ] elif o == ParamOptions.RespectType: self._pre_conditions.append( self.getOnTypeCond(key + 'OfType', key, self.params[key].default.type))
def createDescription(self): self.addParam("Turtle", Element("cora:Robot"), ParamTypes.Required) self.addParam("Linear", float, ParamTypes.Required, "Linear velocity") self.addParam("Angular", float, ParamTypes.Required, "Angular velocity in degrees")
def createDescription(self): #=======Params========= self.addParam("Turtle", Element("cora:Robot"), ParamTypes.Required)