private void AnalyzeName(string text, WordNetEngine.POS pOS)
{
if (text.Length < 2)
{
throw new Exception("Length is less than 2 char");
}
Spelling oSpell = new Spelling();
var words = Regex.Split(text, @"([A-Z _][a-z]+)");
foreach (var word in words.Where(c => !string.IsNullOrEmpty(c) && c != "_"))
{
if (!oSpell.TestWord(word))
{
throw new Exception("FieldName Is not a Valid Word");
}
if (pOS == WordNetEngine.POS.Noun)
{
SynSet token = WordNetEngine.GetMostCommonSynSet(word, pOS);
if (token == null)
{
throw new Exception("FieldName Is Not A Valid noun");
}
}
}
if (pOS == WordNetEngine.POS.Verb)
{
var word = string.Join(" ", words.Where <string>(c => c.Length > 0));
SynSet token = WordNetEngine.GetMostCommonSynSet(word, pOS);
if (token == null)
{
throw new Exception("MethodName Is Not A Valid Verb");
}
}
}
private void getSynSets_Click(object sender, EventArgs e)
{
synSets.Items.Clear();
semanticRelations.Items.Clear();
lexicalRelations.Items.Clear();
getRelatedSynSets.Enabled = false;
// retrive synsets
Set <SynSet> synSetsToShow = null;
if (synsetID.Text != "")
{
try { synSetsToShow = new Set <SynSet>(new SynSet[] { _wordNetEngine.GetSynSet(synsetID.Text) }); }
catch (Exception)
{
MessageBox.Show("Invalid SynSet ID");
return;
}
}
else
{
// get single most common synset
if (mostCommon.Checked)
{
try
{
SynSet synset = _wordNetEngine.GetMostCommonSynSet(word.Text, (WordNetEngine.POS)pos.SelectedItem);
if (synset != null)
{
synSetsToShow = new Set <SynSet>(new SynSet[] { synset });
}
}
catch (Exception ex) { MessageBox.Show("Error: " + ex); return; }
}
// get all synsets
else
{
try
{
synSetsToShow = _wordNetEngine.GetSynSets(word.Text, (WordNetEngine.POS)pos.SelectedItem);
}
catch (Exception ex) { MessageBox.Show("Error: " + ex); return; }
}
}
if (synSetsToShow.Count > 0)
{
foreach (SynSet synSet in synSetsToShow)
{
synSets.Items.Add(synSet);
}
}
else
{
MessageBox.Show("No synsets found");
}
}
public string Evaluate(Context context)
{
try
{
var commonMode = _plugin.Settings["Use-Common"].GetValue <bool>();
var toSearch = context.Element.Value;
Set <SynSet> synSetsList = null;
var definitionList = new List <string>();
if (commonMode)
{
synSetsList = _wordNetEngine.GetSynSets(toSearch);
}
else
{
var synset = _wordNetEngine.GetMostCommonSynSet(toSearch, WordNetEngine.POS.Noun);
if (synset != null)
{
synSetsList = new Set <SynSet>(new[] { synset });
}
}
if (synSetsList != null)
{
foreach (var synSet in synSetsList)
{
var types = SynUtility.Text.GetFormattedSentence(synSet.Words);
types = "( " + types.Replace("_", " ") + " ) ";
var glossString = "";
foreach (var sentence in SynUtility.Text.GetWords(synSet.Gloss, ";"))
{
if (sentence.StartsWith(" \""))
{
glossString += ". Example sentence: " + sentence;
}
else
{
glossString += "Definition: " + sentence;
}
}
definitionList.Add(types + "\n" + glossString);
}
var toShow = "";
foreach (var sentence in definitionList)
{
toShow += sentence + "\n";
}
return(toShow);
}
}
catch (Exception exception)
{
VA.Logger.Error(exception);
}
return(string.Empty);
}
private void test_Click(object sender, EventArgs e)
{
Thread t = new Thread(new ThreadStart(delegate()
{
Invoke(new MethodInvoker(delegate() { Enabled = false; }));
// test all words
Dictionary <WordNetEngine.POS, Set <string> > words = _wordNetEngine.AllWords;
foreach (WordNetEngine.POS pos in words.Keys)
{
foreach (string word in words[pos])
{
// get synsets
Set <SynSet> synsets = _wordNetEngine.GetSynSets(word, pos);
if (synsets.Count == 0)
{
if (MessageBox.Show("Failed to get synset for " + pos + ": " + word + ". Quit?", "Quit?", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
return;
}
}
// make sure there's a most common synset
if (_wordNetEngine.GetMostCommonSynSet(word, pos) == null)
{
throw new NullReferenceException("Failed to find most common synset");
}
// check each synset
foreach (SynSet synset in synsets)
{
// check lexically related words
synset.GetLexicallyRelatedWords();
// check relations
foreach (WordNetEngine.SynSetRelation relation in synset.SynSetRelations)
{
synset.GetRelatedSynSets(relation, false);
}
// check lex file name
if (synset.LexicographerFileName == WordNetEngine.LexicographerFileName.None)
{
throw new Exception("Invalid lex file name");
}
}
}
}
MessageBox.Show("Test completed. Everything looks okay.");
Invoke(new MethodInvoker(delegate() { Enabled = true; }));
}));
t.Start();
}
public static bool IsVerb(string word)
{
var verbPos = WordNetEngine.POS.Verb;
SynSet synSet = WordNetEngine.GetMostCommonSynSet(word, verbPos);
if (synSet == null)
{
return(false);
}
return(true);
}
protected virtual SynSet SelectSynset(string word, POS pos)
{
WordNetEngine.POS wordnetPOS = pos.ForWordnet();
return((wordnetPOS == WordNetEngine.POS.None) ? null : wordnet.GetMostCommonSynSet(word, wordnetPOS));
}
public String QueryExpansion(IEnumerable <String> tokens, Boolean checkForNoun, Boolean checkForAdj, Boolean checkForVerb, Boolean checkForAdverb)
{
String expansion = "";
foreach (String token in tokens)
{
bool isToken = false;
foreach (string sw in STOP_WORDS)
{
if (sw.Contains(token))
{
isToken = true;
}
}
if (token == "" || token == " " || isToken == true)
{
System.Console.WriteLine("Token: {0} : {0}", token, isToken);
continue;
}
System.Console.WriteLine("\n\n~~~~~~~~~~~~~~~~~~~~~~~~ Getting synonyms from WordNet\n");
System.Console.WriteLine("Synonyms for token = " + token + "\n");
expansion += token + "^5 ";
// For each token, add synonym
// src: https://developer.syn.co.in/api/Syn.WordNet.WordNetEngine.html
SynSet synSet_noun = wordNetEngine.GetMostCommonSynSet(token, PartOfSpeech.Noun);
SynSet synSet_adjective = wordNetEngine.GetMostCommonSynSet(token, PartOfSpeech.Adjective);
SynSet synSet_verb = wordNetEngine.GetMostCommonSynSet(token, PartOfSpeech.Verb);
SynSet synSet_adverb = wordNetEngine.GetMostCommonSynSet(token, PartOfSpeech.Adverb);
System.Console.WriteLine("~~~~~~~ Nouns\n");
if (checkForNoun)
{
try
{
foreach (var noun_syn in synSet_noun.Words)
{
if (!expansion.Contains(noun_syn))
{
expansion += noun_syn + "^1 ";
System.Console.WriteLine(noun_syn);
}
}
}
catch (NullReferenceException e)
{
// Noun does not contain synonym
}
}
System.Console.WriteLine("~~~~~~~ Adjectives\n");
if (checkForAdj)
{
try
{
foreach (var adj_syn in synSet_adjective.Words)
{
if (!expansion.Contains(adj_syn))
{
expansion += adj_syn + "^1 ";
System.Console.WriteLine(adj_syn);
}
}
}
catch (NullReferenceException e)
{
// Noun does not contain adjectives
}
}
System.Console.WriteLine("~~~~~~~ Verbs\n");
if (checkForVerb)
{
try
{
foreach (var adj_verb in synSet_verb.Words)
{
if (!expansion.Contains(adj_verb))
{
expansion += adj_verb + "^1 ";
System.Console.WriteLine(adj_verb);
}
}
}
catch (NullReferenceException e)
{
// Noun does not contain adjectives
}
}
System.Console.WriteLine("~~~~~~~ Adverbs\n");
if (checkForAdverb)
{
try
{
foreach (var adj_adverb in synSet_adverb.Words)
{
if (!expansion.Contains(adj_adverb))
{
expansion += adj_adverb + "^1 ";
System.Console.WriteLine(adj_adverb);
}
}
}
catch (NullReferenceException e)
{
// Noun does not contain adjectives
}
}
System.Console.WriteLine("~~~~~~~~~~~~~~~~~~~~~~~~ \n\n");
}
return(expansion);
}
