/// <summary>
/// Compares dependencies.
/// </summary>
/// <param name="source">Source dependency</param>
/// <param name="dest">Destination depenedency</param>
/// <param name="dependeciesAndWordsCount">Number of dependencies and words</param>
/// <returns></returns>
public double Compare(NotenizerDependency source, NotenizerDependency dest, int dependeciesAndWordsCount)
{
try
{
_matchRating = 0;
_oneComparisonRating = NotenizerConstants.MaxMatchValue / Count;
foreach (Comparsion<bool> boolWordComparsionLoop in _boolWordsComparsions)
{
if (boolWordComparsionLoop.Run(source.Governor, dest.Governor))
_matchRating += _oneComparisonRating;
if (boolWordComparsionLoop.Run(source.Dependent, dest.Dependent))
_matchRating += _oneComparisonRating;
}
foreach (Comparsion<double> doubleWordsComparsionLoop in _doubleWordsComparsions)
{
_matchRating += doubleWordsComparsionLoop.Run(source.Governor, dest.Governor, _oneComparisonRating, dependeciesAndWordsCount);
_matchRating += doubleWordsComparsionLoop.Run(source.Dependent, dest.Dependent, _oneComparisonRating, dependeciesAndWordsCount);
}
return _matchRating;
}
catch (Exception ex)
{
throw new Exception("Error comnparing two dependencies." + Environment.NewLine + Environment.NewLine + ex.Message);
}
}
public NoteParticle(NotenizerDependency dependency)
{
_tokenType = dependency.TokenType;
_noteDependency = dependency.Clone();
_noteWord = dependency.CorrespondingWord;
//_noteWordValue = MakeWordConsiderRelation(_noteWord, _noteDependency.Relation);
_noteWordValue = _noteWord.Word;
}
public NoteParticle(String noteWordValue, NotenizerDependency dependency, TokenType tokenType)
{
_tokenType = tokenType;
_noteDependency = dependency.Clone();
_noteDependency.TokenType = tokenType;
_noteWordValue = noteWordValue;
_noteWord = tokenType == TokenType.Dependent ? dependency.Dependent : dependency.Governor;
}
public NotenizerAdvancedLabel(NotenizerDependency dependency, Font font)
: base(font)
{
this._dependency = dependency;
this._representMode = RepresentMode.Dependency;
InitializeComponent();
Init();
}
public NoteParticle(NotenizerDependency dependency, TokenType tokenType, bool considerRelationInWordValueMaking = false)
{
if (tokenType == TokenType.Unidentified)
throw new Exception("Can't make NoteParticle from token of type " + tokenType.ToString());
_tokenType = tokenType;
_noteDependency = dependency.Clone();
_noteDependency.TokenType = tokenType;
_noteWord = _tokenType == TokenType.Dependent ? dependency.Dependent : dependency.Governor;
_noteWordValue = considerRelationInWordValueMaking ? MakeWordConsiderRelation(_noteWord, _noteDependency.Relation) : _noteWord.Word; ;
}
public static double CalculateClosenessDependencies(NotenizerDependency firstDep, NotenizerDependency secondDep, double comparisonValue, int count)
{
return CalculateCloseness(firstDep.Position, secondDep.Position, comparisonValue, count);
}
/// <summary>
/// Gets depeendencies from sentence.
/// </summary>
/// <param name="annotation"></param>
/// <returns></returns>
private NotenizerDependencies GetDepencencies(Annotation annotation)
{
Tree tree;
NotenizerDependency dep;
GrammaticalStructure gramStruct;
NotenizerDependencies dependencies;
NotenizerDependency nsubjComplement;
TreebankLanguagePack treeBankLangPack;
java.util.Collection typedDependencies;
GrammaticalStructureFactory gramStructFact;
tree = annotation.get(typeof(TreeCoreAnnotations.TreeAnnotation)) as Tree;
treeBankLangPack = new PennTreebankLanguagePack();
gramStructFact = treeBankLangPack.grammaticalStructureFactory();
gramStruct = gramStructFact.newGrammaticalStructure(tree);
typedDependencies = gramStruct.typedDependenciesCollapsed();
dependencies = new NotenizerDependencies();
foreach (TypedDependency typedDependencyLoop in (typedDependencies as java.util.ArrayList))
{
dep = new NotenizerDependency(typedDependencyLoop);
dependencies.Add(dep);
if (dep.Relation.IsNominalSubject())
{
nsubjComplement = new NotenizerDependency(typedDependencyLoop);
nsubjComplement.TokenType = dep.TokenType == TokenType.Dependent ? TokenType.Governor : TokenType.Dependent;
dependencies.Add(nsubjComplement);
}
}
return dependencies;
}
/// <summary>
/// Create dependencies from deocument.
/// </summary>
/// <param name="dbEntry"></param>
/// <param name="noteFieldName"></param>
/// <returns></returns>
private static NotenizerDependencies ParseDependencies(BsonDocument dbEntry, String noteFieldName)
{
int position;
TokenType tokenType;
NotenizerWord governor;
NotenizerWord dependent;
BsonDocument governorDoc;
BsonDocument dependantDoc;
NotenizerRelation relation;
ComparisonType comparisonType;
NotenizerDependency dependency;
NotenizerDependencies dependencies = new NotenizerDependencies();
// foreach note dependency
foreach (BsonDocument documentLoop in dbEntry[noteFieldName].AsBsonArray)
{
relation = new NotenizerRelation(documentLoop[DBConstants.RelationNameFieldName].AsString);
// foreach dependency in array of dependencies with same relation name
foreach (BsonDocument dependencyDocLoop in documentLoop[DBConstants.DependenciesFieldName].AsBsonArray)
{
governorDoc = dependencyDocLoop[DBConstants.GovernorFieldName].AsBsonDocument;
dependantDoc = dependencyDocLoop[DBConstants.DependentFieldName].AsBsonDocument;
position = dependencyDocLoop[DBConstants.PositionFieldName].AsInt32;
comparisonType = dependencyDocLoop.GetValue(DBConstants.ComparisonTypeFieldName, ComparisonType.Unidentified).AsInt32.ToEnum<ComparisonType>();
tokenType = dependencyDocLoop.GetValue(DBConstants.TokenTypeFieldName, TokenType.Unidentified).AsInt32.ToEnum<TokenType>();
governor = new NotenizerWord(
governorDoc[DBConstants.POSFieldName].AsString,
governorDoc[DBConstants.IndexFieldName].AsInt32,
governorDoc[DBConstants.LemmaFieldName].AsString,
governorDoc[DBConstants.NERFieldName].AsString);
dependent = new NotenizerWord(
dependantDoc[DBConstants.POSFieldName].AsString,
dependantDoc[DBConstants.IndexFieldName].AsInt32,
dependantDoc[DBConstants.LemmaFieldName].AsString,
dependantDoc[DBConstants.NERFieldName].AsString);
dependency = new NotenizerDependency(governor, dependent, relation, position, comparisonType, tokenType);
dependencies.Add(dependency);
}
}
return dependencies;
}
/// <summary>
/// Sets position of dependnecy and adds it to note part.
/// </summary>
/// <param name="dep"></param>
/// <param name="position"></param>
/// <param name="destionationNotePart"></param>
private void SetPositionAddToNotePart(NotenizerDependency dep, int position, NotePart destionationNotePart)
{
dep.Position = position;
destionationNotePart.Add(new NoteParticle(dep));
}
/// <summary>
/// Finds depdendcy by rule's dependency.
/// </summary>
/// <param name="ruleDependency"></param>
/// <returns></returns>
public NotenizerDependency FindDependency(NotenizerDependency ruleDependency)
{
if (_compressedDependencies.ContainsKey(ruleDependency.Relation.ShortName))
{
foreach (NotenizerDependency dependencyLoop in _compressedDependencies[ruleDependency.Relation.ShortName])
{
if (dependencyLoop.Governor.POS.Type == ruleDependency.Governor.POS.Type
&& dependencyLoop.Dependent.POS.Type == ruleDependency.Dependent.POS.Type)
return dependencyLoop;
}
}
return null;
}
/// <summary>
/// Index of dependnecy.
/// </summary>
/// <param name="dependency"></param>
/// <returns></returns>
public int DependencyIndex(NotenizerDependency dependency)
{
for (int i = 0; i < _dependencies.Count; i++)
{
if (dependency.Dependent.Word == _dependencies[i].Dependent.Word
&& dependency.Governor.Word == _dependencies[i].Governor.Word
&& dependency.Relation.ShortName == _dependencies[i].Relation.ShortName
&& dependency.Dependent.Index == _dependencies[i].Dependent.Index
&& dependency.Governor.Index == _dependencies[i].Governor.Index)
return i;
}
throw new Exception("Sentence doesn't contain dependency: " + dependency.ToString());
}
/// <summary>
/// Fully clones dependency.
/// </summary>
/// <returns></returns>
public NotenizerDependency Clone()
{
NotenizerDependency clonedDep;
if (this._originalDependency == null)
clonedDep = new NotenizerDependency(this._governor, this._dependent, this._relation, this._position, this._comparisonType, this._tokenType);
else
clonedDep = new NotenizerDependency(this._originalDependency);
clonedDep.Position = this._position;
clonedDep.TokenType = this._tokenType;
clonedDep.ComparisonType = this._comparisonType;
return clonedDep;
}
/// <summary>
/// Compares two dependencies
/// </summary>
/// <param name="mainDependency">Main dependency</param>
/// <param name="secondaryDependency">Second dependency</param>
/// <param name="comparisonType">Comparison type</param>
/// <returns></returns>
private bool CompareDependencies(NotenizerDependency mainDependency, NotenizerDependency secondaryDependency, ComparisonType comparisonType)
{
switch (comparisonType)
{
case ComparisonType.DependentToDependant:
return mainDependency.Dependent == secondaryDependency.Dependent;
case ComparisonType.GovernorToGovernor:
return mainDependency.Governor == secondaryDependency.Governor;
case ComparisonType.DependentToGovernor:
return mainDependency.Dependent == secondaryDependency.Governor;
case ComparisonType.GovernorToDependant:
return mainDependency.Governor == secondaryDependency.Dependent;
}
throw new Exception("Error in CompareDependencies. Unidentified Comparison type.");
}
/// <summary>
/// Gets first or null dependency by short name.
/// </summary>
/// <param name="dependencyShortName"></param>
/// <param name="searchResult"></param>
/// <returns></returns>
public NotenizerDependency GetDependencyByShortName(NotenizerDependency mainDependency, ComparisonType comparisonType, params String[] dependencyShortNames)
{
foreach (String dependencyShortNameLoop in dependencyShortNames)
{
if (_compressedDependencies.ContainsKey(dependencyShortNameLoop))
{
foreach (NotenizerDependency dependencyLoop in _compressedDependencies[dependencyShortNameLoop])
{
if (CompareDependencies(mainDependency, dependencyLoop, comparisonType))
{
dependencyLoop.ComparisonType = comparisonType;
return dependencyLoop;
}
}
}
}
return null;
}
/// <summary>
/// Get all dependencies by short name
/// </summary>
/// <param name="mainDependency">Dependency to compare with</param>
/// <param name="comparisonType">Comparison type</param>
/// <param name="dependencyShortNames">Short names</param>
/// <returns></returns>
public List<NotenizerDependency> GetDependenciesByShortName(NotenizerDependency mainDependency, ComparisonType comparisonType, params String[] dependencyShortNames)
{
List<NotenizerDependency> dependencies = new List<NotenizerDependency>();
foreach (String dependencyShortNameLoop in dependencyShortNames)
{
if (_compressedDependencies.ContainsKey(dependencyShortNameLoop))
{
foreach (NotenizerDependency dependencyLoop in _compressedDependencies[dependencyShortNameLoop])
{
if (CompareDependencies(mainDependency, dependencyLoop, comparisonType))
{
dependencyLoop.ComparisonType = comparisonType;
dependencies.Add(dependencyLoop);
}
}
}
}
return dependencies;
}
public static bool SamePosition(NotenizerDependency firstD, NotenizerDependency secondD)
{
return firstD.Position == secondD.Position;
}
public NoteParticle(String noteWordValue, NotenizerWord noteWord, NotenizerDependency noteDependency)
{
_noteWordValue = noteWordValue;
_noteWord = noteWord;
_noteDependency = noteDependency.Clone();
}
/// <summary>
/// Applies rule.
/// Parses sentence by applied rule and part of note of original sentence.
/// </summary>
/// <param name="sentence">Sentence to apply rule to</param>
/// <param name="rule">Rule for parsing to apply</param>
/// <param name="notePart">Part of note</param>
private void ApplyRule(NotenizerSentence sentence, NotenizerDependency rule, NotePart notePart)
{
NotenizerDependency dependency = null;// = sentence.FindDependency(rule);
double match = 0.0;
double currentMatch = 0.0;
foreach (NotenizerDependency dependencyLoop in sentence.Structure.FindDependencies(rule))
{
if (dependencyLoop == null)
continue;
if ((currentMatch = _comparsionManager.Compare(rule, dependencyLoop, sentence.Structure.Dependencies.Count)) > match)
{
match = currentMatch;
dependency = dependencyLoop;
}
}
if (dependency != null)
{
NoteParticle dependencyObj = new NoteParticle(dependency, rule.TokenType, rule.Position);
notePart.Add(dependencyObj);
}
}
/// <summary>
/// Find depdendencies by rule's dependency.
/// </summary>
/// <param name="ruleDependency"></param>
/// <returns></returns>
public IEnumerable<NotenizerDependency> FindDependencies(NotenizerDependency ruleDependency)
{
if (_compressedDependencies.ContainsKey(ruleDependency.Relation.ShortName))
{
foreach (NotenizerDependency dependencyLoop in _compressedDependencies[ruleDependency.Relation.ShortName])
{
if (dependencyLoop.Governor.POS.Type == ruleDependency.Governor.POS.Type
&& dependencyLoop.Dependent.POS.Type == ruleDependency.Dependent.POS.Type)
yield return dependencyLoop;
}
}
}