// get the semantic words
private Dictionary <int, string []> GetSemantic(string word)
{
ArrayList Semantic_words = new ArrayList();
WordNetEngine wn = new WordNetEngine(@"../../", false);
char[] delimiters = { ' ', ',' };
// get the nouns
int count = 0;
Set <SynSet> syns_noun = wn.GetSynSets(word, WordNetEngine.POS.Noun);
foreach (SynSet syn in syns_noun)
{
string syn_s = syn.ToString();
int index = syn_s.IndexOf(":");
syn_s = syn_s.Substring(0, index);// remove until the ":"
syn_s = syn_s.Substring(1, syn_s.Length - 2);
string[] words = syn_s.Split(delimiters);
for (int i = 0; i < words.Length; i++)
{
if (words[i] != "" && !Semantic_words.Contains(words[i]))
{
if (count < 2)
{
Semantic_words.Add(words[i]);
count++;
}
}
}
}
// get the verb
Set <SynSet> syns_verb = wn.GetSynSets(word, WordNetEngine.POS.Verb);
foreach (SynSet syn in syns_verb)
{
string syn_s = syn.ToString();
int index = syn_s.IndexOf(":");
syn_s = syn_s.Substring(0, index);// remove until the ":"
syn_s = syn_s.Substring(1, syn_s.Length - 2);
string[] words = syn_s.Split(delimiters);
for (int i = 0; i < words.Length; i++)
{
if (words[i] != "" && !Semantic_words.Contains(words[i]))
{
if (count < 4)
{
Semantic_words.Add(words[i]);
count++;
}
}
}
}
string[] Semantic_final = (string[])Semantic_words.ToArray(typeof(string));
Dictionary <int, string[]> Semantic_dic = new Dictionary <int, string[]>();
Semantic_dic.Add(900, Semantic_final);
return(Semantic_dic);
}
public void JcnMeasureForkSynsets()
{
var forkSyn = engine.GetSynSets("fork", WordType.Noun);
var carSyn = engine.GetSynSets("car", WordType.Noun);
var result = instance.Measure(forkSyn[4], carSyn[4]);
Assert.AreEqual(0.17, Math.Round(result, 2));
}
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");
}
}
/// <summary>
/// Outputs the Hypernyms (words that the original word is a meaning of)
/// </summary>
private void OutputHypernyms(IEnumerable <string> words, WordNetEngine.POS pos)
{
StringBuilder output = new StringBuilder();
int limitCounter = 0;
foreach (string word in words)
{
limitCounter++;
//get the synsets
var synSets = _wordNetEngine.GetSynSets(word, pos);
//retrieve hypernymSynsets
output.Append(word + "[");
foreach (SynSet directSynset in synSets)
{
var hypernymSynSets =
directSynset.GetRelatedSynSets(WordNetEngine.SynSetRelation.Hypernym, false);
foreach (SynSet hypernymSynSet in hypernymSynSets)
{
//have the synset, find all the words in that synset
IEnumerable <string> outputList =
hypernymSynSet.Words.Where(synonym => synonym != word);
if (outputList.Count() > 0)
{
output.Append("(");
int count = 0;
foreach (string synonym in outputList)
{
count++;
output.Append(synonym);
//add comma not to the last one
if (count != outputList.Count())
{
output.Append(",");
}
}
output.Append(")");
}
}
}
output.Append("]" + Environment.NewLine);
if (limitCounter > nupdLimit.Value)
{
break;
}
}
this.txtHypernyms.Text += output.ToString();
}
public string GetSynonym(string concept)
{
string sinonimos = "";
string conceptSynonym = "";
//Cargar la base de datos de WordNet
WordNetEngine wordNetEngine = new WordNetEngine();
PartOfSpeech pos = new PartOfSpeech();
//var directory = Directory.GetCurrentDirectory();
var directory = HttpContext.Current.Server.MapPath("./") + "bin\\WordNet";
wordNetEngine.LoadFromDirectory(directory);
//Utilizar la librería para traer los sinonimos
var synSetList = wordNetEngine.GetSynSets(concept);
if (synSetList.Count == 0)
{
return("(" + concept + " + )");
}
foreach (var synSet in synSetList)
{
var words = string.Join(" + ", synSet.Words);
sinonimos = sinonimos + words;
}
conceptSynonym = "(" + sinonimos + ")";
return(conceptSynonym);
}
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);
}
public static List <SynSet> FindDefinition(string word)
{
if (!WordNet.IsLoaded)
{
WordNet.LoadFromDirectory(HostingEnvironment.MapPath("~/App_Data/EBook/Wordnet"));
}
return(WordNet.GetSynSets(word));
}
public void InsertInTable(string word)
{
// try
// {
var synSetList = wordNet.GetSynSets(word);
if (synSetList.Count == 0)
{
return;
}
int index = 0;
foreach (var synSet in synSetList)
{
string words = string.Join(", ", synSet.Words);
string pos = $"{synSet.PartOfSpeech}";
string gloss = $"{synSet.Gloss}";
string[] NYMS = new string[27];
for (int i = 0; i < 27; i++)
{
NYMS[i] = " --- ";
}
//var hypernyms = synSet.GetRelatedSynSets(SynSetRelation.AlsoSee, true);
System.Collections.Generic.List <SynSet> nyms;
//-------------------------------------------------------------------1
for (int i = 0; i < 27; i++)
{
nyms = synSet.GetRelatedSynSets((SynSetRelation)i + 1, true);
foreach (var item in nyms)
{
NYMS[i] = NYMS[i] + ", " + item;
}
//NYMS[i] = AddNewLines(NYMS[i],25);
}
dgv.Rows.Add(words, pos, gloss, NYMS[0], NYMS[1], NYMS[2], NYMS[3], NYMS[4], NYMS[5], NYMS[6], NYMS[7], NYMS[8], NYMS[9], NYMS[10], NYMS[11], NYMS[12], NYMS[13], NYMS[14], NYMS[15], NYMS[16], NYMS[17], NYMS[18], NYMS[19], NYMS[20], NYMS[21], NYMS[22], NYMS[23], NYMS[24], NYMS[25], NYMS[26]);
index++;
}
// }
// catch (Exception e)
// {
// }
}
public bool Execute(string lemma, string partOfSpeech, List <string> baseForms)
{
if (!baseForms.Contains(lemma) && mEngine.GetSynSets(lemma, partOfSpeech).Count > 0)
{
baseForms.Add(lemma);
return(true);
}
return(false);
}
//Implementation of advanced system
//WordNet
public static List <string> WordNet(string query)
{
//Can read more files in database but dont know how to use those file yet
//var FileList = Directory.GetFiles(@"C:\Users\USER\Documents\GitHub\IFN647_Advanced\testConvertOrPresentJson\bin\Debug\dict");
//var wordNet = new WordNetEngine();
//foreach (var file in FileList)
//{
// wordNet.AddDataSource(new StreamReader(file));
// // Do some work
//}
var directory = Directory.GetCurrentDirectory();
var wordNet = new WordNetEngine();
wordNet.AddDataSource(new StreamReader(Path.Combine(directory, "./dict/", "data.adj")), PartOfSpeech.Adjective);
wordNet.AddDataSource(new StreamReader(Path.Combine(directory, "./dict/", "data.adv")), PartOfSpeech.Adverb);
wordNet.AddDataSource(new StreamReader(Path.Combine(directory, "./dict/", "data.noun")), PartOfSpeech.Noun);
wordNet.AddDataSource(new StreamReader(Path.Combine(directory, "./dict/", "data.verb")), PartOfSpeech.Verb);
wordNet.AddIndexSource(new StreamReader(Path.Combine(directory, "./dict/", "index.adj")), PartOfSpeech.Adjective);
wordNet.AddIndexSource(new StreamReader(Path.Combine(directory, "./dict/", "index.adv")), PartOfSpeech.Adverb);
wordNet.AddIndexSource(new StreamReader(Path.Combine(directory, "./dict/", "index.noun")), PartOfSpeech.Noun);
wordNet.AddIndexSource(new StreamReader(Path.Combine(directory, "./dict/", "index.verb")), PartOfSpeech.Verb);
Console.WriteLine("Loading database...");
wordNet.Load();
Console.WriteLine("Load completed.");
string word = $"{query}";
var synSetList = new List <Syn.WordNet.SynSet>();
if (word != null)
{
synSetList = wordNet.GetSynSets(word);
if (synSetList.Count == 0)
{
Console.WriteLine($"No SynSet found for '{word}'");
}
}
var synonyms = new List <string>();
foreach (var synSet in synSetList)
{
var words = string.Join(", ", synSet.Words);
synonyms.Add(words);
Console.WriteLine($"\nWords: {words}");
Console.WriteLine($"POS: {synSet.PartOfSpeech}");
Console.WriteLine($"Gloss: {synSet.Gloss}");
}
return(synonyms);
}
static InformationExtraction()
{
TERMS_CLASSIFICATION = new Dictionary <WeaponType, string[]>();
TERMS_CLASSIFICATION.Add(WeaponType.Dagger, new string[] { "dagger", "Dagger", "knives", "Knives", "knife", "Knife" });
TERMS_CLASSIFICATION.Add(WeaponType.Sword, new string[] { "sword", "Sword", "cut", "cutting" });
TERMS_CLASSIFICATION.Add(WeaponType.Axe, new string[] { "axe", "Axe", "ax", "Ax" });
TERMS_CLASSIFICATION.Add(WeaponType.PoleWeapon, new string[] { "pole", "Pole", "staff", "Staff", "spear", "Spear" });
TERMS_CLASSIFICATION.Add(WeaponType.Bow, new string[] { "bow", "Bow" });
TERMS_CLASSIFICATION.Add(WeaponType.Ranged, new string[] { "throw", "Throw", "projectile", "Projectile", "dart", "Dart", "missile", "Missile", "javelin", "Javelin", "throwing", "Throwing" });
TERMS_CLASSIFICATION.Add(WeaponType.Club, new string[] { "club", "Club", "blunt", "Blunt", "flail", "Flail", "chain", "Chain" });
TERMS_CLASSIFICATION.Add(WeaponType.Siege, new string[] { "siege", "Siege", "artillery", "Artillery" });
TERMS_CLASSIFICATION_ALL = TERMS_CLASSIFICATION.SelectMany(kvp => kvp.Value).ToArray();
// Unlike weapon classification, where we defined the terms we were looking for from beforehand, we cannot manually define the terms needed to represent Attack and Defense.
// Our chosen solution picks a few root words and searches for similar words.
string[] attackRoots = { "powerful", "vicious" };
string[] defenseRoots = { "sturdy", "defensive", "protective", "fortified" };
// For each root word, we scan through the linked words that are presented by WordNet and add them to a list, leaving out words that are marked as Antonyms, or opposites. We then check out root words and keep adding the results to the list.
WordNetEngine wordnet = new WordNetEngine(WeaponGeneratorConstants.FOLDER_WORDNET, true);
Func <string[], List <string> > scanAndAdd = roots =>
{
List <string> terms = new List <string>();
terms.AddRange(roots);
// go 3 levels
for (int i = 3; i > 0; --i)
{
List <string> newRoots = new List <string>();
foreach (string root in roots)
{
Set <SynSet> synonims = wordnet.GetSynSets(root, WordNetEngine.POS.Adjective, WordNetEngine.POS.Adverb, WordNetEngine.POS.Noun);
foreach (SynSet synonim in synonims)
{
if (synonim.LexicalRelations.Any(r => r == WordNetEngine.SynSetRelation.Antonym))
{
continue;
}
Debug.Assert(synonim.SemanticRelations.All(r => r != WordNetEngine.SynSetRelation.Antonym));
newRoots.AddRange(synonim.Words.Where(w => !terms.Contains(w)));
terms.AddRange(synonim.Words);
}
}
roots = newRoots.ToArray();
}
return(terms.Distinct().ToList());
};
TERMS_ATTACK = scanAndAdd(attackRoots);
TERMS_DEFENSE = scanAndAdd(defenseRoots);
wordnet.Close();
GC.Collect();
}
private static IEnumerable <SynSet> GetSynSets(string?theme, WordNetEngine wordNetEngine)
{
if (string.IsNullOrWhiteSpace(theme))
{
return(Enumerable.Empty <SynSet>());
}
var sets = wordNetEngine.GetSynSets(theme).ToList();
return(sets);
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object can be used to retrieve data from input parameters and
/// to store data in output parameters.</param>
protected override void SolveInstance(IGH_DataAccess DA)
{
string term1 = null;
string term2 = null;
if (!DA.GetData(0, ref term1))
{
return;
}
// If the retrieved data is Nothing, we need to abort.
// We're also going to abort on a zero-length String.
if (term1 == null)
{
return;
}
if (term1.Length == 0)
{
return;
}
var synSetList = wordNet.GetSynSets(term1);
if (synSetList.Count == 0)
{
Console.WriteLine($"No SynSet found for '{term1}'");
}
var wordList = new List <String>();
var partOfSpeechList = new List <String>();
var glossList = new List <String>();
foreach (var synSet in synSetList)
{
var synonym = string.Join(", ", synSet.Words);
wordList.Add(synonym);
partOfSpeechList.Add(synSet.PartOfSpeech.ToString());
glossList.Add(synSet.Gloss);
}
if (DA.GetData(1, ref term2))
{
var similarity = wordNet.GetSentenceSimilarity(term1, term2);
DA.SetData(3, similarity);
}
// Use the DA object to assign a new String to the first output parameter.
DA.SetDataList(0, wordList);
DA.SetDataList(1, partOfSpeechList);
DA.SetDataList(2, glossList);
}
public Set <SynSet> GetSynSets(string word, params string[] pos)
{
try
{
if (pos == null || pos.Length == 0)
{
//Get synset with all parts of speech
return(wordNetEngine.GetSynSets(word));
}
else
{
//Get synsets with restriction of part of speech
var translatedPOS = TransformPOS(pos.First());
return(wordNetEngine.GetSynSets(word, translatedPOS));
}
}
catch (Exception ex)
{
Logger.LogError("Unable to get synset. " + ex);
return(new Set <SynSet>());
}
}
private static List <string> getSynSets(string word, WordNetEngine.POS type)
{
Set <SynSet> synSetsToShow = null;
try
{
synSetsToShow = _wordNetEngine.GetSynSets(word, type);
}
catch (Exception)
{
return(null);
}
var returnList = new List <string>();
foreach (var syns in synSetsToShow)
{
returnList.AddRange(syns.Words);
}
returnList = returnList.Distinct().ToList();
foreach (var returnListItem in returnList.ToList())
{
try
{
synSetsToShow = _wordNetEngine.GetSynSets(returnListItem, type);
}
catch (Exception)
{
return(null);
}
foreach (var syns in synSetsToShow)
{
returnList.AddRange(syns.Words);
}
}
returnList = returnList.Distinct().ToList();
return(returnList);
}
private SynSet FindSynset(IGlossaryEntry entry, WordNetEngine wordnet)
{
// TODO: find POS, use only nouns for now
int? minDistance = null;
SynSet result = null;
foreach (SynSet synset in wordnet.GetSynSets(entry.Word, WordNetEngine.POS.Noun))
{
int distance = LevenshteinDistance.Compute(entry.Definition, synset.Gloss);
if (minDistance == null || minDistance > distance)
{
result = synset;
}
}
return(result);
}
public List <SynSet> GettingSynSets(string word)
{
var directory = System.IO.Directory.GetCurrentDirectory();
wordNet = new WordNetEngine();
//Console.WriteLine(directory);
//Console.WriteLine("Loading database...");
wordNet.LoadFromDirectory(directory);
//Console.WriteLine("Load completed.");
if (true)
{
var synSetList = wordNet.GetSynSets(word);
return(synSetList);
}
}
static void Main(string[] args)
{
List <String> relaciones = new List <String>();
if (File.Exists("words.txt"))
{
// Usernames are listed first in users.ul, and are followed by a period and then the password associated with that username.
StreamReader reader = new StreamReader("words.txt");
string line;
Set <SynSet> synSetsToShow = null;
List <String> rels = new List <string>();
using (var file = File.CreateText("relaciones.csv"))
{
while ((line = reader.ReadLine()) != null)
{
try
{
synSetsToShow = _wordNetEngine.GetSynSets(line, LAIR.ResourceAPIs.WordNet.WordNetEngine.POS.Noun);
//main SynSet
SynSet s1 = synSetsToShow.Last();
foreach (WordNetEngine.SynSetRelation synSetRelation in s1.SemanticRelations)
{
if (synSetRelation.ToString().Equals("Hypernym") || synSetRelation.ToString().Equals("Hyponym"))
{
//related SynSet
SynSet s2 = s1.GetRelatedSynSets(synSetRelation, false).First();
//fill the line
String csv_line = s1.Words[0] + "," + s2.Words[0] + "," + synSetRelation;
file.WriteLine(csv_line);
//out of the foreach loop
//break;
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
reader.Close();
}
}
}
/*--------------------------------------------------------------------------------------------*/
private static void BuildBaseDbInserts(ISession pSess)
{
int count = 0;
int total = 0;
long start = DateTime.UtcNow.Ticks;
foreach (WordNetEngine.POS key in Engine.AllWords.Keys)
{
Set <string> valSet = Engine.AllWords[key];
total += valSet.Count;
}
foreach (WordNetEngine.POS key in Engine.AllWords.Keys)
{
Set <string> valSet = Engine.AllWords[key];
foreach (string word in valSet)
{
var ssg = new SynSetGroup(word, Engine.GetSynSets(word));
ssg.InsertSynSetsAndWords(pSess);
count++;
if (count % 5000 == 0)
{
Console.WriteLine("Syn/Word: \t" + count + " of " + total +
" \t" + (DateTime.UtcNow.Ticks - start) / 10000 / 1000.0 + " sec");
}
}
}
count = 0;
total = SynSetGroup.GetCachedSynsetCount();
const int step = 5000;
while (true)
{
if (!SynSetGroup.InsertLexicalsAndSemantics(pSess, Engine, count, step))
{
break;
}
count += step;
Console.WriteLine("Lex/Sem: \t" + count + " of " + total +
" \t" + (DateTime.UtcNow.Ticks - start) / 10000 / 1000.0 + " sec");
}
}
public ActionResult Login([FromBody] LinguisticRequest linguisticRequest)
{
var directory = Directory.GetCurrentDirectory();
directory = Path.Combine(directory, "Artifacts");
var wordNet = new WordNetEngine();
var words = new List <String>();
try
{
wordNet.AddDataSource(new StreamReader(Path.Combine(directory, "data.adj")), PartOfSpeech.Adjective);
wordNet.AddDataSource(new StreamReader(Path.Combine(directory, "data.adv")), PartOfSpeech.Adverb);
wordNet.AddDataSource(new StreamReader(Path.Combine(directory, "data.noun")), PartOfSpeech.Noun);
wordNet.AddDataSource(new StreamReader(Path.Combine(directory, "data.verb")), PartOfSpeech.Verb);
wordNet.AddIndexSource(new StreamReader(Path.Combine(directory, "index.adj")), PartOfSpeech.Adjective);
wordNet.AddIndexSource(new StreamReader(Path.Combine(directory, "index.adv")), PartOfSpeech.Adverb);
wordNet.AddIndexSource(new StreamReader(Path.Combine(directory, "index.noun")), PartOfSpeech.Noun);
wordNet.AddIndexSource(new StreamReader(Path.Combine(directory, "index.verb")), PartOfSpeech.Verb);
wordNet.Load();
var synSetList = wordNet.GetSynSets(linguisticRequest.Word);
if (synSetList.Count == 0)
{
return(BadRequest(new { message = "No Words Found." }));
}
foreach (var synSet in synSetList)
{
foreach (string word in synSet.Words)
{
words.Add(word);
}
}
return(Ok(words));
}
catch (Exception ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
protected string GetSynonyms(string query)
{
if (SettingsViewModel.Instance.PosLists.Length == 0)
{
return(query);
}
List <string> synonymList = new List <string>();
string[] tokens = TokeniseString(query.ToLower());
foreach (var t in tokens)
{
var synSetList = wordNet.GetSynSets(t, SettingsViewModel.Instance.PosLists);
if (synSetList.Count == 0)
{
synonymList.Add(t);
Console.WriteLine($"No SynSet found for '{t}'");
}
foreach (var synSet in synSetList)
{
if (synSet.PartOfSpeech == PartOfSpeech.None)
{
continue;
}
var words = string.Join(", ", synSet.Words);
synonymList.AddRange(synSet.Words);
//Console.WriteLine($"\nWords: {synSet.Words}");
//Console.WriteLine($"POS: {synSet.PartOfSpeech}");
//Console.WriteLine($"Gloss: {synSet.Gloss}");
}
}
synonymList = synonymList.Distinct().ToList();
//Console.WriteLine($"synonym List: {string.Join(", ", synonymList)}");
return(SetWeightOriginalTrems(tokens, synonymList));
}
private void Define()
{
definitions.Clear();
var synSetList = wordNet.GetSynSets(SearchText.Text.Trim());
if (synSetList.Count == 0)
{
definitions.Add(new Definition("", noEntries, ""));
}
else
{
foreach (var synSet in synSetList)
{
definitions.Add(new Definition(
string.Join(", ", synSet.Words),
$"{synSet.PartOfSpeech}",
synSet.Gloss));
}
}
}
/// <summary>
/// Gets all wordnet synonyms for a word
/// </summary>
/// <param name="word">The word to find synonyms for</param>
/// <param name="limit">The max amount of synonyms to return</param>
/// <returns>a list of unique synonyms for the word</returns>
public string[] GetSynonyms(string word, int limit)
{
var synSetList = wordNet.GetSynSets(word);
var words = new HashSet <string>();
int counter = 0;
// add each unique word to list
foreach (SynSet set in synSetList)
{
foreach (string setWord in set.Words)
{
// dont add any these type of words (ex. test_test) (idk why these are in the wordnet...)
if (!setWord.Contains('_') && !setWord.Contains('-'))
{
words.Add(setWord);
counter++;
}
// dont go over limit
if (counter >= limit)
{
break;
}
}
// dont go over limit
if (counter >= limit)
{
break;
}
}
// null checks
string[] result = new string[words.Count];
words.CopyTo(result);
return((result.Length != 0) ? result : new string[] { word });
}
/// <summary>
/// Get the synonym set of the input word
/// </summary>
/// <param name="word">The word which is used for search its synonym</param>
/// <returns> return all synonyms of the parameter "word" in an array </returns>
public string[] GetSynnetList(string word)
{
var synSetList = wordnet.GetSynSets(word);
int listNumber = synSetList.Count;
string[] words = new[] { "" };
if (listNumber == 0)
{
words[0] = word;
return(words);
}
else
{
List <string> result = synSetList[0].Words;
for (int i = 1; i < synSetList.Count; i++)
{
result = result.Union(synSetList[i].Words).ToList <string>();
}
words = result.ToArray();
return(words);
}
}
public string Expansion_query(string[] query_token)
{
string expandquery = "";
foreach (string t in query_token)
{
var synSetlist = wordNet.GetSynSets(t);
if (synSetlist.Count != 0)
{
foreach (var synSet in synSetlist)
{
foreach (var word in synSet.Words)
{
if (word != t)
{
expandquery += word;
}
}
}
}
}
return(expandquery.Replace('_', ' '));
}
public void run()
{
while (true)
{
Console.Write("\nType first word:");
var word = Console.ReadLine();
var synSetList = wordNet.GetSynSets(word);
//System.Collections.Generic.List<SynSet> synSetList
if (synSetList.Count == 0)
{
Console.WriteLine($"No SynSet found for '{word}'");
}
foreach (var synSet in synSetList)
{
var words = string.Join(", ", synSet.Words);
Console.WriteLine($"\nWords: {words}");
Console.WriteLine($"Part Of Speech: {synSet.PartOfSpeech}");
Console.WriteLine($"Gloss: {synSet.Gloss}");
}
}
}
public string WordNetExpand0(string inputString, bool queryhook)
{
string[] words = inputString.Split(' ');
string returnText = inputString + " ";
if (userCachedPending == false)
{
WNUser2Cache();
}
int numWords = words.Length;
// Ok, lets try WordNet
//WordNetEngine ourWordNetEngine = this.user.bot.wordNetEngine;
WordNetEngine.POS ourPOS = WordNetEngine.POS.Noun;
List <WordNetEngine.SynSetRelation> vlist = new List <WordNetEngine.SynSetRelation>(); //[2];
//vlist.Add(WordNetEngine.SynSetRelation.Hypernym);
//vlist.Add(WordNetEngine.SynSetRelation.InstanceHypernym);
vlist.Add(WordNetEngine.SynSetRelation.Hyponym);
vlist.Add(WordNetEngine.SynSetRelation.InstanceHyponym);
// retrive synsets
Set <SynSet> synStartSet = null;
try { synStartSet = wordNetEngine.GetSynSets("entity", ourPOS); }
catch (Exception)
{
writeToLog("Invalid Start SynSet ID");
return(returnText);
}
for (int i = 0; i < numWords; i++)
{
string focusWord = words[i];
string focusWordResults = "";
if (WNExpandCache.Contains(focusWord))
{
focusWordResults = (string)WNExpandCache[focusWord];
}
else
{
Set <SynSet> synDestSet = null;
try { synDestSet = wordNetEngine.GetSynSets(focusWord, ourPOS); }
catch (Exception)
{
writeToLog("Invalid Dest SynSet ID");
continue;
}
int numlinks = 0;
if (synStartSet.Count > 0)
{
//WordNetEngine.SynSetRelation[] vlist = new WordNetEngine.SynSetRelation[2];
//vlist[0] = WordNetEngine.SynSetRelation.Hyponym;
//vlist[1] = WordNetEngine.SynSetRelation.InstanceHyponym;
foreach (SynSet synSrcSet in synStartSet)
{
foreach (SynSet synDstSet in synDestSet)
{
//synSets.Items.Add(synSet);
List <SynSet> linkageList = null;
linkageList = synSrcSet.GetShortestPathTo(synDstSet, vlist);
if ((linkageList != null) && (linkageList.Count > 0))
{
foreach (SynSet s in linkageList)
{
StringBuilder desc = new StringBuilder();
//desc.Append("{");
bool prependComma = false;
foreach (string word in s.Words)
{
desc.Append((prependComma ? ", " : "") + word);
prependComma = true;
}
//desc.Append("}");
//LinkBox.Items.Add(desc.ToString());
focusWordResults = focusWordResults + " " + desc.ToString() + " ";
}
//LinkBox.Text = "true";
numlinks++;
//return;
}
}
}
}
WNExpandCache.Add(focusWord, focusWordResults.Trim()); //Add to Cache
}
returnText = returnText + " " + focusWordResults;
}
returnText = returnText.Trim();
if (queryhook)
{
if (returnText.Contains("person"))
{
returnText = returnText + " who";
}
if (returnText.Contains("imaginary_being"))
{
returnText = returnText + " who";
}
if (returnText.Contains("causal_agent"))
{
returnText = returnText + " who";
}
if (returnText.Contains("object"))
{
returnText = returnText + " what";
}
if (returnText.Contains("location"))
{
returnText = returnText + " where";
}
if (returnText.Contains("time_period"))
{
returnText = returnText + " when";
}
if (returnText.Contains("amount"))
{
returnText = returnText + " how much how many";
}
if (returnText.Contains("measure"))
{
returnText = returnText + " how much how many";
}
if (returnText.Contains("quantity"))
{
returnText = returnText + " how much how many";
}
}
// filter out "stop concepts" which have a > 70% occurance and thus low info content
returnText = returnText.Replace("entity", "");
returnText = returnText.Replace("abstraction", "");
returnText = returnText.Replace("abstract", "");
returnText = returnText.Replace("unit", "");
returnText = returnText.Replace("physical", "");
returnText = returnText.Replace("yes", "");
return(returnText.Trim());
}
public override float CanUnify(Unifiable with)
{
string re = ComputeInner();
string wnPos = GetAttribValue("wnpos", "").ToLower();
string wnRelation = GetAttribValue("wnrel", "").ToLower();
//Lookup definition for current word we could unify with
string wordAttributes = "";
string key = (string)with.ToValue(query).Trim();
if (Proc.wordAttributeHash.Contains(key))
{
wordAttributes = (string)Proc.wordAttributeHash[key];
}
else
{
if (Proc.wordAttributeHash.Contains(key.ToLower()))
{
key = key.ToLower();
wordAttributes = (string)Proc.wordAttributeHash[key];
}
}
// Can you find a match inside ?
var matcher = new Regex(re);
if (matcher.IsMatch(wordAttributes))
{
return(AND_TRUE);
}
// Ok, lets try WordNet
WordNetEngine ourWordNetEngine = Proc.wordNetEngine;
Set <SynSet> synPatternSet = null;
// find our POS domain if possible
WordNetEngine.POS ourPOS = WordNetEngine.POS.Noun;
if (wnPos.Length > 0)
{
// populate POS list
foreach (WordNetEngine.POS p in Enum.GetValues(typeof(WordNetEngine.POS)))
{
if (p != WordNetEngine.POS.None)
{
if (p.ToString().ToLower().Equals(wnPos) || p.ToString().ToLower().StartsWith(wnPos))
{
ourPOS = p;
}
}
}
}
if (ourWordNetEngine == null)
{
writeDebugLine("Wordnet engine not loaded .. returning AND_FALSE");
{
return(AND_FALSE);
}
}
try { synPatternSet = ourWordNetEngine.GetSynSets(re, ourPOS); }
catch (Exception)
{
return(AND_FALSE);
}
if (synPatternSet.Count == 0)
{
try { synPatternSet = ourWordNetEngine.GetSynSets(re.ToLower(), ourPOS); }
catch (Exception)
{
return(AND_FALSE);
}
}
Set <SynSet> synInputSet = null;
try { synInputSet = ourWordNetEngine.GetSynSets(key, ourPOS); }
catch (Exception)
{
return(AND_FALSE);
}
if (synInputSet.Count == 0)
{
try { synInputSet = ourWordNetEngine.GetSynSets(key.ToLower(), ourPOS); }
catch (Exception)
{
return(AND_FALSE);
}
}
List <WordNetEngine.SynSetRelation> vlist = new List <WordNetEngine.SynSetRelation>(); //[2];
//vlist[0] = WordNetEngine.SynSetRelation.Hyponym;
//vlist[1] = WordNetEngine.SynSetRelation.InstanceHyponym;
//vlist[0] = WordNetEngine.SynSetRelation.Hypernym ;
//vlist[1] = WordNetEngine.SynSetRelation.InstanceHypernym;
if (wnRelation.Length == 0)
{
vlist.Add(WordNetEngine.SynSetRelation.Hypernym);
vlist.Add(WordNetEngine.SynSetRelation.InstanceHypernym);
}
else
{
// populate Relation list
foreach (WordNetEngine.SynSetRelation r in Enum.GetValues(typeof(WordNetEngine.SynSetRelation)))
{
if (r != WordNetEngine.SynSetRelation.None)
{
if (r.ToString().ToLower().Contains(wnRelation))
{
vlist.Add(r);
}
}
}
}
if ((synInputSet.Count > 0) && (synPatternSet.Count > 0))
{
foreach (SynSet synDstSet in synInputSet)
{
foreach (SynSet synSrcSet in synPatternSet)
{
//synSets.Items.Add(synSet);
List <SynSet> linkageList = null;
linkageList = synDstSet.GetShortestPathTo(synSrcSet, vlist);
if ((linkageList != null) && (linkageList.Count > 0))
{
return(AND_TRUE);
}
}
}
return(AND_FALSE);
}
return(AND_FALSE);
}
public void Extract(string text_segment)
{
if (!string.IsNullOrEmpty(text_segment))
{
#region Local Variables
int i = 0;
int j;
int k;
int d;
int l;
int chunkLength;
int chunksLength;
string curToken;
List <SynSet> Senses, tmpSenses;
SynSet tmpSense;
List <SentenceChunk> Chunks = new List <SentenceChunk>(); // This list of all chunks
List <SentenceChunk> tmpChunks = new List <SentenceChunk>(); // This list of all chunks
Dictionary <string, SynSet> CachedConcepts = new Dictionary <string, SynSet>();
TextVectors = new List <TaggedWord>(); // The list that will hold all mappable terms with thier information
List <string> MiscTerms = new List <string>(); // The list of unmapped terms in the text
string[] tokens;
string[] sentences = _sentenceDetector.SentenceDetect(text_segment);
#endregion
#region Section 3.1.
// Extract all chunks from the given text segment
for (k = 0; k < sentences.Length; k++)
{
tokens = _tokenizer.Tokenize(sentences[k]);
tmpChunks = _chunker.GetChunks(tokens, _posTagger.Tag(tokens));
tmpChunks.RemoveAll(predicate => predicate.TaggedWords.Count == 0);
Chunks.AddRange(tmpChunks);
}
tmpChunks = null;
tokens = null;
sentences = null;
// Extract elements that will be used for Similarity Matrix Generation as the input of clustering
chunksLength = Chunks.Count;
while (i < chunksLength)
{
// Look only inside NP chunks
if (Chunks[i].Tag == "NP")
{
#region Rectify NP Chunks
if (i + 1 < chunksLength)
{
if (Chunks[i + 1].Tag == "NP")
{
if (Chunks[i + 1].TaggedWords[0].Tag.StartsWith("NNP") || AllowedDTList.ContainsKey(Chunks[i + 1].TaggedWords[0].Word))
{
int length = Chunks[i].TaggedWords.Count;
foreach (TaggedWord w in Chunks[i + 1].TaggedWords)
{
w.Index = length;
Chunks[i].TaggedWords.Add(w);
length++;
}
Chunks.RemoveRange(i + 1, 1);
chunksLength = chunksLength - 1;
}
}
else
if (Chunks[i + 1].Tag == "PP" && i + 2 < chunksLength)
{
if (Chunks[i + 2].TaggedWords[0].Tag.StartsWith("NNP") || AllowedDTList.ContainsKey(Chunks[i + 1].TaggedWords[0].Word))
{
int length = Chunks[i].TaggedWords.Count;
Chunks[i + 1].TaggedWords[0].Index = length;
Chunks[i].TaggedWords.Add(Chunks[i + 1].TaggedWords[0]);
length++;
foreach (TaggedWord w in Chunks[i + 2].TaggedWords)
{
w.Index = length;
length++;
Chunks[i].TaggedWords.Add(w);
}
Chunks.RemoveRange(i + 1, 2);
chunksLength = chunksLength - 2;
}
}
}
#endregion
#region Find N-Gram NNPs
// This part is very important:
// 1- Rectify any linguistic errors generated as side effect of the previous step (such as "Belly the")
// 2- Eliminate any syntactic errors such as Texas Rangers (sports) --> Texas Ranger (Police)
// since we don't alter the value of a NNP(s)
chunkLength = Chunks[i].TaggedWords.Count;
j = 0;
// Loop through all chunk words
while (j < chunkLength)
{
if (Chunks[i].TaggedWords[j].Tag[0] == 'N')
{
// Needed for fast access to the last element in SemanticElements
d = TextVectors.Count() - 1;
// Check the probability of merging N-gram Named Entities (NNP(S)* || NNP(S)*|DT*|NNP(S)*)
if (Chunks[i].TaggedWords[j].Tag.StartsWith("NNP"))
{
k = 0;
// First scan to see if the pattern is satisfied
for (l = j + 1; l < chunkLength; l++)
{
// Here to define any patterns the user may wish to apply
if (
Chunks[i].TaggedWords[l].Tag.StartsWith("NNP") || // allow N-Gram NNP
AllowedDTList.ContainsKey(Chunks[i].TaggedWords[l].Word) || // allow adding stop words inside the NNP
Chunks[i].TaggedWords[l].Tag == "CD" // allow adding numbers inside NNP
)
{
k++;
}
else
{
break;
}
}
// k-value changing means a pattern has been found
// if k is changed and the scanned pattern does not end with a stop word
if (k > 0 && !AllowedDTList.ContainsKey(Chunks[i].TaggedWords[j + k].Word))
{
// Concatenate all the pattern parts ans store them in temp variable
curToken = Chunks[i].TaggedWords[j].Word;
for (l = j + 1; l <= j + k; l++)
{
curToken = curToken + " " + Chunks[i].TaggedWords[l].Word;
}
// Delete all the parts added in temp
Chunks[i].TaggedWords.RemoveRange(j + 1, k);
// rectify the sequence length after deletion
chunkLength = chunkLength - k;
// Check if the perv token is a capitalized JJ
if (d > -1 && j > 0 && TextVectors[d].Tag == "JJ" && char.IsUpper(TextVectors[d].Word[0]))
{
// Replace current j with its previous j-1 word, and allocate special tag NNP*J
Chunks[i].TaggedWords[j - 1].Tag = Chunks[i].TaggedWords[j].Tag + "J";
Chunks[i].TaggedWords[j - 1].Word = TextVectors[d].Word + " " + curToken;
// Remove the previous word from all lists
TextVectors.RemoveAt(d);
Chunks[i].TaggedWords.RemoveRange(j, 1);
chunkLength--;
j--;
}
else
{
// Only update the current word
Chunks[i].TaggedWords[j].Word = curToken;
}
TextVectors.Add(Chunks[i].TaggedWords[j]);
// Skip the loop by k steps
j = j + k;
}
else
{
// If there is no pattern match --> add singular NNP(S)
// Before addition check JJ pattern
if (d > -1 && j > 0 && TextVectors[d].Tag == "JJ" && char.IsUpper(TextVectors[d].Word[0]))
{
// Replace current j with its previous j-1 word, and allocate special tag NNP*J
Chunks[i].TaggedWords[j - 1].Tag = Chunks[i].TaggedWords[j].Tag + "J";
Chunks[i].TaggedWords[j - 1].Word = TextVectors[d].Word + " " + Chunks[i].TaggedWords[j].Word;
// Remove the previous word from all lists
TextVectors.RemoveAt(d);
Chunks[i].TaggedWords.RemoveRange(j, 1);
chunkLength--;
j--;
}
TextVectors.Add(Chunks[i].TaggedWords[j]);
j++;
}
}
else
{
// If the current word is NN(S)
if (Chunks[i].TaggedWords[j].Tag == "NNS")
{
Chunks[i].TaggedWords[j].Word = _wn.Lemmatize(Chunks[i].TaggedWords[j].Word, "noun");
}
// Find if the current token forms bigram WordNet concept with the previous token
if (j > 0)
{
if (Chunks[i].TaggedWords[j - 1].Tag == "NN" || Chunks[i].TaggedWords[j - 1].Tag == "NNS" || Chunks[i].TaggedWords[j - 1].Tag == "JJ")
{
if (_wn.GetSynSets(Chunks[i].TaggedWords[j - 1].Word + "_" + Chunks[i].TaggedWords[j].Word, "noun").Count > 0)
{
Chunks[i].TaggedWords[j].Word = Chunks[i].TaggedWords[j - 1].Word + "_" + Chunks[i].TaggedWords[j].Word;
Chunks[i].TaggedWords[j].Index = Chunks[i].TaggedWords[j - 1].Index;
Chunks[i].TaggedWords.RemoveRange(j - 1, 1);
TextVectors.RemoveAt(d);
j--;
chunkLength--;
}
}
}
TextVectors.Add(Chunks[i].TaggedWords[j]);
j++;
}
}
else
{
if (Chunks[i].TaggedWords[j].Tag[0] == 'J')
{
// We add adjectives to increase the disambiguation accuracy
TextVectors.Add(Chunks[i].TaggedWords[j]);
}
// Skip any chunk element that is not NNP(S),NN(S), or JJ(*)
j++;
}
}
#endregion
i++;
}
else
{
// Remove the current Chunk since it was checked during rectification phase of the previous step
// Keeping only NPs is for efficiency reason during the last step of the algorithm
Chunks.RemoveRange(i, 1);
chunksLength--;
}
}
#region Disambiguatation
d = TextVectors.Count;
// Normalize NNP* vectors before the actual disambiguatation
// Performing normalization after disambiguatation may affects caching the concepts since the keys may change
for (i = 0; i < d; i++)
{
if (TextVectors[i].Tag.StartsWith("NNP"))
{
for (j = 0; j < d; j++)
{
if (TextVectors[j].Tag.StartsWith("NNP"))
{
if (TextVectors[i].Word.Contains(TextVectors[j].Word))
{
TextVectors[j].Word = TextVectors[i].Word;
TextVectors[j].Tag = TextVectors[i].Tag;
}
else
if (TextVectors[j].Word.Contains(TextVectors[i].Word))
{
TextVectors[i].Word = TextVectors[j].Word;
TextVectors[i].Tag = TextVectors[j].Tag;
}
}
}
}
}
for (i = 0; i < d; i++)
{
// For limiting access to the list -- Efficiency
curToken = TextVectors[i].Word;
if (TextVectors[i].Tag == "NN" || TextVectors[i].Tag == "NNS")
{
if (CachedConcepts.ContainsKey(curToken))
{
TextVectors[i].Sense = CachedConcepts[curToken];
}
else
{
// Check availability in WordNet
Senses = _wn.GetSynSets(curToken, false, WordNetEngine.POS.Noun);
if (Senses.Count > 0)
{
tmpSense = Disambiguate(Senses, GenerateContextWindow(i, d));
CachedConcepts.Add(curToken, tmpSense);
TextVectors[i].Sense = CachedConcepts[curToken];
}
}
}
else
if (TextVectors[i].Tag.StartsWith("NNP"))
{
if (CachedConcepts.ContainsKey(curToken))
{
TextVectors[i].Sense = CachedConcepts[curToken];
continue;
}
Senses = _wn.GetSynSets(curToken.Replace(" ", "_"), false, WordNetEngine.POS.Noun);
if (Senses.Count > 0)
{
tmpSense = Disambiguate(Senses, GenerateContextWindow(i, d));
CachedConcepts.Add(curToken, tmpSense);
TextVectors[i].Sense = CachedConcepts[curToken];
continue;
}
if (PlugInsNumber > 0)
{
Senses.Clear();
for (l = 0; l < PlugInsNumber; l++)
{
KBDriverQueryArgs[1] = curToken;
tmpSenses = KBDriversQueryPointers[l].Invoke(KBDrivers[l], KBDriverQueryArgs) as List <SynSet>;
if (tmpSenses != null)
{
Senses.AddRange(tmpSenses);
}
}
if (Senses.Count > 0)
{
tmpSense = Disambiguate(Senses, GenerateContextWindow(i, d));
CachedConcepts.Add(curToken, tmpSense);
TextVectors[i].Sense = CachedConcepts[curToken];
continue;
}
}
if (TextVectors[i].Tag.EndsWith("J"))
{
TextVectors[i].Word = curToken.Substring(curToken.IndexOf(" ") + 1);
TextVectors[i].Tag = TextVectors[i].Tag.Substring(0, TextVectors[i].Tag.Length - 1);
i--;
continue;
}
}
}
// Prepare the vectors for semantic similarity measurement
// hence, any vector does not hold valid sense must be excluded from the list in temp list
i = 0;
while (i < d)
{
if (TextVectors[i].Sense == null)
{
if (TextVectors[i].Tag.StartsWith("NNP") && !MiscTerms.Contains(TextVectors[i].Word))
{
MiscTerms.Add(TextVectors[i].Word);
}
TextVectors.RemoveAt(i);
d--;
}
else
{
i++;
}
}
#endregion
// [Implicit-Dispose]
tmpSense = null;
tmpSenses = null;
Senses = null;
#endregion
#region Section 3.2.
// Row * Col - Diagonal / 2 (above or under the Diagonal)
double[] S = new double[((d * d) - d) / 2];
// Dummy counter
k = 0;
for (i = 0; i < d; i++)
{
for (j = i + 1; j < d; j++)
{
S[k] = Math.Round(wupMeasure(TextVectors[i].Sense, TextVectors[j].Sense), 4);
k++;
}
}
// Perform clustering on S
int[] res = ap.Run(S, d, 1, 0.9, 1000, 50);
// Optimized Clustering information collection
// We collect clustering information and at the same time filter out all terms that are not close to their exemplars
Dictionary <int, List <int> > ClusRes = new Dictionary <int, List <int> >();
// ===================================
for (i = 0; i < res.Length; i++)
{
if (!ClusRes.ContainsKey(res[i]))
{
ClusRes.Add(res[i], new List <int>());
}
if (i == res[i])
{
ClusRes[res[i]].Add(i);
continue;
}
if (Math.Round(wupMeasure(TextVectors[res[i]].Sense, TextVectors[i].Sense), 4) >= ClosenessToCentroid)
{
ClusRes[res[i]].Add(i);
}
}
Console.WriteLine("-> Clustering Information:\n");
foreach (KeyValuePair <int, List <int> > kv in ClusRes)
{
Console.Write("\t[" + TextVectors[kv.Key].Word + "] " + TextVectors[kv.Key].Sense.ID + " : ");
foreach (var item in kv.Value)
{
Console.Write(TextVectors[item].Word + ",");
}
Console.WriteLine();
Console.WriteLine();
}
// Manual averaging of exemplars (Sec. 3.2)
Console.WriteLine("-> Remove unimportant clusters:");
bool delFlag;
while (true)
{
delFlag = false;
Console.Write("\tEnter Seed:");
curToken = Console.ReadLine();
if (curToken == "$")
{
break;
}
foreach (var key in ClusRes.Keys)
{
if (TextVectors[key].Word == curToken)
{
delFlag = ClusRes.Remove(key);
break;
}
}
if (delFlag)
{
Console.WriteLine("\tCluster deleted");
}
else
{
Console.WriteLine("\tSeed is not found");
}
Console.WriteLine();
}
// ESA-Based averaging of exemplars
// Insert here local server API
#endregion
#region Section 3.3.
// Flatten ClusRes into List
List <int> Seeds = ClusRes.Values
.SelectMany(x => x) // Flatten
.ToList();
// Final seeds list must be sorted in case of using candidate phrase selection from a window
//Seeds.Sort();
List <string> CandidatePhrases = new List <string>();
List <string> CandidatePhraseSeed = new List <string>();
SelectionWindowSize = Chunks.Count;
for (i = 0; i < Chunks.Count; i++)
{
if (Chunks[i].Tag == "NP")
{
d = Chunks[i].TaggedWords.Count;
for (l = 0; l < Seeds.Count; l++)
{
for (j = 0; j < d; j++)
{
if (Chunks[i].TaggedWords[j].Word == TextVectors[Seeds[l]].Word)
{
if (TextVectors[Seeds[l]].Tag.StartsWith("NNP") && !CandidatePhrases.Contains(TextVectors[Seeds[l]].Word) && i < SelectionWindowSize)
{
CandidatePhrases.Add(TextVectors[Seeds[l]].Word);
if (TextVectors[Seeds[l]].Sense.URI != null)
{
CandidatePhraseSeed.Add(TextVectors[Seeds[l]].Sense.URI);
}
else
{
CandidatePhraseSeed.Add("http://www.pdl.io/core_onto/" + TextVectors[Seeds[l]].Sense.ID);
}
}
else
if (TextVectors[Seeds[l]].Tag == "NN" || TextVectors[Seeds[l]].Tag == "NNS")
{
curToken = TextVectors[Seeds[l]].Word;
if (j > 0 && Chunks[i].TaggedWords[j - 1].Tag == "JJ")
{
curToken = Chunks[i].TaggedWords[j - 1].Word + " " + curToken;
}
for (k = j + 1; k < d; k++)
{
if (Chunks[i].TaggedWords[k].Tag != "NN")
{
break;
}
else
{
curToken = curToken + " " + Chunks[i].TaggedWords[k].Word;
}
}
if (curToken.Contains(" ") || curToken.Contains("_"))
{
if (!CandidatePhrases.Contains(curToken))
{
CandidatePhrases.Add(curToken);
if (TextVectors[Seeds[l]].Sense.URI != null)
{
CandidatePhraseSeed.Add(TextVectors[Seeds[l]].Sense.URI);
}
else
{
CandidatePhraseSeed.Add("http://www.pdl.io/core_onto/" + TextVectors[Seeds[l]].Sense.ID);
}
}
}
}
}
}
}
}
}
#endregion
// Print results
Console.WriteLine("\n-> Candidate Keyphrases:\n");
for (i = 0; i < CandidatePhrases.Count; i++)
{
Console.WriteLine("\t" + CandidatePhrases[i].Replace("_", " ") + " , URI:" + CandidatePhraseSeed[i]);
}
Console.WriteLine("\n-> MISC Entities:\n");
for (i = 0; i < MiscTerms.Count; i++)
{
Console.WriteLine("\t" + MiscTerms[i]);
}
}
}
//This method will initite the search process.
private void searchQuery()
{
if (!LuceneSearch.isIndexAvailale())
{
MessageBox.Show("Please create/load an index first", "Index Error");
return;
}
if (String.IsNullOrEmpty(QueryBox.Text))
{
MessageBox.Show("Please enter a query to search.", "Retry");
return;
}
resultsTable.Rows.Clear();
resultsTable.Refresh();
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
if (queryExpansionCheckBox.Checked == false && multiTermCheckBox.Checked == false)
{
//Lucene search without query expansion
LuceneSearch.CreateSearcher();
LuceneSearch.CreateParser(LuceneSearch.FIELDS_FN[2]);
Query parsedQuery = LuceneSearch.ParseQuery(QueryBox.Text);
queryTextBox.Text = parsedQuery.ToString();
TopDocs resultDocs = LuceneSearch.SearchText(parsedQuery);
DisplaySearch(resultDocs);
}
else if (queryExpansionCheckBox.Checked == true)
{
//Lucene search with query expansion
var directory = Directory.GetCurrentDirectory() + "/wordnet";
var wordNet = new WordNetEngine();
wordNet.AddDataSource(new StreamReader(Path.Combine(directory, "data.adj")), PartOfSpeech.Adjective);
wordNet.AddDataSource(new StreamReader(Path.Combine(directory, "data.adv")), PartOfSpeech.Adverb);
wordNet.AddDataSource(new StreamReader(Path.Combine(directory, "data.noun")), PartOfSpeech.Noun);
wordNet.AddDataSource(new StreamReader(Path.Combine(directory, "data.verb")), PartOfSpeech.Verb);
wordNet.AddIndexSource(new StreamReader(Path.Combine(directory, "index.adj")), PartOfSpeech.Adjective);
wordNet.AddIndexSource(new StreamReader(Path.Combine(directory, "index.adv")), PartOfSpeech.Adverb);
wordNet.AddIndexSource(new StreamReader(Path.Combine(directory, "index.noun")), PartOfSpeech.Noun);
wordNet.AddIndexSource(new StreamReader(Path.Combine(directory, "index.verb")), PartOfSpeech.Verb);
wordNet.Load();
string baseQuery = QueryBox.Text.ToLower();
List <string> tokenizedBaseQuery = LuceneSearch.TokenizeString(baseQuery);
string synonyms = "";
string finalQuery = "";
foreach (string token in tokenizedBaseQuery)
{
finalQuery += token + "^5 ";
List <SynSet> synSetList = wordNet.GetSynSets(token);
if (synSetList.Count != 0)
{
foreach (SynSet synSet in synSetList)
{
foreach (string word in synSet.Words)
{
if (!word.Equals(token))
{
synonyms += word + " ";
}
}
}
}
}
finalQuery += synonyms;
LuceneSearch.CreateSearcher();
LuceneSearch.CreateParser(LuceneSearch.FIELDS_FN[2]);
Query parsedQuery = LuceneSearch.ParseQuery(finalQuery);
queryTextBox.Text = parsedQuery.ToString();
TopDocs resultDocs = LuceneSearch.SearchText(parsedQuery);
DisplaySearch(resultDocs);
}
else if (multiTermCheckBox.Checked == true)
{
LuceneSearch.CreateSearcher();
LuceneSearch.CreateParser(LuceneSearch.FIELDS_FN[2]);
Query parsedQuery = LuceneSearch.ParseQuery("\"" + QueryBox.Text + "\"");
queryTextBox.Text = parsedQuery.ToString();
TopDocs resultDocs = LuceneSearch.SearchText(parsedQuery);
DisplaySearch(resultDocs);
}
stopwatch.Stop();
TimeSpan elapsed = stopwatch.Elapsed;
string elapsedTime = elapsed.ToString(@"hh\:mm\:ss\.fff");
SearchTimeLabel.Text = "Search time elapsed: " + elapsedTime;
}
