/*--------------------------------------------------------------------------------------------*/
private void InsertSynsetFactors(ISession pSess)
{
using (ITransaction tx = pSess.BeginTransaction()) {
Console.WriteLine("Building Synset Factors...");
foreach (Artifact art in vArtSet.List)
{
if (art.Synset == null)
{
continue;
}
Synset ss = pSess.Get <Synset>(art.Synset.Id);
Artifact targArt = vArtSet.WordIdMap[WordNet31WordId];
var f = new Factor();
f.PrimaryArtifact = art;
f.RelatedArtifact = targArt;
f.IsDefining = false;
f.DescriptorTypeId = (byte)DescriptorTypeId.RefersTo;
f.AssertionId = (byte)FactorAssertionId.Fact;
f.Note = "[" + art.Name + "] " + DescriptorTypeId.RefersTo + " [" + targArt.Name + "]";
f.RelatedClassRefine = vArtSet.WordIdMap[SynsetWordId];
f.IdentorTypeId = (int)IdentorTypeId.Key;
f.IdentorValue = ss.SsId;
pSess.Save(f);
}
Console.WriteLine("Comitting Factors..." + TimerString());
tx.Commit();
Console.WriteLine("Finished Factors" + TimerString());
Console.WriteLine("");
}
}
public static Synset GetSynsetById(int synsetId)
{
Synset result = null;
string sql = "SELECT id, pos, semanticCategory, example, gloss, nofather, noMapping FROM synset WHERE id=" + synsetId;
using (var conn = new SQLiteConnection(SqlLiteDbUtility.SqlLiteConnection))
{
using (var cmd = conn.CreateCommand())
{
conn.Open();
cmd.CommandText = sql;
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
result = new Synset(reader.GetInt32(0), reader.GetString(1), reader.GetString(2), reader.GetString(3), reader.GetString(4), Convert.ToString(reader[5]), Convert.ToString(reader[6]));
}
}
}
}
return(result);
}
/*--------------------------------------------------------------------------------------------*/
private void InsertSynSet(ISession pSess, SynSet pSynSet)
{
if (SynsetCache.ContainsKey(pSynSet.ID))
{
return;
}
var dbSyn = new Synset();
dbSyn.SsId = pSynSet.ID;
dbSyn.PartOfSpeechId = (byte)pSynSet.POS;
dbSyn.Gloss = pSynSet.Gloss;
pSess.Save(dbSyn);
SynsetCache.Add(pSynSet.ID, dbSyn);
foreach (string word in pSynSet.Words)
{
if (WordCache.ContainsKey(pSynSet.ID + "|" + word))
{
continue;
}
var dbWord = new Word();
dbWord.Name = word;
dbWord.Synset = dbSyn;
pSess.Save(dbWord);
WordCache.Add(pSynSet.ID + "|" + word, dbWord);
}
}
/*--------------------------------------------------------------------------------------------*/
private static void InsertLexAndSemForSynSet(ISession pSess, string pSynSetId, SynSet pSynSet)
{
Synset dbSynSet = SynsetCache[pSynSetId];
List <LexicalRelation> lexRels = pSynSet.GetLexicallyRelated();
foreach (LexicalRelation lr in lexRels)
{
var dbLex = new Lexical();
dbLex.Synset = dbSynSet;
dbLex.Word = WordCache[dbLex.Synset.SsId + "|" + lr.FromWord];
dbLex.RelationId = (byte)lr.Relation;
dbLex.TargetSynset = SynsetCache[lr.ToSyn.ID];
dbLex.TargetWord = WordCache[dbLex.TargetSynset.SsId + "|" + lr.ToWord];
pSess.Save(dbLex);
}
foreach (WordNetEngine.SynSetRelation rel in pSynSet.SemanticRelations)
{
Set <SynSet> relSet = pSynSet.GetRelatedSynSets(rel, false);
foreach (SynSet rs in relSet)
{
var dbSem = new Semantic();
dbSem.Synset = dbSynSet;
dbSem.RelationId = (byte)rel;
dbSem.TargetSynset = SynsetCache[rs.ID];
pSess.Save(dbSem);
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public static List <String> GetWordList(Synset pSynset)
{
var words = new List <string>();
foreach (Word w in pSynset.WordList)
{
words.Add(FixWordName(w));
}
return(words);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public SemanticNode(Synset pSynSet)
{
SynSet = pSynSet;
Relations = new Dictionary <WordNetEngine.SynSetRelation, List <SemanticNode> >();
Lexicals = new Dictionary <WordNetEngine.SynSetRelation, List <SemanticNode> >();
foreach (WordNetEngine.SynSetRelation ssr in Stats.Relations)
{
Relations.Add(ssr, new List <SemanticNode>());
Lexicals.Add(ssr, new List <SemanticNode>());
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private void InsertPartOfSpeechFactors(ISession pSess)
{
using (ITransaction tx = pSess.BeginTransaction()) {
Console.WriteLine("Building Part-of-Speech Factors...");
foreach (Artifact art in vArtSet.List)
{
Synset ss = pSess.Get <Synset>(art.Synset == null ?
vArtSet.WordIdToSynsetIdMap[art.Word.Id] : art.Synset.Id);
Artifact targArt;
switch (ss.PartOfSpeechId)
{
case (int)WordNetEngine.POS.Noun:
targArt = vArtSet.WordIdMap[NounWordId];
break;
case (int)WordNetEngine.POS.Verb:
targArt = vArtSet.WordIdMap[VerbWordId];
break;
case (int)WordNetEngine.POS.Adjective:
targArt = vArtSet.WordIdMap[AdjectiveWordId];
break;
case (int)WordNetEngine.POS.Adverb:
targArt = vArtSet.WordIdMap[AdverbWordId];
break;
default:
Console.WriteLine("Unknown POS: " +
art.Id + " / " + art.Name + " / " + ss.PartOfSpeechId);
continue;
}
var f = new Factor();
f.PrimaryArtifact = art;
f.RelatedArtifact = targArt;
f.IsDefining = true;
f.DescriptorTypeId = (byte)DescriptorTypeId.IsAnInstanceOf;
f.AssertionId = (byte)FactorAssertionId.Fact;
f.Note = "[" + art.Name + "] " + DescriptorTypeId.IsAnInstanceOf + " [" + targArt.Name + "]";
f.PrimaryClassRefine = vArtSet.WordIdMap[PartOfSpeechWordId];
pSess.Save(f);
}
Console.WriteLine("Comitting Factors..." + TimerString());
tx.Commit();
Console.WriteLine("Finished Factors" + TimerString());
Console.WriteLine("");
}
}
//private void getParents(Synset synset, System.Collections.IList parents)
//{
//Pointer[] pointers = synset.getPointers();
//for (int pi = 0, pn = pointers.length; pi < pn; pi++)
//{
// if (pointers[pi].getType() == PointerType.HYPERNYM)
// {
// Synset parent = pointers[pi].getTargetSynset();
// parents.Add(System.Convert.ToString(parent.getOffset()));
// getParents(parent, parents);
// }
//}
//}
private void getParents(Synset currentSynset, List <string> parentOffsets)
{
for (int currentRelation = 0; currentRelation < currentSynset.RelationCount; currentRelation++)
{
Relation relation = currentSynset.GetRelation(currentRelation);
if (relation.SynsetRelationType.Name == "Hypernym")
{
Synset parentSynset = relation.TargetSynset;
parentOffsets.Add(parentSynset.Offset.ToString(System.Globalization.CultureInfo.InvariantCulture));
getParents(parentSynset, parentOffsets);
}
}
}
/// <summary>
/// Loads the WordNet dataset from local file
/// </summary>
public static void LoadWordNetData()
{
// Loading the JSON file containing the WordNet dataset (originally from https://wordnet.princeton.edu/)
//using var stream = new FileStream(@"C:\users\ssann\source\repos\WordsOpenLinkedData\WordNet\wordnet.json", FileMode.Open);
using var stream = new FileStream(@"WordNet\wordnet.json", FileMode.Open);
using var reader = new StreamReader(stream);
var json = new StringBuilder();
reader.ReadLine(); // Skip initial "{"
reader.ReadLine(); // Skip "synset : {"
int wordCounter = 0;
do
{
// Read records as individual JSON snippets
if (wordCounter == 117791)
{
wordCounter = 0;
}
var s = reader.ReadLine();
if (s.StartsWith(" }", System.StringComparison.OrdinalIgnoreCase)) // There are multiple JSON sets in the file, we only want the first (synset) one
{
break;
}
var id = s.Replace(": {", "", System.StringComparison.OrdinalIgnoreCase).Trim();
json.AppendLine($"{{\"id\":{id},");
do
{
s = reader.ReadLine();
if (s == " },") // Snip off the separating comma, it is syntactically illegal
{
s = " }";
}
json.AppendLine(s);
}while (s != " }");
var wordJson = json.ToString();
json.Clear();
Synset wordObject = (Synset)JsonSerializer.Deserialize(wordJson, typeof(Synset));
WordNetData.SynsetList.Add(wordObject);
WordNetData.SynsetDictionary.Add(wordObject.Id, wordObject);
wordCounter++;
}while (1 == 1);
}
internal void SetCurrentSynset(Synset newCurrentSynset)
{
if (newCurrentSynset != WordSensesForSynsetList.DataContext)
{
WordSensesForSynsetList.DataContext = newCurrentSynset;
// If the new current synset has only one associated word sense, go ahead and select that word sense and make it current.
// If there are multiple associated word senses, the user has to choose one in order to make it the focus of this control.
if (newCurrentSynset.WordSensesForSynset.Count() == 1)
{
WordSense theOnlyWordSenseForThisSynset = newCurrentSynset.WordSensesForSynset.Single();
WordSensesForSynsetList.SelectedItem = theOnlyWordSenseForThisSynset;
WordSenseNavigator.ViewModel.CurrentWordSense = theOnlyWordSenseForThisSynset;
WordSenseNavigator.Visibility = Visibility.Visible;
}
else
{
WordSensesForSynsetList.SelectedItem = null;
WordSenseNavigator.ViewModel.CurrentWordSense = null;
WordSenseNavigator.Visibility = Visibility.Hidden;
}
}
}
internal void SetDropTargets_ForSynset(Synset draggedSynset)
{
if (CurrentSynsetSource.CurrentSynset != null)
{
GetNewSynsetRelationConstraintsResult addRelationConstraints = WordNetData.Context.GetNewSynsetRelationConstraints(CurrentSynsetSource.CurrentSynset.ID, draggedSynset.ID).Single();
Hypernyms.SynsetDropIsEnabled = (bool)addRelationConstraints.CanAddHypernym;
Hyponyms.SynsetDropIsEnabled = (bool)addRelationConstraints.CanAddHyponym;
Holonyms.SynsetDropIsEnabled = (bool)addRelationConstraints.CanAddHolonym;
Meronyms.SynsetDropIsEnabled = (bool)addRelationConstraints.CanAddMeronym;
Types.SynsetDropIsEnabled = (bool)addRelationConstraints.CanAddType;
Instances.SynsetDropIsEnabled = (bool)addRelationConstraints.CanAddInstance;
ValuesOfAttribute.SynsetDropIsEnabled = (bool)addRelationConstraints.CanAddValueOfAttribute;
IsCausedBy.SynsetDropIsEnabled = (bool)addRelationConstraints.CanAddCausedBy;
IsCauseOf.SynsetDropIsEnabled = (bool)addRelationConstraints.CanAddCauseOf;
IsEntailedBy.SynsetDropIsEnabled = (bool)addRelationConstraints.CanAddEntailedBy;
SeeAlso.SynsetDropIsEnabled = (bool)addRelationConstraints.CanAddSeeAlso;
Entails.SynsetDropIsEnabled = (bool)addRelationConstraints.CanAddEntails;
VerbGroupMembers.SynsetDropIsEnabled = (bool)addRelationConstraints.CanAddVerbGroupMember;
Satellites.SynsetDropIsEnabled = (bool)addRelationConstraints.CanAddSatellite;
AttributesWithValue.SynsetDropIsEnabled = (bool)addRelationConstraints.CanAddAttributeWithValue;
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private void BuildArtifacts()
{
foreach (SemanticNode n in vNodes.NodeList)
{
Synset ss = n.SynSet;
List <string> words = ArtNode.GetWordList(ss);
string pos = Stats.PartsOfSpeech[ss.PartOfSpeechId] + "";
Artifact art = new Artifact();
art.Name = string.Join(" / ", (words.Count > 5 ? words.GetRange(0, 5) : words));
art.Name = ArtNode.TruncateString(art.Name, 128);
art.Note = ArtNode.TruncateString(pos + ": " + ss.Gloss, 256);
art.Synset = ss;
art.Word = (words.Count == 1 ? ss.WordList[0] : null);
vList.Add(new ArtNode {
Art = art, Node = n, Word = art.Word
});
if (art.Word != null)
{
continue;
}
for (int i = 0; i < words.Count; ++i)
{
Word w = ss.WordList[i];
art = new Artifact();
art.Name = ArtNode.TruncateString(words[i], 128);
art.Note = ArtNode.TruncateString(pos + ": " + ss.Gloss, 256);
art.Word = w;
vList.Add(new ArtNode {
Art = art, Node = n, Word = art.Word, IsWord = true
});
}
}
Console.WriteLine("Created " + vList.Count + " Artifacts");
}
private static void ParseSynsetContent(XmlNode lexiconChild, Synset synset, bool loadRelations)
{
foreach (XmlNode synsetChild in lexiconChild.ChildNodes)
{
if (synsetChild.Name == "Definition")
{
synset.Definitions.Add(synsetChild.InnerText);
}
else if (synsetChild.Name == "Example")
{
synset.Examples.Add(synsetChild.InnerText);
}
else if (loadRelations && synsetChild.Name == "SynsetRelation")
{
var relation = new SynsetRelation
{
Type = Enum.Parse <SynsetRelationType>(synsetChild.Attributes["relType"].Value),
SourceId = synset.Id,
TargetId = synsetChild.Attributes["target"].Value
};
synset.Relations.Add(relation);
}
}
}
private void OnSynsetSelected(Synset synset) => SynsetSelected?.Invoke(synset);
private void ViewModel_SynsetSelected(Synset synset) => SynsetSelected?.Invoke(synset);
private void WordNetBrowser_SynsetDropCompleted(Synset synset) => SynsetNavigator.ViewModel.Edit.ClearDropTargets();
private void WordNetBrowser_SynsetDragStarted(Synset synset) => SynsetNavigator.ViewModel.Edit.SetDropTargets_ForSynset(synset);
private void SynsetNavigator_SynsetSelected(Synset selectedSynset) => WordSensesControl.SetCurrentSynset(selectedSynset);
private void MeronymsList_MouseDoubleClick(object sender, MouseButtonEventArgs e) => ViewModel.SetCurrentSynset(Synset.WithID(SelectedMeronym.ID));
/// <summary>Respond as appropriate to <paramref name="synset"/> being dropped on this, and return true if successful.</summary> internal bool AcceptDrop_OfSynset(Synset synset) => true;
private void SynsetNavigator_SynsetDragCancelled(Synset synset) => SynsetDragCancelled?.Invoke(synset);
private void SynsetNavigator_SynsetDragStarted(Synset synset) => SynsetDragStarted?.Invoke(synset);
private void OnSynsetDragStarted(Synset synset) => SynsetDragStarted?.Invoke(synset);
private void OnSynsetDragCancelled(Synset synset) => SynsetDragCancelled?.Invoke(synset);
public static void CombineFiles(XDocument aDoc, XDocument bDoc)
{
try
{
notFoundWords.Clear();
notFoundNumbers.Clear();
var xml = new DATA();
var synsets = new List <Synset>();
var sensePlwn = string.Empty;
foreach (var element in aDoc.Descendants(Nodes.Synset))
{
_id++;
string value = "ID_" + _id;
var irlList = new List <ILR>();
var literals = new List <Literal>();
var plwnIDs = new List <PlWN>();
var idPns = new List <PN>();
var xElementsIlr = element?.Descendants(Nodes.ILR);
if (xElementsIlr != null)
{
irlList.AddRange(xElementsIlr.Select(ilr => new ILR()
{
source = Types.Source_PNID,
type = ilr.Attribute("type")?.Value,
Value = ilr.FirstNode.ToString()
}));
}
var xElementsLiteral = element?.Descendants(Nodes.Literal);
if (xElementsLiteral == null)
{
continue;
}
foreach (var literal in xElementsLiteral)
{
var searchingWord = literal.FirstNode.ToString();
var plWnNumbers = SearchNumberBasedOnWord(bDoc, searchingWord);
var polNumbers = SearchNumberBasedOnWord(aDoc, searchingWord);
foreach (var a in polNumbers.Where(a => idPns.All(x => x.Value != a)))
{
idPns.Add(new PN()
{
Value = a
});
}
if (plWnNumbers.Count > 0)
{
foreach (var b in plWnNumbers.Where(b => plwnIDs.All(y => y.Value != b)))
{
plwnIDs.Add(new PlWN()
{
Value = b
});
}
List <XElement> theSameWord =
bDoc.Descendants(Nodes.Literal).Where(x => x.FirstNode.ToString() == searchingWord).ToList();
sensePlwn = theSameWord.Descendants(Nodes.Sense)?.First().Value;
var xElementsIlrPlwn = theSameWord.Ancestors(Nodes.Synset)?.Descendants(Nodes.ILR);
if (xElementsIlrPlwn != null)
{
foreach (var ilr in xElementsIlrPlwn)
{
var forMerged = new Synset();
if (synsets.Count > 0)
{
forMerged =
synsets.Find(
item =>
item?.ID?.PlWN?.ToString().Contains(ilr.FirstNode.ToString()) ??
false);
//Where(s => s?.ID?.PlWN?.Any(x => x.Value == ilr.FirstNode.ToString() ?? true))
}
irlList.Add(new ILR()
{
source = Types.Source_PLWNID,
type = ilr.Descendants(Nodes.ILRType).First().Value,
merged = forMerged?.ID?.Value,
Value = ilr.FirstNode.ToString()
});
}
//irlList.AddRange(xElementsIlrPlwn.Select(ilr => new ILR()
//{
// source = Types.Source_PLWNID,
// type = ilr.Descendants(Nodes.ILRType).First().Value,
// merged = synsets.Count > 0 ? synsets.SingleOrDefault(s => s?.ID?.PlWN?.ToString().Contains(ilr.FirstNode.ToString()) ?? false)?.ID?.Value : null,
// Value = ilr.FirstNode.ToString()
//}));
}
}
string sensePn = literal.Attribute("sense")?.Value;
literals.Add(new Literal()
{
plwnsense = sensePlwn, plwnsenseSpecified = !string.IsNullOrEmpty(sensePlwn), pnsense = sensePn, Value = searchingWord
});
}
synsets.Add(
new Synset
{
ID = new ID()
{
Value = value,
PlWN = plwnIDs.ToArray(),
PN = idPns.ToArray()
},
ILR = irlList.ToArray(),
SYNONYM = literals.ToArray()
});
}
xml.SYNSET = synsets.ToArray();
CreateFile(xml);
}
catch (Exception ex)
{
MessageBox.Show(Messages.ErrorFound + ex.Message);
}
finally
{
try
{
File.WriteAllLines(@"C:\t\notFoundWords.txt", notFoundWords);
MessageBox.Show("Not found words: " + notFoundWords.Count);
File.WriteAllLines(@"C:\t\notFoundNumbers.txt", notFoundNumbers);
MessageBox.Show("Not found numbers: " + notFoundNumbers.Count);
}
catch (Exception)
{
MessageBox.Show("Cannot store data in files.");
}
}
}
internal SynsetToElementBindingViewModel(Synset synset, object element)
{
Synset = synset;
Element = element;
}
private void OnSynsetBoundToNode(IElementTreeNode boundNode, Synset boundSynset) => SynsetBoundToNode?.Invoke(boundNode, boundSynset);
private void SynsetNavigator_SynsetDropCompleted(Synset synset) => SynsetDropCompleted?.Invoke(synset);
private void WordToSynsetSelector_SynsetSelected(Synset selectedSynset)
{
SynsetNavigator.Visibility = Visibility.Visible;
ExpandCollapseWordFinderButton.IsChecked = false;
SynsetNavigator.ViewModel.SetCurrentSynset(selectedSynset);
}
private void OnSynsetDropCompleted(Synset synset) => SynsetDropCompleted?.Invoke(synset);
