private static string TextFromConstituencyTree(ConstituencyTreeNode node, string tree) { ConstituencyTreeNode previous = null; foreach (ConstituencyTreeNode n in node.Children) { if (previous != n.previousNode) { throw new FormatException(); } if (previous != null && previous.nextNode != n) { throw new FormatException(); } previous = n; if (n.word == null) { tree += " (" + n.PoS; tree = TextFromConstituencyTree(n, tree); tree += ")"; } else { tree += " (" + n.PoS + " " + n.word + ")"; } } return(tree); }
private static void FormatConstituencyTree(ConstituencyTreeNode node, int level, int col, string[] printLines, int debugLevel) { if (level != node.level) { throw new FormatException(); } if (printLines[level] == null) { printLines[level] = "|"; } if (col - printLines[level].Length - 1 > 0) { printLines[level] += string.Empty.PadRight(col - printLines[level].Length - 1, ' ') + "|"; } foreach (ConstituencyTreeNode n in node.Children) { string debugInfo = debugLevel < 4 ? string.Empty : "(" + n.parentNode.PoS + " " + n.level + "/" + n.maxDepth + ")"; if (n.word == null) { int previousLen = printLines[level].Length; FormatConstituencyTree(n, level + 1, previousLen, printLines, debugLevel); int len = printLines[level + 1].Length - previousLen - n.PoS.Length - 1; int left = len / 2; int right = len - left; printLines[level] += string.Empty.PadRight(left, '-') + n.PoS + debugInfo + string.Empty.PadRight(right, '-') + "|"; } else { printLines[level] += " " + n.PoS + debugInfo + ":" + n.word + " |"; } } }
private static string ConstituencyTreeFromText(string parse, ConstituencyTreeNode node, ConstituencyTreeNode root) { ConstituencyTreeNode previous = null; while (!string.IsNullOrWhiteSpace(parse) && parse[0] == '(') { int lastIndex = parse.IndexOfAny(" ()".ToCharArray(), 1); char lastChar = parse[lastIndex]; string gu = parse.Substring(1, lastIndex - 1); parse = parse.Substring(lastIndex).TrimStart(); ConstituencyTreeNode child; switch (lastChar) { case ' ': lastIndex = parse.IndexOfAny("()".ToCharArray()); string wo = parse.Substring(0, lastIndex); parse = parse.Substring(lastIndex).TrimStart(); child = node.AddChild(new ConstituencyTreeNode(gu, wo)); child.level = node.level + 1; if (root.nextWord == null) { root.nextWord = child; } else { root.previousWord.nextWord = child; } child.previousWord = root.previousWord; root.previousWord = child; break; case '(': child = node.AddChild(new ConstituencyTreeNode(gu)); child.level = node.level + 1; parse = ConstituencyTreeFromText(parse, child, root); break; default: throw new FormatException(); } if (parse[0] != ')') { throw new FormatException(); } parse = parse.Substring(1).TrimStart(); child.parentNode = node; child.previousNode = previous; if (previous != null) { previous.nextNode = child; } previous = child; if (child.maxDepth + 1 > node.maxDepth) { node.maxDepth = child.maxDepth + 1; } } return(parse); }
public static ConstituencyTreeNode ConstituencyTreeFromText(string parse) { parse = parse.Replace(" (", "("); ConstituencyTreeNode root = new ConstituencyTreeNode("root"); parse = ConstituencyTreeFromText(parse, root, root); return(root); }
private static string WordsFromConstituencyTree(ConstituencyTreeNode node, string words) { node = node.nextWord; if (node != null) { words += node.word + " "; words = WordsFromConstituencyTree(node, words); } return(words); }
public override async System.Threading.Tasks.Task <CallServiceResponse <IGenericServiceResponse> > CallServiceAsync(string text, System.Collections.Generic.Dictionary <string, string> apiArgs) { Log.WriteLine("MicrosoftCognitiveParseServices: Text:" + text); if (MicrosoftCognitiveParseAnalyzersServices.ParseAnalysers == null) // calling ParseAnalyzersService. It's a dependency of ParseService. { CallServiceResponse <IGenericServiceResponse> responseAnalyzers = new CallServiceResponse <IGenericServiceResponse>(service); MicrosoftCognitiveParseAnalyzersServices parseAnalyersService = new MicrosoftCognitiveParseAnalyzersServices(Options.services["MicrosoftCognitiveParseAnalyzersService"].service); responseAnalyzers = await parseAnalyersService.CallServiceAsync(text, apiArgs); if (MicrosoftCognitiveParseAnalyzersServices.ParseAnalysers == null || MicrosoftCognitiveParseAnalyzersServices.ParseAnalysers.Length == 0 || string.IsNullOrWhiteSpace(MicrosoftCognitiveParseAnalyzersServices.ParseAnalyzerStringized)) { throw new InvalidOperationException(); // can't continue without at least one Analyzer } } CallServiceResponse <IGenericServiceResponse> response = new CallServiceResponse <IGenericServiceResponse>(service); response.Request = Array.Find(service.requests, p => p.argType == "text"); System.Collections.Generic.List <Tuple <string, string> > jsonSubstitutes = new System.Collections.Generic.List <Tuple <string, string> >() { new Tuple <string, string>("{AnalyzerStringized}", MicrosoftCognitiveParseAnalyzersServices.ParseAnalyzerStringized), }; await HttpMethods.CallApiAsync(response, null, null, jsonSubstitutes, text, apiArgs); // example of using jsonSubstitutes await HttpMethods.ExtractResultAsync(response); Newtonsoft.Json.Linq.JArray arrayOfResults = Newtonsoft.Json.Linq.JArray.Parse(response.ResponseResult); foreach (Newtonsoft.Json.Linq.JToken s in arrayOfResults) { ConstituencyTreeNode root = ParseHelpers.ConstituencyTreeFromText(s.ToString()); string textTree = ParseHelpers.TextFromConstituencyTree(root); if (textTree != s.ToString()) { throw new FormatException(); } string words = ParseHelpers.WordsFromConstituencyTree(root); string[] printLines = ParseHelpers.FormatConstituencyTree(root); foreach (string p in printLines) { Console.WriteLine(p); } } return(response); }
public static string WordsFromConstituencyTree(ConstituencyTreeNode node) { return(WordsFromConstituencyTree(node, "")); }
public static string TextFromConstituencyTree(ConstituencyTreeNode node) { return(TextFromConstituencyTree(node, "").Trim()); }
public ConstituencyTreeNode AddChild(ConstituencyTreeNode node) { Children.Add(node); return(node); }
public static string[] FormatConstituencyTree(ConstituencyTreeNode node) { string[] printLines = new string[node.maxDepth]; FormatConstituencyTree(node, 0, 0, printLines, 0); return(printLines); }