public WordNodePair(ParseNodeDrawable parseNodeDrawable, int no)
{
_node = parseNodeDrawable;
_annotatedWord = new AnnotatedWord(parseNodeDrawable.GetLayerData());
_doneForConnect = false;
_no = no;
}
protected override void AutoDetectMoney(ParseTreeDrawable parseTree)
{
NodeDrawableCollector nodeDrawableCollector = new NodeDrawableCollector((ParseNodeDrawable)parseTree.GetRoot(), new IsTurkishLeafNode());
List <ParseNodeDrawable> leafList = nodeDrawableCollector.Collect();
for (int i = 0; i < leafList.Count; i++)
{
ParseNodeDrawable parseNode = leafList[i];
if (!parseNode.LayerExists(ViewLayerType.NER))
{
String word = parseNode.GetLayerData(ViewLayerType.TURKISH_WORD).ToLower(new CultureInfo("tr"));
if (Word.IsMoney(word))
{
parseNode.GetLayerInfo().SetLayerData(ViewLayerType.NER, "MONEY");
int j = i - 1;
while (j >= 0)
{
ParseNodeDrawable previous = leafList[j];
if (previous.GetParent().GetData().GetName().Equals("CD"))
{
previous.GetLayerInfo().SetLayerData(ViewLayerType.NER, "MONEY");
}
else
{
break;
}
j--;
}
}
}
}
}
public override bool Satisfies(ParseNodeDrawable parseNode)
{
var layerInfo = parseNode.GetLayerInfo();
return(base.Satisfies(parseNode) && layerInfo != null && layerInfo.GetArgument() != null &&
layerInfo.GetArgument().GetArgumentType().Equals("PREDICATE"));
}
private void NodeModify(ParseNodeDrawable parseNode)
{
_nodeModifier.Modifier(parseNode);
for (var i = 0; i < parseNode.NumberOfChildren(); i++)
{
NodeModify((ParseNodeDrawable)parseNode.GetChild(i));
}
}
public override bool Satisfies(ParseNodeDrawable parseNode)
{
if (base.Satisfies(parseNode))
{
return(!new IsNullElement().Satisfies(parseNode));
}
return(false);
}
public override bool Satisfies(ParseNodeDrawable parseNode)
{
if (base.Satisfies(parseNode))
{
var data = parseNode.GetLayerData(ViewLayerType.ENGLISH_WORD);
return(Word.IsPunctuation(data) && !data.Equals("$"));
}
return(false);
}
public override bool Satisfies(ParseNodeDrawable parseNode)
{
if (base.Satisfies(parseNode))
{
var parentData = parseNode.GetParent().GetData().GetName();
return(parentData.Equals("NNP") || parentData.Equals("NNPS"));
}
return(false);
}
public override bool Satisfies(ParseNodeDrawable parseNode)
{
if (base.Satisfies(parseNode))
{
var data = parseNode.GetLayerData(_secondLanguage);
return(data != null && data.Equals("*NONE*"));
}
return(false);
}
public bool Satisfies(ParseNodeDrawable parseNode)
{
if (parseNode.NumberOfChildren() > 0)
{
return(parseNode.GetData().ToString().Equals(_symbol));
}
return(false);
}
public override bool Satisfies(ParseNodeDrawable parseNode)
{
if (base.Satisfies(parseNode))
{
var data = parseNode.GetLayerData(ViewLayerType.ENGLISH_WORD);
var parentData = parseNode.GetParent().GetData().GetName();
return(data.Contains("*") || (data.Equals("0") && parentData.Equals("-NONE-")));
}
return(false);
}
public void Modifier(ParseNodeDrawable parseNode)
{
if (parseNode.IsLeaf())
{
string name = parseNode.GetData().GetName();
parseNode.ClearLayers();
parseNode.GetLayerInfo().SetLayerData(ViewLayerType.ENGLISH_WORD, name);
parseNode.ClearData();
}
}
public TurkishPartOfSpeechTranslator(ParseNodeDrawable parseNode, List <string> parentList,
List <string> englishWordList, string prefix, string lastWordForm, TxtWord lastWord)
{
this.parseNode = parseNode;
this.parentList = parentList;
this.englishWordList = englishWordList;
this.prefix = prefix;
this.lastWordForm = lastWordForm;
this.lastWord = lastWord;
}
public override bool Satisfies(ParseNodeDrawable parseNode)
{
if (base.Satisfies(parseNode))
{
string data = parseNode.GetLayerData(ViewLayerType.ENGLISH_WORD);
string parentData = parseNode.GetParent().GetData().GetName();
return(parentData.Equals("CD") && new Regex("[0-9,.]+").IsMatch(data));
}
return(false);
}
private bool ContainsChild(ParseNodeDrawable parent, ParseNodeDrawable child)
{
for (var i = 0; i < parent.NumberOfChildren(); i++)
{
if (GetParent((ParseNodeDrawable)parent.GetChild(i)).Equals(GetParent(child)))
{
return(true);
}
}
return(false);
}
private ParseNodeDrawable GetParent(ParseNodeDrawable node)
{
if (node.GetParent() != null)
{
return(GetParent((ParseNodeDrawable)node.GetParent()));
}
else
{
return(node);
}
}
private void CollectNodes(ParseNodeDrawable parseNode, List <ParseNodeDrawable> collected)
{
if (_condition == null || _condition.Satisfies(parseNode))
{
collected.Add(parseNode);
}
for (var i = 0; i < parseNode.NumberOfChildren(); i++)
{
CollectNodes((ParseNodeDrawable)parseNode.GetChild(i), collected);
}
}
protected bool IsLastWordOfNounPhrase(ParseNodeDrawable parseNode)
{
var parent = (ParseNodeDrawable)parseNode.GetParent();
var grandParent = (ParseNodeDrawable)parent.GetParent();
var next = (ParseNodeDrawable)parseNode.NextSibling();
var previous = (ParseNodeDrawable)parseNode.PreviousSibling();
if (parent.IsLastChild(parseNode))
{
if (previous != null && previous.GetData().GetName().StartsWith("J") && previous.LastChild().IsLeaf())
{
string word = ((ParseNodeDrawable)previous.LastChild()).GetLayerData(ViewLayerType.TURKISH_WORD);
if (word != null && txtDictionary.GetWord(word) != null &&
((TxtWord)txtDictionary.GetWord(word)).IsNominal())
{
return(true);
}
}
if (previous != null && previous.GetData().GetName().StartsWith("N"))
{
return(true);
}
if (grandParent != null && grandParent.IsLastChild(parent) && grandParent.NumberOfChildren() == 2)
{
ParseNodeDrawable parentPrevious = (ParseNodeDrawable)parent.PreviousSibling();
if (parentPrevious.GetData().GetName().Equals("PP") &&
parentPrevious.LastChild().GetData().GetName().Equals("IN"))
{
ParseNodeDrawable inNode = (ParseNodeDrawable)parentPrevious.LastChild().LastChild();
if (inNode != null && inNode.GetLayerData(ViewLayerType.ENGLISH_WORD) != null &&
inNode.GetLayerData(ViewLayerType.ENGLISH_WORD).Equals("of"))
{
return(true);
}
return(false);
}
return(false);
}
return(false);
}
if (next != null && previous != null)
{
return(!(next.GetData().GetName().StartsWith("N")) && previous.GetData().GetName().StartsWith("N"));
}
return(false);
}
private void MergeNodes(List <WordNodePair> list, string treePos)
{
var parent = new ParseNodeDrawable(new Symbol(treePos));
if (!AllSame(list))
{
foreach (var wordNodePair in list)
{
if (!ContainsChild(parent, wordNodePair.GetNode()))
{
parent.AddChild(GetParent(wordNodePair.GetNode()));
}
}
}
}
public string LeafConverter(ParseNodeDrawable leafNode)
{
var layerInfo = leafNode.GetLayerInfo();
var rootWords = " ";
for (var i = 0; i < layerInfo.GetNumberOfWords(); i++)
{
var root = layerInfo.GetMorphologicalParseAt(i).GetWord().GetName();
if (!string.IsNullOrEmpty(root))
{
rootWords += " " + root;
}
}
return(rootWords);
}
private string ConvertToString(ParseNodeDrawable parseNode)
{
if (parseNode.IsLeaf())
{
return(_converter.LeafConverter(parseNode));
}
var st = "";
for (var i = 0; i < parseNode.NumberOfChildren(); i++)
{
st += ConvertToString((ParseNodeDrawable)parseNode.GetChild(i));
}
return(st);
}
public override bool Satisfies(ParseNodeDrawable parseNode)
{
if (base.Satisfies(parseNode))
{
var layerInfo = parseNode.GetLayerInfo();
for (var i = 0; i < layerInfo.GetNumberOfMeanings(); i++)
{
var synSetId = layerInfo.GetSemanticAt(i);
if (synSetId.Equals(_id))
{
return(true);
}
}
}
return(false);
}
protected bool IsLastWordOfVerbAsNoun(ParseNodeDrawable parseNode)
{
ParseNodeDrawable parent = (ParseNodeDrawable)parseNode.GetParent();
ParseNodeDrawable grandParent = (ParseNodeDrawable)parent.GetParent();
if (parent.IsLastChild(parseNode) && parent.GetData().GetName().Equals("VP"))
{
if (grandParent != null && grandParent.GetData().GetName().Equals("NP") &&
grandParent.GetChild(0).Equals(parent) &&
grandParent.NumberOfChildren() == 2 && grandParent.GetChild(1).GetData().GetName().Equals("NP"))
{
return(true);
}
}
return(false);
}
private List <ParseNodeDrawable> FindNodes(ParseNodeDrawable node)
{
var list = new List <ParseNodeDrawable>();
for (var i = 0; i < node.NumberOfChildren(); i++)
{
var child = (ParseNodeDrawable)node.GetChild(i);
if (node.GetLayerInfo() == null)
{
if (node.NumberOfChildren() == 1 && ((ParseNodeDrawable)node.GetChild(0)).GetLayerInfo() == null)
{
list.Add(node);
}
list.AddRange(FindNodes(child));
}
}
return(list);
}
public string LeafConverter(ParseNodeDrawable leafNode)
{
var layerData = leafNode.GetLayerData(viewLayerType);
var parentLayerData = ((ParseNodeDrawable)leafNode.GetParent()).GetLayerData(viewLayerType);
if (layerData != null)
{
if (layerData.Contains("*") || (layerData.Equals("0") && parentLayerData.Equals("-NONE-")))
{
return("");
}
return(" " + layerData.Replace("-LRB-", "(").Replace("-RRB-", ")").Replace("-LSB-", "[")
.Replace("-RSB-", "]").Replace("-LCB-", "{").Replace("-RCB-", "}")
.Replace("-lrb-", "(").Replace("-rrb-", ")").Replace("-lsb-", "[")
.Replace("-rsb-", "]").Replace("-lcb-", "{").Replace("-rcb-", "}"));
}
return("");
}
public override bool Satisfies(ParseNodeDrawable parseNode)
{
var layerInfo = parseNode.GetLayerInfo();
if (base.Satisfies(parseNode) && layerInfo != null &&
layerInfo.GetLayerData(ViewLayerType.SEMANTICS) != null)
{
for (int i = 0; i < layerInfo.GetNumberOfMeanings(); i++)
{
String synSetId = layerInfo.GetSemanticAt(i);
if (_wordNet.GetSynSetWithId(synSetId) != null &&
_wordNet.GetSynSetWithId(synSetId).GetPos() == Pos.VERB)
{
return(true);
}
}
}
return(false);
}
public ParseTree.ParseTree Convert(AnnotatedSentence.AnnotatedSentence annotatedSentence, List <TreeEnsembleModel> models)
{
try {
var wordNodePairs = ConstructWordPairList(annotatedSentence, annotatedSentence.GetFileName());
var dependencyMap = SetDependencyMap(wordNodePairs);
if (wordNodePairs.Count > 1)
{
return(ConstructTreeFromWords(wordNodePairs, dependencyMap, models));
}
else
{
var parent = new ParseNodeDrawable(new Symbol("S"));
parent.AddChild(wordNodePairs[0].GetNode());
return(new ParseTree.ParseTree(parent));
}
} catch (Exception e) {
if (e is UniversalDependencyNotExistsException || e is NonProjectiveDependencyException || e is MorphologicalAnalysisNotExistsException)
{
Console.WriteLine(e.ToString());
}
}
return(null);
}
public WordNodePair(AnnotatedWord annotatedWord, int no)
{
_annotatedWord = annotatedWord;
ParseNodeDrawable parent;
if (GetUniversalDependency().Equals("ADVMOD"))
{
parent = new ParseNodeDrawable(new Symbol("ADVP"));
}
else if (GetUniversalDependency().Equals("ACL"))
{
parent = new ParseNodeDrawable(new Symbol("ADJP"));
}
else
{
parent = new ParseNodeDrawable(new Symbol(annotatedWord.GetParse().GetTreePos()));
}
_node = new ParseNodeDrawable(parent, annotatedWord.ToString().Replace("\\(", "-LRB-").Replace("\\)", "-RRB-"), true, 0);
parent.AddChild(_node);
_no = no;
_doneForConnect = false;
_doneForHead = false;
}
public bool Satisfies(ParseNodeDrawable parseNode)
{
return(parseNode.NumberOfChildren() > 0 && parseNode.GetData().IsVp());
}
public TurkishNNTranslator(ParseNodeDrawable parseNode, List <string> parentList, List <string> englishWordList,
string prefix, string lastWordForm, TxtWord lastWord, TxtDictionary txtDictionary) : base(parseNode,
parentList, englishWordList, prefix, lastWordForm, lastWord, txtDictionary)
{
}
public override bool Satisfies(ParseNodeDrawable parseNode)
{
if (base.Satisfies(parseNode))
{
var data = parseNode.GetLayerData(ViewLayerType.ENGLISH_WORD);
var parentData = parseNode.GetParent().GetData().GetName();
if (parentData.Equals("DT"))
{
return(data.Equals("the"));
}
if (parentData.Equals("IN"))
{
return(data.Equals("in") || data.Equals("than") || data.Equals("from") || data.Equals("on") ||
data.Equals("with") || data.Equals("of") || data.Equals("at") || data.Equals("if") ||
data.Equals("by"));
}
if (parentData.Equals("TO"))
{
return(data.Equals("to"));
}
if (parentData.Equals("VBZ"))
{
return(data.Equals("has") || data.Equals("does") || data.Equals("is") || data.Equals("'s"));
}
if (parentData.Equals("MD"))
{
return(data.Equals("will") || data.Equals("'d") || data.Equals("'ll") || data.Equals("ca") ||
data.Equals("can") || data.Equals("could") || data.Equals("would") ||
data.Equals("should") || data.Equals("wo") || data.Equals("may") || data.Equals("might"));
}
if (parentData.Equals("VBP"))
{
return(data.Equals("'re") || data.Equals("is") || data.Equals("are") || data.Equals("am") ||
data.Equals("'m") || data.Equals("do") || data.Equals("have") || data.Equals("has") ||
data.Equals("'ve"));
}
if (parentData.Equals("VBD"))
{
return(data.Equals("had") || data.Equals("did") || data.Equals("were") || data.Equals("was"));
}
if (parentData.Equals("VBN"))
{
return(data.Equals("been"));
}
if (parentData.Equals("VB"))
{
return(data.Equals("have") || data.Equals("be"));
}
if (parentData.Equals("RB"))
{
return(data.Equals("n't") || data.Equals("not"));
}
if (parentData.Equals("POS"))
{
return(data.Equals("'s") || data.Equals("'"));
}
if (parentData.Equals("WP"))
{
return(data.Equals("who") || data.Equals("where") || data.Equals("which") || data.Equals("what") ||
data.Equals("why"));
}
}
return(false);
}
