knowrob_common: PrologQueryUtils.java Source File

Go to the documentation of this file.
00001 package edu.tum.cs.ias.knowrob.prolog;
00002 
00003 import java.io.IOException;
00004 import java.util.ArrayList;
00005 import java.util.HashMap;
00006 import java.util.Vector;
00007 
00008 import edu.tum.cs.ias.knowrob.owl.OWLThing;
00009 
00010 
00011 
00027 public class PrologQueryUtils {
00028 
00029         
00030         
00031         public static void setActionVisHighlight(String action_class) {
00032                 try {
00033                         action_class = PrologInterface.removeSingleQuotes(action_class);
00034                         PrologInterface.executeQuery("planvis_clear_highlight(_), planvis_highlight('"+ action_class +"', _)");
00035                 } catch (Exception e) {}
00036         }
00037         
00038         public static void clearActionVisHighlight() {
00039                 try {
00040                         PrologInterface.executeQuery("planvis_clear_highlight(_)");
00041                 } catch (Exception e) {}
00042         }
00043 
00044         public static void startActionVis(String recipe_class) {
00045                 recipe_class = PrologInterface.removeSingleQuotes(recipe_class);
00046                 PrologInterface.executeQuery("planvis_create(P), planvis_load('"+ recipe_class +"', _)");
00047         }
00048         
00049         public static void loadActionIntoVis(String recipe_class) {
00050                 recipe_class = PrologInterface.removeSingleQuotes(recipe_class);
00051                 PrologInterface.executeQuery("planvis_load('"+ recipe_class +"', _)");
00052         }
00053 
00054         public static void parseOwlFile(String filename) {
00055                 PrologInterface.executeQuery("owl_parser:owl_parse('"+ filename +"', false, false, true)");
00056         }
00057         
00058         
00066         public static int readNumObjectInstances(String objClass) {
00067                 
00068                 objClass = PrologInterface.removeSingleQuotes(objClass);
00069 
00070                 HashMap<String, Vector<String>> obj_insts = 
00071                         PrologInterface.executeQuery("owl_individual_of(Inst, '" + objClass + "')");
00072 
00073                 if(obj_insts!=null && obj_insts.get("Inst").size()>0) {
00074 
00075                         return obj_insts.get("Inst").size();
00076                 }
00077 
00078                 return 0;
00079         }       
00080         
00081         
00088         public static Vector<String> readAllInstancesOfClass(String owlClass) {
00089                 
00090                 owlClass = PrologInterface.removeSingleQuotes(owlClass);
00091                 
00092                 HashMap<String, Vector<String>> obj_insts = 
00093                         PrologInterface.executeQuery("owl_individual_of(Inst, '" + owlClass + "')");
00094 
00095                 if(obj_insts!=null && obj_insts.get("Inst").size()>0) {
00096 
00097                         return obj_insts.get("Inst");
00098                 }
00099                 return null;
00100         }
00101         
00102         
00109         public static String readLatestDetectionOfObjectInst(String objInst) {
00110 
00111                 objInst = PrologInterface.removeSingleQuotes(objInst);
00112                 
00113                 HashMap<String, Vector<String>> detections = 
00114                         PrologInterface.executeQuery("latest_detection_of_instance('" + objInst + "', LatestDetection)");
00115 
00116                 if(detections!=null && detections.get("LatestDetection").size()>0) {
00117                         return detections.get("LatestDetection").get(0);
00118                 }
00119                 return null;
00120         }
00121 
00122         
00129         public static String readLatestDetectionOfObjectClass(String objClass) {
00130 
00131                 objClass = PrologInterface.removeSingleQuotes(objClass);
00132                 
00133                 HashMap<String, Vector<String>> detections = 
00134                         PrologInterface.executeQuery("latest_detection_of_type('" + objClass + "', LatestDetection)");
00135 
00136                 if(detections!=null && detections.get("LatestDetection").size()>0) {
00137                         return detections.get("LatestDetection").get(0);
00138                 }
00139                 return null;
00140         }
00141         
00142         
00149         public static HashMap<String, Vector<String>> readInformationForInstance(String owlInst) {
00150 
00151                 owlInst = PrologInterface.removeSingleQuotes(owlInst);
00152                 
00153                 HashMap<String, Vector<String>> values = 
00154                         PrologInterface.executeQuery("owl_has('" + owlInst + "', P, O)");
00155                 
00156                 return values;
00157         }
00158         
00159         
00166         public static HashMap<String, Vector<String>> readInformationForClass(String owlClass) {
00167 
00168                 owlClass = PrologInterface.removeSingleQuotes(owlClass);
00169                 
00170                 HashMap<String, Vector<String>> values = 
00171                         PrologInterface.executeQuery("class_properties('" + owlClass + "', P, O)");
00172                 
00173                 return values;
00174         }
00175         
00176         public static Vector<String> readTypesOfInstance(String owlInst) {
00177 
00178                 owlInst = PrologInterface.removeSingleQuotes(owlInst);
00179                 
00180                 HashMap<String, Vector<String>> types = 
00181                         PrologInterface.executeQuery("owl_has('" + owlInst + "', rdf:type, T)");
00182                 
00183                 if(types!=null && types.get("T").size()>0) {
00184                         return types.get("T");
00185                 }
00186                 return new Vector<String>();
00187         }
00188 
00189 
00197         public static String readRecipeClass(String command) {
00198 
00199                 HashMap<String, Vector<String>> recipe_classes = 
00200                         PrologInterface.executeQuery("rdf(RecipeClass, rdfs:label, literal(like('*"+command+"*'), _))");
00201 
00202                 if(recipe_classes.get("RecipeClass").size()==0) {
00203                         return null;
00204                 } 
00205                 return recipe_classes.get("RecipeClass").firstElement();
00206         }
00207 
00208         
00209         
00216         public static Vector<String> readPrevActionInTask(String currentActInst) {
00217 
00218                 currentActInst = PrologInterface.removeSingleQuotes(currentActInst);
00219                 
00220                 HashMap<String, Vector<String>> values =
00221                         PrologInterface.executeQuery("rdf_reachable(Prev, 'http://ias.cs.tum.edu/kb/knowrob.owl#nextAction', '" + currentActInst + "')");
00222                 
00223                 if(values!=null && values.get("Prev").size()>0) {
00224                         return values.get("Prev");
00225                 }
00226                 return null;
00227         }
00228         
00229         
00238         public static String readOutputOfPrevAction(String currentActInst, String prevActionClass, String prop) {
00239 
00240                 prevActionClass = PrologInterface.removeSingleQuotes(prevActionClass);
00241                 prop = OWLThing.getShortNameOfIRI(PrologInterface.removeSingleQuotes(prop));
00242                 Vector<String> prev_acts = readPrevActionInTask(currentActInst);
00243                 prevActionClass = OWLThing.getOWLThingByShortname(prevActionClass).getIRI();
00244                 
00245                 for(String prev_act : prev_acts) {
00246                         
00247                         HashMap<String, Vector<String>> values =  // TODO: check that that action is in the same task!
00248                                 PrologInterface.executeQuery(
00249                                                 "owl_individual_of('" + PrologInterface.removeSingleQuotes(prev_act) + "', '" + prevActionClass + "'), " +
00250                                                 "rdf_has('" + PrologInterface.removeSingleQuotes(prev_act) + "', 'http://ias.cs.tum.edu/kb/knowrob.owl#" + prop + "' , Val)");
00251 //                      "rdf_has(prev_act, 'http://ias.cs.tum.edu/kb/knowrob.owl#" + prop + "' , Val)");
00252                         
00253                         if(values!=null && values.get("Val").size()>0) {
00254                                 return PrologInterface.stripLiteralType(values.get("Val").firstElement());
00255                         }
00256                 }
00257                 return null;
00258         }
00259         
00260         
00261         
00262         
00271         public static Vector<Float> readPointXYPose(String pointInst) {
00272 
00273                 pointInst = PrologInterface.removeSingleQuotes(pointInst);
00274                 
00275                 if(PrologInterface.executeQuery("owl_individual_of('" + pointInst + "', 'http://ias.cs.tum.edu/kb/knowrob.owl#Point2D')") != null) {
00276 
00277                         Vector<Float> res = new Vector<Float>();
00278                         HashMap<String, Vector<String>> obj_pose = 
00279                                 PrologInterface.executeQuery("rdf_has('" + pointInst + "', 'http://ias.cs.tum.edu/kb/knowrob.owl#xCoord', X), " +
00280                                                 "rdf_has('" + pointInst + "', 'http://ias.cs.tum.edu/kb/knowrob.owl#yCoord', Y)");
00281 
00282                         if(obj_pose!=null && obj_pose.get("X").size()>0 && obj_pose.get("X").size()>0) {
00283 
00284                                 res.add(Float.valueOf(PrologInterface.stripLiteralType(obj_pose.get("X").get(0))));   // x coord
00285                                 res.add(Float.valueOf(PrologInterface.stripLiteralType(obj_pose.get("Y").get(0))));   // y coord
00286                                 return res;
00287                         }
00288                 }
00289                 return null;
00290         }
00291         
00292         
00301         public static Vector<Float> readPointXYAZPose(String pointInst) {
00302 
00303                 pointInst = PrologInterface.removeSingleQuotes(pointInst);
00304                 
00305                 if(PrologInterface.executeQuery("owl_individual_of('" + pointInst + "', 'http://ias.cs.tum.edu/kb/knowrob.owl#Point2D')") != null) {
00306 
00307                         Vector<Float> res = new Vector<Float>();
00308                         HashMap<String, Vector<String>> obj_pose = 
00309                                 PrologInterface.executeQuery("rdf_has('" + pointInst + "', 'http://ias.cs.tum.edu/kb/knowrob.owl#xCoord', X), " +
00310                                                 "rdf_has('" + pointInst + "', 'http://ias.cs.tum.edu/kb/knowrob.owl#yCoord', Y)," +
00311                                                 "rdf_has('" + pointInst + "', 'http://ias.cs.tum.edu/kb/knowrob.owl#orientationAZ', AZ)");
00312 
00313                         if(obj_pose!=null && obj_pose.get("X").size()>0 && obj_pose.get("X").size()>0 && obj_pose.get("AZ").size()>0) {
00314 
00315                                 res.add(Float.valueOf(PrologInterface.stripLiteralType(obj_pose.get("X").get(0))));   // x coord
00316                                 res.add(Float.valueOf(PrologInterface.stripLiteralType(obj_pose.get("Y").get(0))));   // y coord
00317                                 res.add(Float.valueOf(PrologInterface.stripLiteralType(obj_pose.get("AZ").get(0))));  // orientation
00318                                 return res;
00319                         }
00320                 }
00321                 return null;
00322         }
00323         
00324 
00336         public static Vector<Float> readObjectPose(String objInst) {
00337 
00338                 objInst = PrologInterface.removeSingleQuotes(objInst);
00339                 
00340                 if(PrologInterface.executeQuery("owl_individual_of('" + objInst + "', 'http://ias.cs.tum.edu/kb/knowrob.owl#EnduringThing-Localized')") != null) {
00341 
00342                         Vector<Float> res = new Vector<Float>();
00343                         HashMap<String, Vector<String>> obj_pose = 
00344                                 PrologInterface.executeQuery("current_object_pose('" + objInst + "', Pose)");
00345 
00346                         if(obj_pose.get("Pose").size()>0) {
00347 
00348                                 ArrayList<String[]> pose = PrologInterface.dottedPairsToArrayList(obj_pose.get("Pose").get(0));
00349 
00350                                 for(String[] elem : pose) {
00351                                         res.add(Float.valueOf(elem[0]));
00352                                 }
00353                                 return res;
00354                         }
00355                 }
00356                 return null;
00357         }
00358 
00359 
00371         public static Vector<Float> readObjectClassPose(String objClass) {
00372 
00373                 objClass = PrologInterface.removeSingleQuotes(objClass);
00374                 
00375                 if(PrologInterface.executeQuery("owl_subclass_of('" + objClass + "', 'http://ias.cs.tum.edu/kb/knowrob.owl#EnduringThing-Localized')") != null) {
00376 
00377                         Vector<Float> res = new Vector<Float>();
00378                         
00379                         // read pose of first instance and set as target position
00380                         HashMap<String, Vector<String>> obj_inst = 
00381                                 PrologInterface.executeQuery("owl_individual_of(Ind, '" + objClass + "')");
00382 
00383                         if(obj_inst!=null && obj_inst.get("Ind")!=null && obj_inst.get("Ind").size()>0) {
00384 
00385                                 HashMap<String, Vector<String>> obj_pose = 
00386                                         PrologInterface.executeQuery("current_object_pose(" + obj_inst.get("Ind").get(0) + ", Pose)");
00387 
00388                                 if(obj_pose.get("Pose").size()>0) {
00389 
00390                                         ArrayList<String[]> pose = PrologInterface.dottedPairsToArrayList(obj_pose.get("Pose").get(0));
00391 
00392                                         for(String[] elem : pose) {
00393                                                 res.add(Float.valueOf(elem[0]));
00394                                         }
00395                                         return res;
00396 
00397                                 }
00398                         }
00399                 }
00400                 return null;
00401         }
00402         
00403         
00411         public static boolean owlClassExists(String owlClass) {
00412 
00413                 owlClass = PrologInterface.removeSingleQuotes(owlClass);
00414                 
00415                 HashMap<String, Vector<String>> values = 
00416                         PrologInterface.executeQuery("rdfs_subclass_of('" + owlClass + "', Super), \\+ rdf_equal('" + owlClass + "',Super)");
00417                 
00418                 if(values!=null && values.get("Super")!=null && values.get("Super").size()>0) {
00419                         
00420                         // there is a superclass different from the class itself -> class exists
00421                         return true;
00422                 }
00423                 return false;
00424         }
00425         
00426         
00432         public static String createActionInst(String currentActClass) {
00433 
00434                 currentActClass = PrologInterface.removeSingleQuotes(currentActClass);
00435                 
00436                 String inst = createOWLInst(currentActClass);
00437                 
00438                 HashMap<String, Vector<String>> st_time = 
00439                         PrologInterface.executeQuery("get_timepoint(NOW), " +
00440                                                                                  "rdf_assert(" + inst + ", 'http://ias.cs.tum.edu/kb/knowrob.owl#startTime', NOW)");
00441 
00442                 if(st_time !=null && st_time.get("NOW").size() > 0) {
00443                         return inst;
00444                 }
00445                 return null;
00446         }
00447         
00448         
00454         public static void assertActionEndTime(String actionInst) {
00455 
00456                 actionInst = PrologInterface.removeSingleQuotes(actionInst);
00457                 
00458                 PrologInterface.executeQuery("get_timepoint(NOW), " +
00459                                 "rdf_assert('" + actionInst + "', 'http://ias.cs.tum.edu/kb/knowrob.owl#endTime', NOW)");
00460         }
00461         
00462         
00469         public static void linkActionInTaskContext(String actionInst, String recipeInst) {
00470 
00471                 actionInst = PrologInterface.removeSingleQuotes(actionInst);
00472                 recipeInst = PrologInterface.removeSingleQuotes(recipeInst);
00473                 
00474                 
00475                 // find subAction of recipeInst that does not yet have a nextAction
00476                 // (which should be the end of the sequence)
00477                 
00478                 HashMap<String, Vector<String>> prev_action = PrologInterface.executeQuery(
00479                                 "rdf_has('" + recipeInst + "', 'http://ias.cs.tum.edu/kb/knowrob.owl#subAction', SUB)," +
00480                                 " not(rdf_has(SUB, 'http://ias.cs.tum.edu/kb/knowrob.owl#nextAction', _))");
00481 
00482                 // if there is any, assert the current action as nextAction (now being the end of the sequence)
00483                 if(prev_action !=null && prev_action.get("SUB").size() > 0) {
00484                         assertObjectPropertyForInst(prev_action.get("SUB").get(0), "'http://ias.cs.tum.edu/kb/knowrob.owl#nextAction'", actionInst);
00485                 }
00486 
00487                 // set actionInst as subAction of recipeInst
00488                 assertObjectPropertyForInst(recipeInst, "'http://ias.cs.tum.edu/kb/knowrob.owl#subAction'", actionInst);
00489         }
00490 
00491 
00498         public static void assertPropertiesForInstance(String inst, HashMap<String, Vector<String>> propVal) {
00499 
00500                 inst = PrologInterface.removeSingleQuotes(inst);
00501                 
00502                 for(String prop: propVal.keySet()) {
00503                         prop = PrologInterface.removeSingleQuotes(prop);
00504                         for(String val : propVal.get(prop)) {
00505                                 val = PrologInterface.removeSingleQuotes(val);
00506                                 PrologInterface.executeQuery("rdf_assert('" + inst + "', '"+prop+"', '" + val + "')");
00507                         }
00508                 }
00509         }       
00510 
00511         
00519         public static void assertObjectPropertyForInst(String inst, String prop, String val) {
00520 
00521                 inst = PrologInterface.removeSingleQuotes(inst);
00522                 prop = PrologInterface.removeSingleQuotes(prop);
00523                 val = PrologInterface.removeSingleQuotes(val);
00524                 
00525                 PrologInterface.executeQuery("rdf_assert('" + inst + "', '"+prop+"', '" + val + "')");
00526         }
00527         
00528 
00529         
00538         public static void assertDataPropertyForInst(String inst, String prop, String val, String type) {
00539 
00540                 inst = PrologInterface.removeSingleQuotes(inst);
00541                 prop = PrologInterface.removeSingleQuotes(prop);
00542                 val = PrologInterface.removeSingleQuotes(val);
00543                 type = PrologInterface.removeSingleQuotes(type);
00544                 
00545                 PrologInterface.executeQuery("rdf_assert('" + inst + "', '"+prop+"', literal(type('" + type + "', '" + val + "')))");
00546         }
00547         
00548         
00549         
00560         public static String createRestriction(String owlClass, String prop, String value, String restrType, String sourceRef) {
00561 
00562                 owlClass  = PrologInterface.removeSingleQuotes(owlClass);
00563                 prop      = PrologInterface.removeSingleQuotes(prop);
00564                 value     = PrologInterface.removeSingleQuotes(value);
00565                 restrType = PrologInterface.removeSingleQuotes(restrType);
00566                 sourceRef = PrologInterface.removeSingleQuotes(sourceRef);
00567                 
00568                 HashMap<String, Vector<String>> restr = 
00569                         PrologInterface.executeQuery("create_restr('"+owlClass+"', '" + prop + "', '" + value + "', '" + restrType + "', '" + sourceRef + "', Restr)");
00570 
00571                 if(restr !=null && restr.get("Restr")!=null && restr.get("Restr").size() > 0) {
00572                         return restr.get("Restr").firstElement();
00573                 }
00574                 return null;
00575         }
00576         
00577         
00584         public static void assertSubClassOf(String subClass, String superClass) {
00585 
00586                 subClass = PrologInterface.removeSingleQuotes(subClass);
00587                 superClass = PrologInterface.removeSingleQuotes(superClass);
00588                 
00589                 PrologInterface.executeQuery("rdf_assert('" + subClass + "', rdfs:subClassOf, '" + superClass + "')");
00590         }
00591         
00592         
00599         public static String createOWLInst(String owlClass) {
00600 
00601                 owlClass = PrologInterface.removeSingleQuotes(owlClass);
00602                 
00603                 HashMap<String, Vector<String>> inst = 
00604                         PrologInterface.executeQuery("rdf_instance_from_class('" + owlClass + "', ObjInst)");
00605 
00606                 if(inst !=null && inst.get("ObjInst").size() > 0) {
00607 
00608                         return inst.get("ObjInst").get(0);
00609                 }
00610                 return null;
00611         }
00612         
00613         
00620         public static String createStateTransition(String fromState, String toState, String causedBy) {
00621 
00622                 fromState = PrologInterface.removeSingleQuotes(fromState);
00623                 toState   = PrologInterface.removeSingleQuotes(toState);
00624                 
00625                 // check if there is already a transition with the defined from- and to-classes
00626                 HashMap<String, Vector<String>> t_insts = 
00627                         PrologInterface.executeQuery("owl_individual_of(T, 'http://ias.cs.tum.edu/kb/knowrob.owl#IntrinsicStateChangeEvent'), " +
00628                                                                                  "rdf_has(T, 'http://ias.cs.tum.edu/kb/knowrob.owl#fromState', '" + fromState + "'), " +
00629                                                                                  "rdf_has(T, 'http://ias.cs.tum.edu/kb/knowrob.owl#toState', '" + toState + "'), " +
00630                                                                                  "rdf_has(T, 'http://ias.cs.tum.edu/kb/knowrob.owl#causedBy', '" + causedBy+ "')");
00631 
00632                 // return existing instance if there is one with the respective arguments
00633                 if(t_insts !=null && t_insts.get("T").size() > 0) {
00634                         return t_insts.get("T").get(0);
00635                         
00636                 } else {
00637                         
00638                         // create new transition otherwise:
00639                         String t_inst = PrologQueryUtils.createOWLInst("http://ias.cs.tum.edu/kb/knowrob.owl#IntrinsicStateChangeEvent");
00640                         
00641                         assertObjectPropertyForInst(t_inst, "http://ias.cs.tum.edu/kb/knowrob.owl#fromState", fromState);
00642                         assertObjectPropertyForInst(t_inst, "http://ias.cs.tum.edu/kb/knowrob.owl#toState",   toState);
00643                         assertObjectPropertyForInst(t_inst, "http://ias.cs.tum.edu/kb/knowrob.owl#causedBy",  causedBy); // TODO: is this value already in the UNR Actions OWL namespace?
00644                         return t_inst;
00645                 }
00646         }
00647         
00648         
00654         public static void clearActionStateTransitions(String action) {
00655 
00656                 action = PrologInterface.removeSingleQuotes(action);
00657                 
00658                 HashMap<String, Vector<String>> t_insts = PrologInterface.
00659                                 executeQuery("class_properties('" + action + "', 'http://ias.cs.tum.edu/kb/knowrob.owl#stateTransition', T)");
00660 
00661                 if(t_insts !=null && t_insts.get("T").size() > 0) {
00662                         
00663                         for(String t : t_insts.get("T")) {
00664 
00665                                 // remove restriction on this transition
00666                                 PrologInterface.executeQuery("findall(R, rdf_has(R, 'http://www.w3.org/2002/07/owl#hasValue', " + t + "), Rs), " +
00667                                                 "member(Restr, Rs), rdf_retractall(Restr, _, _), rdf_retractall(_, 'http://www.w3.org/2000/01/rdf-schema#subClassOf', Restr)");
00668 
00669                                 // remove transition properties and transition itself
00670                                 PrologInterface.executeQuery("rdf_retractall(" + t + ", _, _)");
00671 
00672                         }
00673                 }
00674         }
00675         
00676         
00684         public static String createObjInstWithPose(String objClass, String perceptionMethod, Vector<Float> pose) {
00685 
00686                 objClass = PrologInterface.removeSingleQuotes(objClass);
00687                 perceptionMethod = PrologInterface.removeSingleQuotes(perceptionMethod);
00688                 
00689                 String q = "";
00690                 
00691                 if(pose.size()==2) {
00692                         q="create_object_perception('" + objClass + "', [1.0,0.0,0.0," + 
00693                                 pose.get(0) + ",0.0,1.0,0.0," + pose.get(1) + ",0.0,0.0,1.0," +
00694                                 "0.0,0.0,0.0,0.0,1.0], ['" + perceptionMethod + "'], ObjInst)";
00695                 } else if(pose.size()==16) {
00696                         q="create_object_perception('" + objClass + "', ["+
00697                         pose.get(0)  +","+ pose.get(1)  +","+ pose.get(2)  +","+ pose.get(3)  +","+
00698                         pose.get(4)  +","+ pose.get(5)  +","+ pose.get(6)  +","+ pose.get(7)  +","+
00699                         pose.get(8)  +","+ pose.get(9)  +","+ pose.get(10) +","+ pose.get(11) +","+
00700                         pose.get(12) +","+ pose.get(13) +","+ pose.get(14) +","+ pose.get(15) +
00701                         "], ['" + perceptionMethod + "'], ObjInst)";                    
00702                 }
00703 
00704                 HashMap<String, Vector<String>> obj_id = PrologInterface.executeQuery(q);
00705                 if(obj_id != null && obj_id.get("ObjInst").size() > 0) {
00706 
00707                         return obj_id.get("ObjInst").get(0);
00708                 }
00709                 return null;
00710         }
00711         
00712         
00713         
00721         public static void setObjPose(String objInst, String perceptionMethod, Vector<Float> pose) {
00722 
00723                 objInst = PrologInterface.removeSingleQuotes(objInst);
00724                 perceptionMethod = PrologInterface.removeSingleQuotes(perceptionMethod);
00725                 String q = "";
00726                 
00727                 if(pose.size()==2) {
00728                         q="create_perception_instance(['"+perceptionMethod+"'], Perception),"+
00729                     "set_object_perception('"+objInst+"', Perception),"+
00730                     "set_perception_pose(Perception, [1.0,0.0,0.0," + pose.get(0) + 
00731                     ",0.0,1.0,0.0," + pose.get(1) + ",0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0]).";
00732                         
00733                 } else if(pose.size()==16) {
00734                         q="create_perception_instance(['"+perceptionMethod+"'], Perception),"+
00735                     "set_object_perception('"+objInst+"', Perception),"+
00736                     "set_perception_pose(Perception, ["+
00737                         pose.get(0)  +","+ pose.get(1)  +","+ pose.get(2)  +","+ pose.get(3)  +","+
00738                         pose.get(4)  +","+ pose.get(5)  +","+ pose.get(6)  +","+ pose.get(7)  +","+
00739                         pose.get(8)  +","+ pose.get(9)  +","+ pose.get(10) +","+ pose.get(11) +","+
00740                         pose.get(12) +","+ pose.get(13) +","+ pose.get(14) +","+ pose.get(15) +
00741                         "])";                   
00742                 }
00743 
00744                 PrologInterface.executeQuery(q);
00745         }
00746         
00747         
00757         public static boolean evaluateCondition(String condition, String objActOn) {
00758 
00759                 condition = PrologInterface.removeSingleQuotes(condition);
00760                 objActOn = PrologInterface.removeSingleQuotes(objActOn);
00761                 
00762                 // covers the cases that 
00763                 // - objectActedOn is class: check if there is an instance of that class that fulfills the condition
00764                 // - objectActedOn is instance: check if that instance fulfills the condition
00765                 
00766                 HashMap<String, Vector<String>> cond_check = 
00767                         PrologInterface.executeQuery("owl_individual_of('" + objActOn+ "', '" + condition + "');" +
00768                                         "owl_individual_of(Inst, '" + objActOn + "'), owl_individual_of(Inst, '" + condition + "')");   
00769 
00770                 if(cond_check !=null) {
00771 
00772                         return true;
00773                 }
00774                 return false;
00775         }
00776 
00777         
00787         public static String getSemanticMapInstance(String roomNumber, String floorNumber, String streetNumber, String streetName) {
00788 
00789                 String q =      "owl_individual_of(Map, 'http://ias.cs.tum.edu/kb/knowrob.owl#SemanticEnvironmentMap')";
00790                 
00791                 if(roomNumber!=null && !roomNumber.isEmpty()) {
00792                         roomNumber = PrologInterface.removeSingleQuotes(roomNumber);
00793                         q+= ",owl_has(R, 'http://ias.cs.tum.edu/kb/knowrob.owl#describedInMap', Map)," +
00794                              "owl_has(R, 'http://ias.cs.tum.edu/kb/knowrob.owl#roomNumber', literal(type(_,'"+roomNumber+"')))";
00795                 }
00796                 
00797                 if(floorNumber!=null && !floorNumber.isEmpty()) {
00798                         floorNumber = PrologInterface.removeSingleQuotes(floorNumber);
00799                         q+= ",owl_has(S1, 'http://ias.cs.tum.edu/kb/knowrob.owl#properPhysicalParts', R)," +
00800                                  "rdf_has(R,  'http://ias.cs.tum.edu/kb/knowrob.owl#floorNumber', literal(type(_, '"+floorNumber+"')))";
00801                 }
00802                 
00803                 if(streetNumber!=null && !streetNumber.isEmpty()) {
00804                         streetNumber = PrologInterface.removeSingleQuotes(streetNumber);
00805                         q+= ",owl_has(S1, 'http://ias.cs.tum.edu/kb/knowrob.owl#properPhysicalParts', R)," +
00806                                 "rdf_has(R, 'http://ias.cs.tum.edu/kb/knowrob.owl#streetNumber', literal(type(_, '"+streetNumber+"')))";
00807                 }
00808                 
00809                 if(streetName!=null && !streetName.isEmpty()) {
00810                         streetName = PrologInterface.removeSingleQuotes(streetName);
00811                         q+= ",owl_has(S1, 'http://ias.cs.tum.edu/kb/knowrob.owl#properPhysicalParts', R)," +
00812                                 "rdf_has(S2, rdfs:label, literal(like('*"+streetName+"*'), _))";
00813                 }
00814                 
00815                 HashMap<String, Vector<String>> map_insts = PrologInterface.executeQuery(q);
00816                 
00817                 if(map_insts!=null && map_insts.get("Map").size()>0) {
00818                         return map_insts.get("Map").firstElement();
00819                 }
00820                 return null;
00821         }
00822 
00823         
00824         public static void writeActionToOWLFile(String actionClass, String file) {
00825                 PrologInterface.executeQuery("export_action('" + actionClass + "', '" + file + "')");
00826         }
00827         
00828         
00829         public static void deleteObjectInstance(String iri) {
00830                 iri = PrologInterface.removeSingleQuotes(iri);
00831                 PrologInterface.executeQuery("delete_object_information('" + iri + "')");
00832         }
00833 
00834         public static void deleteObjectInstanceWithChildren(String iri) {
00835                 iri = PrologInterface.removeSingleQuotes(iri);
00836                 PrologInterface.executeQuery("delete_object_information_recursive('" + iri + "')");
00837         }
00838 }