private ArrayList _history; // store the previous agenda items public PlanGraph(SQLiteKBase kbase, Executor exec) { this._kbase = kbase; this._exec = exec; this._root = null; this._currDlgAct = null; this._agenda = new ArrayList(); this._history = new ArrayList(); this._respList = new ArrayList(); }
public void Close() { this._exec = null; this._kbase.Close(); this._root = null; this._currDlgAct = null; this._agenda.Clear(); this._history.Clear(); this._respList.Clear(); }
private bool _explainAffOrNeg(PlanNode planNode, DialogueAct dlgAct, string indent) { Console.WriteLine(indent + "Dialogue.PlanGraph _explainAffOrNeg " + planNode.Name); if (planNode is ActionNode) { ActionNode actNode = (ActionNode)planNode; if (actNode.ActType == "ID" && actNode.ActState == ActionState.Executing) { if (actNode.Parent != null && actNode.Parent is ParamNode) { ParamNode paramNode = actNode.Parent as ParamNode; if (paramNode.ParamType == "boolean") { return(true); } } } } return(false); }
private ActionNode _explainAction(Hashtable tempAct, DialogueAct dlgAct, string indent) { Console.WriteLine(indent + "Dialogue.PlanGraph _explainAction "); if (this._root == null) { // todo: check the top actions before assign it to the root node this._root = new ActionNode((string)tempAct["name"], (string)tempAct["act_type"], (string)tempAct["complexity"], (string)tempAct["description"], null); ((ActionNode)this._root).Agents.Add(dlgAct.Agent); ((ActionNode)this._root).ActState = ActionState.Initiated; return(this._root); } else if (this._agenda.Count > 0) { foreach (PlanNode planNode in this._agenda.ToArray()) { ActionNode actNode = this._explainActionFromNode(planNode, tempAct, dlgAct, indent + " "); if (actNode != null) { return(actNode); } } } return(this._explainActionFromNode(this._root, tempAct, dlgAct, indent + " ")); }
private ActionNode _explainAction(Hashtable tempAct, DialogueAct dlgAct) { if (this._root == null) { // todo: check the top actions before assign it to the root node this._root = new ActionNode((string)tempAct["name"], (string)tempAct["act_type"], (string)tempAct["complexity"], (string)tempAct["description"], null); ((ActionNode)this._root).Agents.Add(dlgAct.Agent); ((ActionNode)this._root).ActState = ActionState.Initiated; return this._root; } else if (this._agenda.Count > 0) { foreach (PlanNode planNode in this._agenda.ToArray()) { ActionNode actNode = this._explainActionFromNode(planNode, tempAct, dlgAct); if (actNode != null) { return actNode; } } } return this._explainActionFromNode(this._root, tempAct, dlgAct); }
private ArrayList ChooseAnalyticFunctions(ActionNode actionNode, DialogueAct currDlgAct) { ArrayList respList = new ArrayList(); // change its own state actionNode.ActState = ActionState.Executing; // do something: respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, "Basic Action: ChooseAnalyticFunctions")); ActionNode parentNode = ((ActionNode)(actionNode.Parent)); bool multiple = false; bool need_summary = false; bool partiality = false; foreach (ParamNode param in parentNode.Params) { if (param.Name == "region.multiple") { if (param.Values.Count > 0) { multiple = ((bool)param.Values[0]); } } else if (param.Name == "need_summary") { if (param.Values.Count > 0) { need_summary = ((bool)param.Values[0]); } } else if (param.Name == "partiality") { if (param.Values.Count > 0) { partiality = ((bool)param.Values[0]); } } } string chosenActionName = ""; if (need_summary == true) { if (partiality == false) { // select features in the region chosenActionName = "Select Features Inside Region"; } else { // overlay features with the region chosenActionName = "Overlay Features and Region"; } } respList.Add(new DialogueResponse(DialogueResponseType.newAgendaItem, chosenActionName)); // change its own state actionNode.ActState = ActionState.Complete; // generate response return respList; }
private ArrayList DrawRegion(ActionNode actionNode, DialogueAct currDlgAct) { ArrayList respList = new ArrayList(); if (actionNode.ActState == ActionState.Initiated) { // change its own state actionNode.ActState = ActionState.Executing; // do something: generate the candiate list respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, "Basic Action: DrawRegion")); respList.Add(new DialogueResponse(DialogueResponseType.speechInfo, "Please adjust the map so that you can see the whole region of your interest.")); respList.Add(new DialogueResponse(DialogueResponseType.speechInfo, "Ask me for a drawing tool when you are ready.")); return respList; } // if the action is executing, try to check whether the current input answers the question else if (actionNode.ActState == ActionState.Executing) { if (currDlgAct.DlgActType == DialogueActType.Intend) { respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, "Start drawing the region")); respList.Add(new DialogueResponse(DialogueResponseType.drawPolygonStarted, "Region 1")); respList.Add(new DialogueResponse(DialogueResponseType.speechInfo, "Use the mouse to draw the region, double click when you want to finish drawing.")); return respList; } else if (currDlgAct.DlgActType == DialogueActType.Feedback) { // find the parameter node from the ancestor PlanNode parent = actionNode.Parent; ParamNode paramNode = null; while (parent != null) { if (parent.Parent is ParamNode) { paramNode = parent.Parent as ParamNode; break; } else if (parent.Parent is ActionNode) { parent = parent.Parent; } } if (paramNode != null) { foreach (string phrase in currDlgAct.SpeechContext.Keys) { if (phrase.ToLower() == actionNode.Name.ToLower()) { object newValue = this._parseValueFromSpeech(paramNode, currDlgAct.SpeechContext[phrase]); if (newValue != null) { this._addValueToParam(paramNode, newValue); // change its own state actionNode.ActState = ActionState.Complete; // generate response if (paramNode.ParamType == "geometry_polygon") { // fixed at the moment respList.Add(new DialogueResponse(DialogueResponseType.speechInfo, "Thanks, you may refer to this region as " + newValue.ToString())); return respList; } } } } } } } // change its own state actionNode.ActState = ActionState.Complete; // generate response return respList; }
private ArrayList AskForPartiality(ActionNode actionNode, DialogueAct currDlgAct) { ArrayList respList = new ArrayList(); if (actionNode.ActState == ActionState.Initiated) { // change its own state actionNode.ActState = ActionState.Executing; // do something: generate the candiate list respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, "Basic Action: AskForPartiality")); ParamNode paramNode = (ParamNode)actionNode.Parent; if (paramNode.Name == "partiality") { // only respond if the need_summary is true ActionNode parentNode = ((ActionNode)(paramNode.Parent)); bool need_summary = false; foreach (ParamNode param in parentNode.Params) { if (param.Name == "need_summary") { if (param.Values.Count > 0) { need_summary = ((bool)param.Values[0]); } } } if (need_summary == true) { // fixed at the moment OptionWithExampleListData respContent = new OptionWithExampleListData(); respContent.Opening = this._generateQuestionString(paramNode); respContent.Opening = "Do you want to map them partially or fully inside? The comparison of difference between partially and fully inside are shown in the popup window."; respContent.AddOption(new OptionWithExampleItemData("the parts inside", "Only the parts of features inside the region should be taken into account", "/CAGA;component/Images/partial2.png")); respContent.AddOption(new OptionWithExampleItemData("the features as a whole", "The inside features as a whole should be taken into account", "/CAGA;component/Images/full2.png")); respList.Add(new DialogueResponse(DialogueResponseType.listOptionsWithExamples, respContent)); return respList; } } } // if the action is executing, try to check whether the current input answers the question else if (actionNode.ActState == ActionState.Executing) { ParamNode paramNode = (ParamNode)actionNode.Parent; foreach (string phrase in currDlgAct.SpeechContext.Keys) { if (phrase.ToLower() == paramNode.Name.ToLower()) { object newValue = this._parseValueFromSpeech(paramNode, currDlgAct.SpeechContext[phrase]); if (newValue != null) { this._addValueToParam(paramNode, newValue); // change its own state actionNode.ActState = ActionState.Complete; return respList; } } } } // change its own state actionNode.ActState = ActionState.Complete; // generate response return respList; }
private ArrayList SpecifyRegionByAttributes(ActionNode actionNode, DialogueAct currDlgAct) { ArrayList respList = new ArrayList(); if (actionNode.ActState == ActionState.Initiated) { // change its own state actionNode.ActState = ActionState.Executing; // do something: generate the candiate list respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, "Basic Action: SpecifyRegionByAttributes")); respList.Add(new DialogueResponse(DialogueResponseType.speechInfo, "Please specify the region by filtering out the attributes.")); respList.Add(new DialogueResponse(DialogueResponseType.selectByAttributes, null)); return respList; } // if the action is executing, try to check whether the current input answers the question else if (actionNode.ActState == ActionState.Executing) { if (currDlgAct.DlgActType == DialogueActType.Feedback) { // find the parameter node from the ancestor PlanNode parent = actionNode.Parent; ParamNode paramNode = null; while (parent != null) { if (parent.Parent is ParamNode) { paramNode = parent.Parent as ParamNode; break; } else if (parent.Parent is ActionNode) { parent = parent.Parent; } } if (paramNode != null) { foreach (string phrase in currDlgAct.SpeechContext.Keys) { if (phrase.ToLower() == actionNode.Name.ToLower()) { object newValue = this._parseValueFromSpeech(paramNode, currDlgAct.SpeechContext[phrase]); if (newValue != null) { Hashtable v = new Hashtable(); v.Add("type", "features"); v.Add("value", newValue); this._addValueToParam(paramNode, v); // change its own state actionNode.ActState = ActionState.Complete; // generate response if (paramNode.ParamType == "geometry_polygon") { // fixed at the moment respList.Add(new DialogueResponse(DialogueResponseType.speechInfo, "The region is identified as a set of features in the layer " + newValue.ToString())); return respList; } } } } } } } // change its own state actionNode.ActState = ActionState.Complete; // generate response return respList; }
private ArrayList PerformOverlay(ActionNode actionNode, DialogueAct currDlgAct) { ArrayList respList = new ArrayList(); // change its own state actionNode.ActState = ActionState.Executing; // do something: respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, "Basic Action: PerformOverlay")); ParamNode paramNode = (ParamNode)actionNode.Parent; ActionNode parentNode = ((ActionNode)(actionNode.Parent.Parent)); string featureClass = ""; Hashtable region = null; foreach (ParamNode param in parentNode.Params) { if (param.ParamState == ParamState.Ready && param.Name == "region") { region = param.Values[0] as Hashtable; } else if (param.ParamState == ParamState.Ready && param.Name == "feature_class") { featureClass = param.Values[0].ToString(); } } if (region != null && featureClass != "") { if (region["type"].ToString() == "drawing") { string graphicsName = region["value"].ToString(); //this._mapMgr.SelectFeaturesByGraphics(graphicsName); //respList.Add(new DialogueResponse(DialogueResponseType.speechInfo, "The " + featureClass + " within " + graphicsName + "are highlighted in the map!")); //int count = this._mapMgr.GetTotalSelectedFeaturesInLayer(featureClass); //respList.Add(new DialogueResponse(DialogueResponseType.speechInfo, "There are total of " + count + " " + featureClass + " selected.")); respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, "overlay " + featureClass + " and " + graphicsName)); } else if (region["type"].ToString() == "features") { string in_layer = featureClass; string select_features = region["value"].ToString(); ArrayList inputLayers = new ArrayList(); inputLayers.Add(in_layer); inputLayers.Add(select_features); // use cached output file for demo purpose, reduce the time to calculate the overlay string cachedOutputFile = in_layer + "_" + select_features + "_overlay"; string outputFile = this._mapMgr.Overlay(inputLayers, cachedOutputFile); if (outputFile.Length > 0) { this._addValueToParam(paramNode, cachedOutputFile); respList.Add(new DialogueResponse(DialogueResponseType.speechInfo, "The overlay of " + featureClass + " and " + select_features + "is added in the map!")); respList.Add(new DialogueResponse(DialogueResponseType.mapLayerAdded, outputFile)); respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, "overlay " + featureClass + " and " + select_features)); // change its own state actionNode.ActState = ActionState.Complete; return respList; } //this._mapMgr.SelectFeaturesByLocation(in_layer, select_features); //respList.Add(new DialogueResponse(DialogueResponseType.speechInfo, "The " + featureClass + " within " + select_features + "are highlighted in the map!")); //int count = this._mapMgr.GetTotalSelectedFeaturesInLayer(featureClass); //respList.Add(new DialogueResponse(DialogueResponseType.speechInfo, "There are total of " + count + " " + featureClass + " selected.")); } } // change its own state actionNode.ActState = ActionState.Complete; // generate response return respList; }
private ArrayList PerformSelection(ActionNode actionNode, DialogueAct currDlgAct) { ArrayList respList = new ArrayList(); // change its own state actionNode.ActState = ActionState.Executing; // do something: respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, "Basic Action: PerformSelection")); ActionNode parentNode = ((ActionNode)(actionNode.Parent)); string featureClass = ""; Hashtable region = null; foreach (ParamNode param in parentNode.Params) { if (param.ParamState == ParamState.Ready && param.ParamType == "geometry_polygon") { region = param.Values[0] as Hashtable; } else if (param.ParamState == ParamState.Ready && param.ParamType == "feature_class") { featureClass = param.Values[0].ToString(); } } if (region != null && featureClass != "") { if (region["type"].ToString() == "drawing") { string graphicsName = region["value"].ToString(); this._mapMgr.SelectFeaturesByGraphics(graphicsName); respList.Add(new DialogueResponse(DialogueResponseType.speechInfo, "The " + featureClass + " within " + graphicsName + "are highlighted in the map!")); int count = this._mapMgr.GetTotalSelectedFeaturesInLayer(featureClass); respList.Add(new DialogueResponse(DialogueResponseType.speechInfo, "There are total of " + count + " " + featureClass + " selected.")); respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, "selecting by drawing")); } else if (region["type"].ToString() == "features") { string in_layer = featureClass; string select_features = region["value"].ToString(); this._mapMgr.SelectFeaturesByLocation(in_layer, select_features); respList.Add(new DialogueResponse(DialogueResponseType.speechInfo, "The " + featureClass + " within " + select_features + "are highlighted in the map!")); int count = this._mapMgr.GetTotalSelectedFeaturesInLayer(featureClass); respList.Add(new DialogueResponse(DialogueResponseType.speechInfo, "There are total of " + count + " " + featureClass + " selected.")); respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, "selecting by attributes")); } } // change its own state actionNode.ActState = ActionState.Complete; // generate response return respList; }
/// <summary> /// When Completed, Update Parent recursively /// </summary> /// <param name="planNode"></param> /// <param name="indent"></param> private void _updateParentState(PlanNode planNode, string indent) { Console.WriteLine(indent + "Dialogue.PlanGraph _updateParentState " + planNode.Name); if (planNode.Parent != null) { Console.WriteLine(indent + "Parent: " + planNode.Parent.Name); if (planNode.Parent is ActionNode) { ActionNode parent = (ActionNode)planNode.Parent; foreach (ParamNode param in parent.Params) { if (param.ParamState != ParamState.Ready) { Console.WriteLine(indent + "ActionNode Parent not Completed becasue of param " + param.Name + " " + param.ParamState.ToString()); return; } } foreach (ActionNode subAct in parent.SubActions) { if (subAct.Optional == false && subAct.ActState != ActionState.Complete) { Console.WriteLine(indent + "ActionNode Parent not Completed becasue of subAct " + subAct.Name + " " + subAct.ActState.ToString() + " Optional=false"); return; } if (subAct.Optional == true && subAct.ActState != ActionState.Complete && subAct.ActState != ActionState.Unknown) { Console.WriteLine(indent + "ActionNode Parent not Completed becasue of subAct " + subAct.Name + " " + subAct.ActState.ToString() + " Optional=ture"); return; } } parent.ActState = ActionState.Complete; Console.WriteLine(indent + "ActionNode Parent Completed"); this._updateParentState(parent, indent + " "); } else if (planNode.Parent is ParamNode) { ParamNode parent = (ParamNode)planNode.Parent; if (parent.Values.Count == 0) { Console.WriteLine(indent + "ParamNode Parent notReady becasue of 0 value"); return; } else { foreach (object obj in parent.Values) { if (obj is string) { Console.WriteLine(indent + "******string******"); Console.WriteLine(indent + "obj=" + obj); } else if (obj is Hashtable) { Console.WriteLine(indent + "******hashtable******"); foreach (DictionaryEntry item in (Hashtable)obj) { Console.WriteLine(indent + "key=" + item.Key + ",value=" + item.Value); } } } } // assume the parameter is ready as long as it has values // it might be extended to consider the conditions on the parameter parent.ParamState = ParamState.Ready; this._updateParentState(parent, indent + " "); } } }
private bool _parseRecipeXML(string recipeXML, ActionNode actionNode, string indent) { Console.WriteLine(indent + "Dialogue/PlanGraph _parseRecipeXML " + actionNode.Name); XmlDocument doc = new XmlDocument(); doc.LoadXml(recipeXML); XmlNodeList paramList = doc.GetElementsByTagName("PARA"); foreach (XmlNode param in paramList) { string name = param.Attributes["Name"].Value; string paramType = param.Attributes["Type"].Value; bool multiple = true; if (param.Attributes["Multiple"] != null && param.Attributes["Multiple"].Value.ToLower() == "false") { multiple = false; } string description = ""; if (param.Attributes["Description"] != null) { description = param.Attributes["Description"].Value; } ParamNode paramNode = new ParamNode(name, paramType, multiple, description, actionNode); bool hasParam = false; foreach (ParamNode tmpParam in actionNode.Params) { //Console.WriteLine(indent + "tmpParam= " + tmpParam.Name + ",paramNode=" + paramNode.Name); if (paramNode.Name == tmpParam.Name) { hasParam = true; paramNode.Flag = true; } } if (!hasParam) { foreach (XmlNode node in param.ChildNodes) { if (node.Name == "ID_PARAS") { foreach (XmlNode subAct in node.ChildNodes) { if (subAct.Name == "ID_PARA") { Hashtable tempAct = this._kbase.SearchAction(subAct.Attributes["Name"].Value); Console.WriteLine("name=" + (string)tempAct["name"]); //Console.WriteLine("act_type=" + (string)tempAct["act_type"]); //Console.WriteLine("complexity=" + (string)tempAct["complexity"]); //Console.WriteLine("description=" + (string)tempAct["description"]); ActionNode subActNode = new ActionNode((string)tempAct["name"], (string)tempAct["act_type"], (string)tempAct["complexity"], (string)tempAct["description"], paramNode); if (subAct.Attributes["Optional"] != null && subAct.Attributes["Optional"].Value.ToString().ToLower() == "true") { subActNode.Optional = true; } paramNode.Flag = true; paramNode.SubActions.Add(subActNode); } } } } actionNode.Params.Add(paramNode); } } for (int index = actionNode.Params.Count - 1; index >= 0; index--) { // Get the item. ParamNode tmpParam = (ParamNode)actionNode.Params[index]; // Check to remove. if (tmpParam.Flag == false) { Console.WriteLine("what deleted is " + tmpParam.Name); // Remove. actionNode.Params.RemoveAt(index); } } XmlNodeList actionList = doc.GetElementsByTagName("SUBACT"); foreach (XmlNode action in actionList) { Hashtable tempAct = this._kbase.SearchAction(action.Attributes["Name"].Value); ActionNode subActNode = new ActionNode((string)tempAct["name"], (string)tempAct["act_type"], (string)tempAct["complexity"], (string)tempAct["description"], actionNode); if (action.Attributes["Optional"] != null && action.Attributes["Optional"].Value.ToString().ToLower() == "true") { subActNode.Optional = true; } bool hasAction = false; foreach (ActionNode tmpActNode in actionNode.SubActions) { Console.WriteLine("tmpActNode.Name=" + tmpActNode.Name + ",subActNode.Name" + subActNode.Name); if (tmpActNode.Name == subActNode.Name) { hasAction = true; } } if (!hasAction) { actionNode.SubActions.Add(subActNode); } } return(true); }
private void _elaborateFromActionNode(ActionNode actionNode, string indent) { Console.WriteLine(indent + "Dialogue/PlanGraph _elaborateFromActionNode " + actionNode.Name); // check the parameters and constraints bool paramsRdy = this._parentParamsRdy(actionNode, indent + " "); // check whether the params are ready Console.WriteLine(indent + "paramsRdy = " + paramsRdy); if (paramsRdy == false) { return; } // If the action is a basic one and can be executed, then execute it if (actionNode.Complexity == "basic") { Console.WriteLine(indent + actionNode.Name + " is Basic"); // check the state of the action if (actionNode.ActState == ActionState.Initiated || actionNode.ActState == ActionState.Executing) { Console.WriteLine(indent + "actionNode.ActState before: " + actionNode.ActState); //// perform the task ArrayList execResp = this._exec.Execute(actionNode, this._currDlgAct, indent + " "); Console.WriteLine(indent + ""); if ((actionNode.Parent != null) && (actionNode.Parent is ActionNode)) { _actionNodeStack.Push((ActionNode)actionNode.Parent); } // add the execution response to the response list ArrayList newAgendaItems = new ArrayList(); foreach (DialogueResponse resp in execResp) { if (resp.DlgRespType == DialogueResponseType.newAgendaItem) { newAgendaItems.Add(resp.RespContent); } else { this._respList.Add(resp); } } Console.WriteLine(indent + "actionNode.ActState after: " + actionNode.ActState); // remove the running/complete action from the agenda; if (actionNode.ActState == ActionState.Complete) { this.RemoveFromAgenda(actionNode, indent + " "); } // check whether the parent's state is also complete if the action is complete if (actionNode.ActState == ActionState.Complete) { this._updateParentState(actionNode, indent + " "); } // perform the new agenda item foreach (string actionName in newAgendaItems) { if (actionName != "") { // only search parent level at the moment ActionNode parentNode = (ActionNode)actionNode.Parent; foreach (ActionNode subAct in parentNode.SubActions) { if (subAct.Name.ToLower() == actionName.ToLower()) { if (subAct.ActState == ActionState.Unknown) { subAct.ActState = ActionState.Initiated; int idx = this.GetIndexInAgenda(actionNode); this.AddToAgenda(subAct, idx + 1, indent + " "); this.ElaborateFromNode(subAct, indent + " "); break; } } } } } } Console.WriteLine(indent + "Agenda:"); foreach (PlanNode planNode in this._agenda.ToArray()) { Console.WriteLine(indent + "-" + planNode.Name); } return; } if (actionNode.Complexity == "complex") { if (_actionNodeStack.Count != 0) { Console.WriteLine(indent + "!!!!!!!!!!!!_prevActionNode is " + _actionNodeStack.Peek().Name); ActionNode tmpAction = _actionNodeStack.Peek(); foreach (ParamNode param in tmpAction.Params) { if (param.ParamState == ParamState.Ready) { Console.WriteLine(indent + "param " + param.Name + " is " + param.Values[0].ToString()); } } } Console.WriteLine(indent + actionNode.Name + " is Complex"); // check the state of the action if (actionNode.ActState == ActionState.Initiated) { // find and load the recipe this._loadRecipe(actionNode, indent + " "); } if (actionNode.ActState == ActionState.Planned) { int idx = this.RemoveFromAgenda(actionNode, indent + " "); foreach (ParamNode param in actionNode.Params) { idx = this.AddToAgenda(param, idx, indent + " "); idx++; } foreach (ActionNode subAct in actionNode.SubActions) { idx = this.AddToAgenda(subAct, idx, indent + " "); idx++; } Console.WriteLine(indent + "Agenda:"); foreach (PlanNode planNode in this._agenda.ToArray()) { Console.WriteLine(indent + "-" + planNode.Name); } // elaborate on the params foreach (ParamNode param in actionNode.Params) { param.ParamState = ParamState.InPreparation; this._elaborateFromParamNode(param, indent + " "); } foreach (ActionNode subAct in actionNode.SubActions) { if (subAct.Optional == false) { subAct.ActState = ActionState.Initiated; this._elaborateFromActionNode(subAct, indent + " "); } else { this.RemoveFromAgenda(subAct, indent + " "); } } } } }
private ActionNode _explainActionFromNode(PlanNode planNode, Hashtable tempAct, DialogueAct dlgAct, string indent) { Console.WriteLine(indent + "Dialogue.PlanGraph _explainActionFromNode " + planNode.Name); ActionNode pNode = (ActionNode)planNode; ActionNode newAction = new ActionNode((string)tempAct["name"], (string)tempAct["act_type"], (string)tempAct["complexity"], (string)tempAct["description"]); if (planNode is ActionNode) { Console.WriteLine(indent + "IsActionNode actionNode:" + planNode.Name.ToLower() + " tempAct" + tempAct["name"].ToString()); // ActionNode actionNode = (ActionNode)planNode; switch (newAction.ActType) { case "ACT": { if (pNode.Name.ToLower() == tempAct["name"].ToString().ToLower()) { // If the action has not been initiated, initiate it and add the agent if (pNode.ActState == ActionState.Unknown) { pNode.ActState = ActionState.Initiated; } if (pNode.SearchAgent(dlgAct.Agent) == null) { pNode.Agents.Add(dlgAct.Agent); } // If the action has been completed, or failed, start a new one, attached it to the same parent if (pNode.ActState == ActionState.Complete || pNode.ActState == ActionState.Failed) { // ActionNode newAction = new ActionNode((string)tempAct["name"], (string)tempAct["act_type"], (string)tempAct["complexity"], (string)tempAct["description"], actionNode.Parent); newAction.Parent = pNode.Parent; newAction.Agents.Add(dlgAct.Agent); newAction.ActState = ActionState.Initiated; if (pNode.Parent != null) { if (pNode.Parent is ActionNode) { //There seems to be a logical error, because the newAction is now added as a subaction of pNode.Parent. This is equivalent to modifying the recipe for pNode.Parent action. The correct way to handle this should be: // if the tempAct matches with one of the subactions that has not been initiated (potential intention), then replace that subact with newAction ActionNode pParent = (ActionNode)(pNode.Parent); foreach (ActionNode subact in pParent.SubActions) { if ((subact.Name == newAction.Name) & (subact.ActState == CAGA.Dialogue.ActionState.Unknown)) { ((ActionNode)(pNode.Parent)).SubActions.Add(newAction); newAction.Parent = pParent; ((ActionNode)(pNode.Parent)).SubActions.Remove(subact); } } } else if (pNode.Parent is ParamNode) { ((ParamNode)(pNode.Parent)).SubActions.Add(newAction); } } return(newAction); } return(pNode); } // search the params and subactions foreach (ParamNode paramNode in pNode.Params) { ActionNode actNode = this._explainActionFromNode(paramNode, tempAct, dlgAct, indent + " "); if (actNode != null) { return(actNode); } } foreach (ActionNode subActNode in pNode.SubActions) { ActionNode actNode = this._explainActionFromNode(subActNode, tempAct, dlgAct, indent + " "); if (actNode != null) { return(actNode); } } return(null); } case "REF": // If the parent is a Action node and the new act is a reference, try to explain it as a parameter of its subaction { // return(null); } } return(null); } else if (planNode is ParamNode) { switch (newAction.ActType) { case "ACT": { ParamNode paramNode = (ParamNode)planNode; foreach (ActionNode subActNode in paramNode.SubActions) { ActionNode actNode = this._explainActionFromNode(subActNode, tempAct, dlgAct, indent + " "); if (actNode != null) { return(actNode); } } return(null); } case "REF": { // explain the REF for potential match with the parameter, if the parent still expecting a parameter (paraStatus=unknown) //retrieval the REF type, if it matches with the Parameter type, move forward // Create a RefNode based on the newAction // RefNode has a parant of planNode // RefNode.execute to calculate the referenced entities and set the parameter of the planNode RefNode newRef = new RefNode(newAction); newRef.parent = (ParamNode)planNode; newRef.execute(); return(null); } } return(null); } return(null); }
private ArrayList GetValueFromInput(ActionNode actionNode, DialogueAct currDlgAct) { ArrayList respList = new ArrayList(); // change its own state actionNode.ActState = ActionState.Executing; // do something: parse the value respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, "Basic Action: GetValueFromInput")); ParamNode paramNode = (ParamNode)actionNode.Parent; foreach (string phrase in currDlgAct.SpeechContext.Keys) { if (phrase.ToLower() == paramNode.Name.ToLower()) { object newValue = _parseValueFromSpeech(paramNode, currDlgAct.SpeechContext[phrase]); if (newValue != null) { this._addValueToParam(paramNode, newValue); break; } } } // change its own state actionNode.ActState = ActionState.Complete; // generate response return respList; }
private bool _parseRecipeXML(string recipeXML, ActionNode actionNode) { XmlDocument doc = new XmlDocument(); doc.LoadXml(recipeXML); XmlNodeList paramList = doc.GetElementsByTagName("PARA"); foreach (XmlNode param in paramList) { string name = param.Attributes["Name"].Value; string paramType = param.Attributes["Type"].Value; bool multiple = true; if (param.Attributes["Multiple"] != null && param.Attributes["Multiple"].Value.ToLower() == "false") { multiple = false; } string description = ""; if (param.Attributes["Description"] != null) { description = param.Attributes["Description"].Value; } ParamNode paramNode = new ParamNode(name, paramType, multiple, description, actionNode); foreach (XmlNode node in param.ChildNodes) { if (node.Name == "ID_PARAS") { foreach (XmlNode subAct in node.ChildNodes) { if (subAct.Name == "ID_PARA") { Hashtable tempAct = this._kbase.SearchAction(subAct.Attributes["Name"].Value); ActionNode subActNode = new ActionNode((string)tempAct["name"], (string)tempAct["act_type"], (string)tempAct["complexity"], (string)tempAct["description"], paramNode); if (subAct.Attributes["Optional"] != null && subAct.Attributes["Optional"].Value.ToString().ToLower() == "true") { subActNode.Optional = true; } paramNode.SubActions.Add(subActNode); } } } } actionNode.Params.Add(paramNode); } XmlNodeList actionList = doc.GetElementsByTagName("SUBACT"); foreach (XmlNode action in actionList) { Hashtable tempAct = this._kbase.SearchAction(action.Attributes["Name"].Value); ActionNode subActNode = new ActionNode((string)tempAct["name"], (string)tempAct["act_type"], (string)tempAct["complexity"], (string)tempAct["description"], actionNode); if (action.Attributes["Optional"] != null && action.Attributes["Optional"].Value.ToString().ToLower() == "true") { subActNode.Optional = true; } actionNode.SubActions.Add(subActNode); } return true; }
private ArrayList CalculateFieldStatistics(ActionNode actionNode, DialogueAct currDlgAct) { ArrayList respList = new ArrayList(); // change its own state actionNode.ActState = ActionState.Executing; // do something: respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, "Basic Action: CalculateFieldStatistics")); ActionNode parentNode = ((ActionNode)(actionNode.Parent)); string featureClass = ""; // search for overlay first ArrayList featureClassValues = this._searchValueFromAncestor(actionNode, "overlay"); if (featureClassValues.Count == 0) { featureClassValues = this._searchValueFromAncestor(actionNode, "feature_class"); } if (featureClassValues.Count > 0) { featureClass = featureClassValues[0].ToString(); } string dataFieldName = ""; ArrayList dataFieldValues = this._searchValueFromAncestor(actionNode, "data_field"); if (dataFieldValues.Count > 0) { dataFieldName = dataFieldValues[0].ToString(); } string statistics = ""; ArrayList statisticsValues = this._searchValueFromAncestor(actionNode, "statistics"); if (statisticsValues.Count > 0) { statistics = statisticsValues[0].ToString(); } // mapping dataField name to field name in the data set string dataField = this._dataFieldMapping(dataFieldName); if (featureClass != "" && dataField != "") { Hashtable statResults = this._mapMgr.GetFieldStatistics(featureClass, dataField, true); respList.Add(new DialogueResponse(DialogueResponseType.speechInfo, "Here are the statistic results of " + dataFieldName)); respList.Add(new DialogueResponse(DialogueResponseType.statisticResults, statResults)); } // change its own state actionNode.ActState = ActionState.Complete; // generate response return respList; }
private ArrayList ChooseSpecificationMethod(ActionNode actionNode, DialogueAct currDlgAct) { ArrayList respList = new ArrayList(); // change its own state actionNode.ActState = ActionState.Executing; // do something: respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, "Basic Action: ChooseSpecificationMethod")); ActionNode parent = (ActionNode)actionNode.Parent; if (parent != null) { foreach (ParamNode param in parent.Params) { if (param.ParamType == "region_type" && param.ParamState == ParamState.Ready) { string region_type = param.Values[0].ToString(); respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, "Region Type:" + region_type)); string chosenActionName = ""; if (region_type == "features") { // select features in the region chosenActionName = "Specify Region By Attributes"; } else if (region_type == "drawing") { // select features in the region chosenActionName = "Specify Region By Drawing"; } else if (region_type == "buffer") { // select features in the region chosenActionName = "Specify Region By Buffer"; } if (chosenActionName != "") { respList.Add(new DialogueResponse(DialogueResponseType.newAgendaItem, chosenActionName)); } // change its own state actionNode.ActState = ActionState.Complete; return respList; } } } // change its own state actionNode.ActState = ActionState.Complete; // generate response return respList; }
private ArrayList CalculateDataSummary(ActionNode actionNode, DialogueAct currDlgAct) { ArrayList respList = new ArrayList(); // change its own state actionNode.ActState = ActionState.Executing; // do something: respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, "Basic Action: CalculateDataSummary")); ActionNode parentNode = ((ActionNode)(actionNode.Parent)); string featureClass = ""; bool selectedOnly = false; // search for overlay first ArrayList featureClassValues = this._searchValueFromAncestor(actionNode, "overlay"); if (featureClassValues.Count == 0) { featureClassValues = this._searchValueFromAncestor(actionNode, "feature_class"); selectedOnly = true; } if (featureClassValues.Count > 0) { featureClass = featureClassValues[0].ToString(); } string sumFieldName = ""; ArrayList sumFieldValues = this._searchValueFromAncestor(actionNode, "summarize_field"); if (sumFieldValues.Count > 0) { sumFieldName = sumFieldValues[0].ToString(); } sumFieldName = this._dataFieldMapping(sumFieldName); string statistics = ""; ArrayList statisticsValues = this._searchValueFromAncestor(actionNode, "statistics"); if (statisticsValues.Count > 0) { statistics = statisticsValues[0].ToString(); } string grpFieldName = ""; ArrayList grpFieldValues = this._searchValueFromAncestor(actionNode, "group_by_field"); if (grpFieldValues.Count > 0) { grpFieldName = grpFieldValues[0].ToString(); } grpFieldName = this._dataFieldMapping(grpFieldName); if (featureClass != "" && sumFieldName != "" && grpFieldName != "") { string summaryFields = "Minimum." + grpFieldName + ", "; switch (statistics) { case "count": summaryFields += "Count." + sumFieldName; break; case "sum": summaryFields += "Sum." + sumFieldName; break; case "minimum": summaryFields += "Minimum." + sumFieldName; break; case "maximum": summaryFields += "Maximum." + sumFieldName; break; case "mean": summaryFields += "Average." + sumFieldName; break; case "std": summaryFields += "StdDev." + sumFieldName; break; default: summaryFields += "Count." + sumFieldName; summaryFields += ", "; summaryFields += "Sum." + sumFieldName; summaryFields += ", "; summaryFields += "Minimum." + sumFieldName; summaryFields += ", "; summaryFields += "Maximum." + sumFieldName; summaryFields += ", "; summaryFields += "Average." + sumFieldName; summaryFields += ", "; summaryFields += "StdDev." + sumFieldName; break; } Hashtable sumResults = this._mapMgr.GetDataSummary(featureClass, summaryFields, grpFieldName, selectedOnly); respList.Add(new DialogueResponse(DialogueResponseType.speechInfo, "Here are the summary of " + sumFieldName + " grouped by " + grpFieldName)); respList.Add(new DialogueResponse(DialogueResponseType.summaryResults, sumResults)); } // change its own state actionNode.ActState = ActionState.Complete; // generate response return respList; }
private ArrayList SpecifyRegionByBuffer(ActionNode actionNode, DialogueAct currDlgAct) { ArrayList respList = new ArrayList(); // change its own state actionNode.ActState = ActionState.Executing; // do something: respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, "MOCKUP Action: SpecifyRegionByBuffer")); // change its own state actionNode.ActState = ActionState.Complete; // generate response return respList; }
private ArrayList BufferOp(ActionNode actionNode, DialogueAct currDlgAct) { ArrayList respList = new ArrayList(); // change its own state actionNode.ActState = ActionState.Executing; // do something: calculate the buffer ActionNode parentAct = (ActionNode)actionNode.Parent; string inputLayer = parentAct.GetParamValue("input_layer")[0].ToString(); Hashtable distInfo = (Hashtable)(parentAct.GetParamValue("distance")[0]); string distString = distInfo["value"].ToString(); if (distInfo.ContainsKey("unit")) { distString += " " + distInfo["unit"].ToString(); } // todo: convert the unit if needed if (inputLayer != "" && distString != "") { string outLayerFile = ((IGeoProcessor)this._mapMgr).Buffer(inputLayer, distString); if (outLayerFile.Length > 0) { respList.Add(new DialogueResponse(DialogueResponseType.mapLayerAdded, outLayerFile)); // change its own state actionNode.ActState = ActionState.Complete; return respList; } } // change its own state actionNode.ActState = ActionState.Failed; // generate response return respList; }
private ArrayList GetCurrentMapExtent(ActionNode actionNode, DialogueAct currDlgAct) { ArrayList respList = new ArrayList(); // change its own state actionNode.ActState = ActionState.Executing; // do something: ParamNode paramNode = (ParamNode)actionNode.Parent; object newValue = this._mapMgr.GetMapExtent(); this._addValueToParam(paramNode, newValue); respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, "Basic Action: GetCurrentMapExtent")); // change its own state actionNode.ActState = ActionState.Complete; // generate response return respList; }
private ArrayList AskForValue(ActionNode actionNode, DialogueAct currDlgAct) { ArrayList respList = new ArrayList(); // if the action has not been executed, set it to executing, raid the question and return if (actionNode.ActState == ActionState.Initiated) { // change its own state actionNode.ActState = ActionState.Executing; // do something: raise a question to the user respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, "Basic Action: AskForValue")); ParamNode paramNode = (ParamNode)actionNode.Parent; // only ask if there is no value assigned yet if (paramNode.Values.Count == 0) { respList.Add(new DialogueResponse(DialogueResponseType.speechQuestion, this._generateQuestionString(paramNode))); // change its own state actionNode.ActState = ActionState.Executing; return respList; } else { // change its own state actionNode.ActState = ActionState.Complete; // generate response return respList; } } // if the action is executing, try to check whether the current input answers the question else if (actionNode.ActState == ActionState.Executing) { ParamNode paramNode = (ParamNode)actionNode.Parent; if (currDlgAct.DlgActType == DialogueActType.Answer) { foreach (string phrase in currDlgAct.SpeechContext.Keys) { if (phrase.ToLower() == paramNode.Name.ToLower()) { object newValue = this._parseValueFromSpeech(paramNode, currDlgAct.SpeechContext[phrase]); if (newValue != null) { this._addValueToParam(paramNode, newValue); // change its own state actionNode.ActState = ActionState.Complete; // generate response return respList; } } } } else if (currDlgAct.DlgActType == DialogueActType.Accept && paramNode.ParamType == "boolean") { this._addValueToParam(paramNode, true); respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, paramNode.Name + ": true")); actionNode.ActState = ActionState.Complete; return respList; } else if (currDlgAct.DlgActType == DialogueActType.Accept && paramNode.ParamType == "boolean") { this._addValueToParam(paramNode, true); respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, paramNode.Name + ": false")); actionNode.ActState = ActionState.Complete; return respList; } } // change its own state actionNode.ActState = ActionState.Complete; // generate response return respList; }
private ArrayList InferValueFromOtherParameter(ActionNode actionNode, DialogueAct currDlgAct) { ArrayList respList = new ArrayList(); // change its own state actionNode.ActState = ActionState.Executing; // do something: respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, "Basic Action: InferValueFromOtherParameter")); ParamNode paramNode = (ParamNode)actionNode.Parent; string [] paramNames = paramNode.Name.Split('.'); if (paramNames.Length > 1 && paramNames[1] == "multiple" && paramNode.ParamType == "boolean") { PlanNode parent = paramNode; string ancestorParamName = paramNames[0]; ParamNode matchedParam = null; while (parent != null) { if (parent.Parent is ParamNode) { ParamNode ancestorParam = parent.Parent as ParamNode; if (ancestorParam.Name.ToLower() == ancestorParamName.ToLower() && ancestorParam.ParamState == ParamState.Ready) { matchedParam = ancestorParam; break; } } else if (parent.Parent is ActionNode) { ActionNode ancestorAction = parent.Parent as ActionNode; foreach (ParamNode ancestorParam in ancestorAction.Params) { if (ancestorParam.Name.ToLower() == ancestorParamName.ToLower() && ancestorParam.ParamState == ParamState.Ready) { matchedParam = ancestorParam; break; } } if (matchedParam != null) { break; } } parent = parent.Parent; } if (matchedParam != null) { if (matchedParam.Values.Count > 1) { this._addValueToParam(paramNode, true); respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, paramNode.Name + ": true")); } else if (matchedParam.Values.Count == 1) { this._addValueToParam(paramNode, false); respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, paramNode.Name + ": false")); } } } // change its own state actionNode.ActState = ActionState.Complete; // generate response return respList; }
public ArrayList Execute(ActionNode actionNode, DialogueAct currDlgAct) { if (actionNode.Name.ToLower() == "Get Value From Input".ToLower()) { return this.GetValueFromInput(actionNode, currDlgAct); } else if (actionNode.Name.ToLower() == "Ask For Value".ToLower()) { return this.AskForValue(actionNode, currDlgAct); } else if (actionNode.Name.ToLower() == "Select From Candidates".ToLower()) { return this.SelectFromCandidates(actionNode, currDlgAct); } else if (actionNode.Name.ToLower() == "Get Existing Value From Ancestor".ToLower()) { return this.GetExistingValueFromAncestor(actionNode, currDlgAct); } else if (actionNode.Name.ToLower() == "Ask For More Value".ToLower()) { return this.AskForMoreValue(actionNode, currDlgAct); } else if (actionNode.Name.ToLower() == "Identify Region Type".ToLower()) { return this.IdentifyRegionType(actionNode, currDlgAct); } else if (actionNode.Name.ToLower() == "Choose Specification Method".ToLower()) { return this.ChooseSpecificationMethod(actionNode, currDlgAct); } else if (actionNode.Name.ToLower() == "Specify Region By Attributes".ToLower()) { return this.SpecifyRegionByAttributes(actionNode, currDlgAct); } else if (actionNode.Name.ToLower() == "Specify Region By Drawing".ToLower()) { return this.SpecifyRegionByDrawing(actionNode, currDlgAct); } else if (actionNode.Name.ToLower() == "Specify Region By Buffer".ToLower()) { return this.SpecifyRegionByBuffer(actionNode, currDlgAct); } else if (actionNode.Name.ToLower() == "Ask For Partiality".ToLower()) { return this.AskForPartiality(actionNode, currDlgAct); } else if (actionNode.Name.ToLower() == "Get Current Map Extent".ToLower()) { return this.GetCurrentMapExtent(actionNode, currDlgAct); } else if (actionNode.Name.ToLower() == "Draw Region".ToLower()) { return this.DrawRegion(actionNode, currDlgAct); } else if (actionNode.Name.ToLower() == "Infer Value From Other Parameter".ToLower()) { return this.InferValueFromOtherParameter(actionNode, currDlgAct); } else if (actionNode.Name.ToLower() == "Choose Analytic Functions".ToLower()) { return this.ChooseAnalyticFunctions(actionNode, currDlgAct); } else if (actionNode.Name.ToLower() == "Perform Selection".ToLower()) { return this.PerformSelection(actionNode, currDlgAct); } else if (actionNode.Name.ToLower() == "Perform Overlay".ToLower()) { return this.PerformOverlay(actionNode, currDlgAct); } else if (actionNode.Name.ToLower() == "Calculate Field Statistics".ToLower()) { return this.CalculateFieldStatistics(actionNode, currDlgAct); } else if (actionNode.Name.ToLower() == "Calculate Data Summary".ToLower()) { return this.CalculateDataSummary(actionNode, currDlgAct); } return new ArrayList(); }
private ArrayList BasicActionTemplate(ActionNode actionNode, DialogueAct currDlgAct) { ArrayList respList = new ArrayList(); // change its own state actionNode.ActState = ActionState.Executing; // do something: respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, "Basic Action: ")); // change its own state actionNode.ActState = ActionState.Complete; // generate response return respList; }
private ArrayList SelectFromCandidates(ActionNode actionNode, DialogueAct currDlgAct) { ArrayList respList = new ArrayList(); if (actionNode.ActState == ActionState.Initiated) { // change its own state actionNode.ActState = ActionState.Executing; // do something: generate the candiate list respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, "Basic Action: SelectFromCandidates")); ParamNode paramNode = (ParamNode)actionNode.Parent; if (paramNode.Name == "admin_area") { // fixed at the moment, future work will search the database to generat the list PlainOptionListData respContent = new PlainOptionListData(); respContent.Opening = this._generateQuestionString(paramNode); respContent.AddOption(new PlainOptionItemData("City of Oleader", "Matched feature classes: LandUse")); respContent.AddOption(new PlainOptionItemData("City of Rochester", "Matched feature classes: LandUse, Parcels")); respContent.AddOption(new PlainOptionItemData("City of Baltimore", "Matched feature classes: Parcels, Dwelling units")); respList.Add(new DialogueResponse(DialogueResponseType.listPlainOptions, respContent)); return respList; } } // if the action is executing, try to check whether the current input answers the question else if (actionNode.ActState == ActionState.Executing) { ParamNode paramNode = (ParamNode)actionNode.Parent; foreach (string phrase in currDlgAct.SpeechContext.Keys) { if (phrase.ToLower() == paramNode.Name.ToLower()) { object newValue = this._parseValueFromSpeech(paramNode, currDlgAct.SpeechContext[phrase]); if (newValue != null) { this._addValueToParam(paramNode, newValue); // change its own state actionNode.ActState = ActionState.Complete; // generate response if (paramNode.ParamType == "data_source") { // fixed at the moment string dataSourcePath = @"..\..\..\Data\GISLAB\Data\"; foreach (string value in paramNode.Values) { string filePath = System.IO.Path.Combine(dataSourcePath, value + ".mxd"); if (System.IO.File.Exists(filePath)) { respList.Add(new DialogueResponse(DialogueResponseType.mapDocumentOpened, filePath)); respList.Add(new DialogueResponse(DialogueResponseType.speechInfo, "The map of " + value + " is loaded!")); break; } } } return respList; } } } } // change its own state actionNode.ActState = ActionState.Complete; // generate response return respList; }
private ActionNode _explainActionFromNode(PlanNode planNode, Hashtable tempAct, DialogueAct dlgAct) { if (planNode is ActionNode) { ActionNode actionNode = (ActionNode)planNode; if (actionNode.Name.ToLower() == tempAct["name"].ToString().ToLower()) { // If the action has not been initiated, initiate it and add the agent if (actionNode.ActState == ActionState.Unknown) { actionNode.ActState = ActionState.Initiated; } if (actionNode.SearchAgent(dlgAct.Agent) == null) { actionNode.Agents.Add(dlgAct.Agent); } // If the action has been completed, or failed, start a new one, attached it to the same parent if (actionNode.ActState == ActionState.Complete || actionNode.ActState == ActionState.Failed) { ActionNode newAction = new ActionNode((string)tempAct["name"], (string)tempAct["act_type"], (string)tempAct["complexity"], (string)tempAct["description"], actionNode.Parent); newAction.Agents.Add(dlgAct.Agent); newAction.ActState = ActionState.Initiated; if (actionNode.Parent != null) { if (actionNode.Parent is ActionNode) { ((ActionNode)(actionNode.Parent)).SubActions.Add(newAction); } else if (actionNode.Parent is ParamNode) { ((ParamNode)(actionNode.Parent)).SubActions.Add(newAction); } } return newAction; } return actionNode; } // search the params and subactions foreach (ParamNode paramNode in actionNode.Params) { ActionNode actNode = this._explainActionFromNode(paramNode, tempAct, dlgAct); if (actNode != null) { return actNode; } } foreach (ActionNode subActNode in actionNode.SubActions) { ActionNode actNode = this._explainActionFromNode(subActNode, tempAct, dlgAct); if (actNode != null) { return actNode; } } } else if (planNode is ParamNode) { ParamNode paramNode = (ParamNode)planNode; foreach (ActionNode subActNode in paramNode.SubActions) { ActionNode actNode = this._explainActionFromNode(subActNode, tempAct, dlgAct); if (actNode != null) { return actNode; } } } return null; }
private ArrayList GetExistingValueFromAncestor(ActionNode actionNode, DialogueAct currDlgAct) { ArrayList respList = new ArrayList(); // change its own state actionNode.ActState = ActionState.Executing; // do something: respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, "Basic Action: GetExistingValueFromAncestor")); ParamNode paramNode = (ParamNode)actionNode.Parent; PlanNode parent = paramNode; while (parent != null) { if (parent.Parent is ParamNode) { ParamNode ancestorParam = parent.Parent as ParamNode; if (ancestorParam.ParamType == paramNode.ParamType && ancestorParam.ParamState == ParamState.Ready) { foreach (object value in ancestorParam.Values) { this._addValueToParam(paramNode, value); } } } else if (parent.Parent is ActionNode) { ActionNode ancestorAction = parent.Parent as ActionNode; foreach (ParamNode param in ancestorAction.Params) { if (param != paramNode) { if (param.ParamType == paramNode.ParamType && param.ParamState == ParamState.Ready) { foreach (object value in param.Values) { this._addValueToParam(paramNode, value); } } } } } parent = parent.Parent; } // change its own state actionNode.ActState = ActionState.Complete; // generate response return respList; }
private void _elaborateFromActionNode(ActionNode actionNode) { // check the parameters and constraints bool paramsRdy = this._parentParamsRdy(actionNode); // check whether the params are ready if (paramsRdy == false) { return; } // If the action is a basic one and can be executed, then execute it if (actionNode.Complexity == "basic") { // check the state of the action if (actionNode.ActState == ActionState.Initiated || actionNode.ActState == ActionState.Executing) { // perform the task ArrayList execResp = this._exec.Execute(actionNode, this._currDlgAct); // add the execution response to the response list ArrayList newAgendaItems = new ArrayList(); foreach (DialogueResponse resp in execResp) { if (resp.DlgRespType == DialogueResponseType.newAgendaItem) { newAgendaItems.Add(resp.RespContent); } else { this._respList.Add(resp); } } // remove the running/complete action from the agenda; if (actionNode.ActState == ActionState.Complete) { this.RemoveFromAgenda(actionNode); } // check whether the parent's state is also complete if the action is complete if (actionNode.ActState == ActionState.Complete) { this._updateParentState(actionNode); } // perform the new agenda item foreach (string actionName in newAgendaItems) { if (actionName != "") { // only search parent level at the moment ActionNode parentNode = (ActionNode)actionNode.Parent; foreach (ActionNode subAct in parentNode.SubActions) { if (subAct.Name.ToLower() == actionName.ToLower()) { if (subAct.ActState == ActionState.Unknown) { subAct.ActState = ActionState.Initiated; int idx = this.GetIndexInAgenda(actionNode); this.AddToAgenda(subAct, idx + 1); this.ElaborateFromNode(subAct); break; } } } } } } return; } if (actionNode.Complexity == "complex") { // check the state of the action if (actionNode.ActState == ActionState.Initiated) { // find and load the recipe this._loadRecipe(actionNode); } if (actionNode.ActState == ActionState.Planned) { int idx = this.RemoveFromAgenda(actionNode); foreach (ParamNode param in actionNode.Params) { idx = this.AddToAgenda(param, idx); idx++; } foreach (ActionNode subAct in actionNode.SubActions) { idx = this.AddToAgenda(subAct, idx); idx++; } // elaborate on the params foreach (ParamNode param in actionNode.Params) { param.ParamState = ParamState.InPreparation; this._elaborateFromParamNode(param); } foreach (ActionNode subAct in actionNode.SubActions) { if (subAct.Optional == false) { subAct.ActState = ActionState.Initiated; this._elaborateFromActionNode(subAct); } else { this.RemoveFromAgenda(subAct); } } } } }
private ArrayList AskForMoreValue(ActionNode actionNode, DialogueAct currDlgAct) { ArrayList respList = new ArrayList(); if (actionNode.ActState == ActionState.Initiated) { // change its own state actionNode.ActState = ActionState.Executing; // do something: generate the candiate list respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, "Basic Action: AskForMoreValue")); ParamNode paramNode = (ParamNode)actionNode.Parent; if (paramNode.Name == "feature_class") { // fixed at the moment, future work will search the database to generate the list MapLayerOptionListData respContent = new MapLayerOptionListData(); //respContent.Opening = this._generateQuestionString(paramNode); respContent.Opening = "You may want to consider adding the following layers to the map as background:"; respContent.AddOption(new MapLayerOptionItemData("Lot boundaries", @"C:\Work\Data\GISLAB\Data\Oleader\Lot Boundaries.lyr")); respContent.AddOption(new MapLayerOptionItemData("Zoning", @"C:\Work\Data\GISLAB\Data\Oleader\Zoning.lyr")); respContent.AddOption(new MapLayerOptionItemData("Flood areas", @"C:\Work\Data\GISLAB\Data\Oleader\Flood Areas.lyr")); respList.Add(new DialogueResponse(DialogueResponseType.listMapLayerOptions, respContent)); return respList; } } // if the action is executing, try to check whether the current input answers the question else if (actionNode.ActState == ActionState.Executing) { ParamNode paramNode = (ParamNode)actionNode.Parent; foreach (string phrase in currDlgAct.SpeechContext.Keys) { if (phrase.ToLower() == paramNode.Name.ToLower()) { object newValue = this._parseValueFromSpeech(paramNode, currDlgAct.SpeechContext[phrase]); if (newValue != null) { this._addValueToParam(paramNode, newValue); // change its own state actionNode.ActState = ActionState.Complete; // generate response if (paramNode.ParamType == "feature_class") { // fixed at the moment string dataSourcePath = @"C:\Work\Data\GISLAB\Data\Oleader\"; string filePath = System.IO.Path.Combine(dataSourcePath + (string)newValue + ".lyr"); if (System.IO.File.Exists(filePath)) { respList.Add(new DialogueResponse(DialogueResponseType.mapLayerAdded, filePath)); } } return respList; } } } } // change its own state actionNode.ActState = ActionState.Complete; // generate response return respList; }
private void _loadRecipe(ActionNode actionNode) { ArrayList recipeList = this._kbase.SearchRecipe(actionNode.Name); if (recipeList.Count == 0) { this._respList.Add(new DialogueResponse(DialogueResponseType.speechError, "There is no recipe for action " + actionNode.Name + " in the knowledge base!")); return; } // todo: select from multiple recipes? // load the first one atm Hashtable recipeInfo = (Hashtable)recipeList[0]; string recipeXMl = recipeInfo["content"].ToString(); bool parsed = this._parseRecipeXML(recipeXMl, actionNode); // if succeed, set the action state to planned, set the states of children, remove the node from the agenda if (parsed == true) { actionNode.ActState = ActionState.Planned; } }
private ArrayList IdentifyRegionType(ActionNode actionNode, DialogueAct currDlgAct) { ArrayList respList = new ArrayList(); if (actionNode.ActState == ActionState.Initiated) { // change its own state actionNode.ActState = ActionState.Executing; // do something: generate the candiate list respList.Add(new DialogueResponse(DialogueResponseType.debugInfo, "Basic Action: IdentifyRegionType")); ParamNode paramNode = (ParamNode)actionNode.Parent; if (paramNode.Name == "region_type") { // fixed at the moment OptionWithExampleListData respContent = new OptionWithExampleListData(); respContent.Opening = this._generateQuestionString(paramNode); respContent.Opening = "Please describe exactly the region you are interested in. You may choose one of the three methods:"; respContent.AddOption(new OptionWithExampleItemData("Draw the region manually on the map", "The region is drawn manually", "/CAGA;component/Images/region_drawing.png")); respContent.AddOption(new OptionWithExampleItemData("Define a region from selection of area features", "The region is a set of areal features", "/CAGA;component/Images/region_attributes.png")); respContent.AddOption(new OptionWithExampleItemData("Define region from neighborhood of selected features", "The region is a buffer zone around some feature", "/CAGA;component/Images/region_buffer.png")); respList.Add(new DialogueResponse(DialogueResponseType.listOptionsWithExamples, respContent)); return respList; } } // if the action is executing, try to check whether the current input answers the question else if (actionNode.ActState == ActionState.Executing) { ParamNode paramNode = (ParamNode)actionNode.Parent; foreach (string phrase in currDlgAct.SpeechContext.Keys) { if (phrase.ToLower() == paramNode.Name.ToLower()) { object newValue = this._parseValueFromSpeech(paramNode, currDlgAct.SpeechContext[phrase]); if (newValue != null) { this._addValueToParam(paramNode, newValue); // change its own state actionNode.ActState = ActionState.Complete; return respList; } } } } // change its own state actionNode.ActState = ActionState.Complete; // generate response return respList; }
public RefNode(ActionNode tmpAct) { // set the properties of the refnode based on the recipe retrieved for tmpAct // check for readiness of the node for execution, if yes, turn status to be ready }
public bool Explain(DialogueAct dlgAct) { string indent = ""; Console.WriteLine(indent + "Dialogue.PlanGraph Explain " + dlgAct.DlgActType); bool isExplained = false; if (dlgAct.DlgActType == DialogueActType.Intend) { // search the actions from knowledge base // the simplest way: search based on name matching ArrayList tempActions = new ArrayList(); SortedList tmpSortedList = new SortedList(); foreach (object phrase in dlgAct.SpeechContext.Values) { if (phrase is string) { Console.WriteLine(indent + "string:" + phrase); Hashtable tempAct = this._kbase.SearchAction((string)phrase); if (tempAct != null) { tempActions.Add(tempAct); } } else if (phrase is SortedList) { foreach (DictionaryEntry item in (SortedList)phrase) { tmpSortedList.Add(item.Key, item.Value); Console.WriteLine(indent + "key:" + item.Key + ",value=" + item.Value); } } } foreach (DictionaryEntry item in tmpSortedList) { dlgAct.SpeechContext.Add(item.Key, item.Value); } // Explain the actions into the plangraph ArrayList explainedActs = new ArrayList(); foreach (Hashtable tempAct in tempActions) { ActionNode explainedAct = this._explainAction(tempAct, dlgAct, indent + " "); if (explainedAct != null) { explainedActs.Add(explainedAct); AddToAgenda(explainedAct, 0, indent + " "); } } if (explainedActs.Count > 0) { isExplained = true; } } else if (dlgAct.DlgActType == DialogueActType.Answer) { // the input is an answer to previous question, // explain in the agenda foreach (PlanNode planNode in this._agenda.ToArray()) { isExplained = this._explainAnswer(planNode, dlgAct, indent + " "); if (isExplained == true) { break; } } } else if (dlgAct.DlgActType == DialogueActType.Accept || dlgAct.DlgActType == DialogueActType.Reject) { // the input is an affirmative or neagtive to previous question, // explain in the agenda foreach (PlanNode planNode in this._agenda.ToArray()) { isExplained = this._explainAffOrNeg(planNode, dlgAct, indent + " "); if (isExplained == true) { break; } } } else if (dlgAct.DlgActType == DialogueActType.Feedback) { // the input is a feedback to previous action, // explain in the agenda foreach (PlanNode planNode in this._agenda.ToArray()) { isExplained = this._explainFeedback(planNode, dlgAct, indent + " "); if (isExplained == true) { break; } } } else if (dlgAct.DlgActType == DialogueActType.Correct) { Console.WriteLine("DialogueActType.Correct"); if (this._actionNodeStack.Count > 0) { ActionNode tmpAction = _actionNodeStack.Peek(); Console.WriteLine("preAction=" + tmpAction.Name); foreach (ParamNode param in tmpAction.Params) { Console.WriteLine("param=" + param.Name); Console.WriteLine("DialogueActType.Correct"); if ((param.ParamState == ParamState.Ready) && (dlgAct.SpeechContext.ContainsKey(param.Name))) { object newValue = _exec._parseValueFromSpeech(param, dlgAct.SpeechContext[param.Name]); if (newValue != null) { _exec._addValueToParam(param, newValue, indent); isExplained = true; } } } if (isExplained == true) { foreach (ActionNode subAct in tmpAction.SubActions) { Console.WriteLine("subAct=" + subAct.Name); subAct.ActState = ActionState.Executing; AddToAgenda(subAct, 0, indent + " "); } foreach (PlanNode planNode in this._agenda.ToArray()) { if (planNode is ActionNode) { ((ActionNode)planNode).ActState = ActionState.Initiated; } if (planNode is ParamNode) { ((ParamNode)planNode).ParamState = ParamState.InPreparation; } } } } } if (isExplained == true) { this._currDlgAct = dlgAct; } Console.WriteLine(indent + "Agenda:"); foreach (PlanNode planNode in this._agenda.ToArray()) { Console.WriteLine(indent + "-" + planNode.Name); } Console.WriteLine(indent + "IsExplained? " + isExplained); return(isExplained); }