/// <summary>Fix some bizarre peculiarities with certain trees.</summary>
/// <remarks>
/// Fix some bizarre peculiarities with certain trees.
/// So far, these include:
/// <ul>
/// <li>Sometimes there's a node from a word to itself. This seems wrong.</li>
/// </ul>
/// </remarks>
/// <param name="tree">The tree to clean (in place!).</param>
/// <returns>A list of extra edges, which are valid but were removed.</returns>
public static IList <SemanticGraphEdge> CleanTree(SemanticGraph tree)
{
// assert !isCyclic(tree);
// Clean nodes
IList <IndexedWord> toDelete = new List <IndexedWord>();
foreach (IndexedWord vertex in tree.VertexSet())
{
// Clean punctuation
if (vertex.Tag() == null)
{
continue;
}
char tag = vertex.BackingLabel().Tag()[0];
if (tag == '.' || tag == ',' || tag == '(' || tag == ')' || tag == ':')
{
if (!tree.OutgoingEdgeIterator(vertex).MoveNext())
{
// This should really never happen, but it does.
toDelete.Add(vertex);
}
}
}
toDelete.ForEach(null);
// Clean edges
IEnumerator <SemanticGraphEdge> iter = tree.EdgeIterable().GetEnumerator();
IList <Triple <IndexedWord, IndexedWord, SemanticGraphEdge> > toAdd = new List <Triple <IndexedWord, IndexedWord, SemanticGraphEdge> >();
toDelete.Clear();
while (iter.MoveNext())
{
SemanticGraphEdge edge = iter.Current;
if (edge.GetDependent().Index() == edge.GetGovernor().Index())
{
// Clean up copy-edges
if (edge.GetDependent().IsCopy(edge.GetGovernor()))
{
foreach (SemanticGraphEdge toCopy in tree.OutgoingEdgeIterable(edge.GetDependent()))
{
toAdd.Add(Triple.MakeTriple(edge.GetGovernor(), toCopy.GetDependent(), toCopy));
}
toDelete.Add(edge.GetDependent());
}
if (edge.GetGovernor().IsCopy(edge.GetDependent()))
{
foreach (SemanticGraphEdge toCopy in tree.OutgoingEdgeIterable(edge.GetGovernor()))
{
toAdd.Add(Triple.MakeTriple(edge.GetDependent(), toCopy.GetDependent(), toCopy));
}
toDelete.Add(edge.GetGovernor());
}
// Clean self-edges
iter.Remove();
}
else
{
if (edge.GetRelation().ToString().Equals("punct"))
{
// Clean punctuation (again)
if (!tree.OutgoingEdgeIterator(edge.GetDependent()).MoveNext())
{
// This should really never happen, but it does.
iter.Remove();
}
}
}
}
// (add edges we wanted to add)
toDelete.ForEach(null);
foreach (Triple <IndexedWord, IndexedWord, SemanticGraphEdge> edge_1 in toAdd)
{
tree.AddEdge(edge_1.first, edge_1.second, edge_1.third.GetRelation(), edge_1.third.GetWeight(), edge_1.third.IsExtra());
}
// Handle extra edges.
// Two cases:
// (1) the extra edge is a subj/obj edge and the main edge is a conj:.*
// in this case, keep the extra
// (2) otherwise, delete the extra
IList <SemanticGraphEdge> extraEdges = new List <SemanticGraphEdge>();
foreach (SemanticGraphEdge edge_2 in tree.EdgeIterable())
{
if (edge_2.IsExtra())
{
IList <SemanticGraphEdge> incomingEdges = tree.IncomingEdgeList(edge_2.GetDependent());
SemanticGraphEdge toKeep = null;
foreach (SemanticGraphEdge candidate in incomingEdges)
{
if (toKeep == null)
{
toKeep = candidate;
}
else
{
if (toKeep.GetRelation().ToString().StartsWith("conj") && candidate.GetRelation().ToString().Matches(".subj.*|.obj.*"))
{
toKeep = candidate;
}
else
{
if (!candidate.IsExtra() && !(candidate.GetRelation().ToString().StartsWith("conj") && toKeep.GetRelation().ToString().Matches(".subj.*|.obj.*")))
{
toKeep = candidate;
}
}
}
}
foreach (SemanticGraphEdge candidate_1 in incomingEdges)
{
if (candidate_1 != toKeep)
{
extraEdges.Add(candidate_1);
}
}
}
}
extraEdges.ForEach(null);
// Add apposition edges (simple coref)
foreach (SemanticGraphEdge extraEdge in new List <SemanticGraphEdge>(extraEdges))
{
// note[gabor] prevent concurrent modification exception
foreach (SemanticGraphEdge candidateAppos in tree.IncomingEdgeIterable(extraEdge.GetDependent()))
{
if (candidateAppos.GetRelation().ToString().Equals("appos"))
{
extraEdges.Add(new SemanticGraphEdge(extraEdge.GetGovernor(), candidateAppos.GetGovernor(), extraEdge.GetRelation(), extraEdge.GetWeight(), extraEdge.IsExtra()));
}
}
foreach (SemanticGraphEdge candidateAppos_1 in tree.OutgoingEdgeIterable(extraEdge.GetDependent()))
{
if (candidateAppos_1.GetRelation().ToString().Equals("appos"))
{
extraEdges.Add(new SemanticGraphEdge(extraEdge.GetGovernor(), candidateAppos_1.GetDependent(), extraEdge.GetRelation(), extraEdge.GetWeight(), extraEdge.IsExtra()));
}
}
}
// Brute force ensure tree
// Remove incoming edges from roots
IList <SemanticGraphEdge> rootIncomingEdges = new List <SemanticGraphEdge>();
foreach (IndexedWord root in tree.GetRoots())
{
foreach (SemanticGraphEdge incomingEdge in tree.IncomingEdgeIterable(root))
{
rootIncomingEdges.Add(incomingEdge);
}
}
rootIncomingEdges.ForEach(null);
// Loop until it becomes a tree.
bool changed = true;
while (changed)
{
// I just want trees to be trees; is that so much to ask!?
changed = false;
IList <IndexedWord> danglingNodes = new List <IndexedWord>();
IList <SemanticGraphEdge> invalidEdges = new List <SemanticGraphEdge>();
foreach (IndexedWord vertex_1 in tree.VertexSet())
{
// Collect statistics
IEnumerator <SemanticGraphEdge> incomingIter = tree.IncomingEdgeIterator(vertex_1);
bool hasIncoming = incomingIter.MoveNext();
bool hasMultipleIncoming = false;
if (hasIncoming)
{
incomingIter.Current;
hasMultipleIncoming = incomingIter.MoveNext();
}
// Register actions
if (!hasIncoming && !tree.GetRoots().Contains(vertex_1))
{
danglingNodes.Add(vertex_1);
}
else
{
if (hasMultipleIncoming)
{
foreach (SemanticGraphEdge edge in new IterableIterator <SemanticGraphEdge>(incomingIter))
{
invalidEdges.Add(edge_2);
}
}
}
}
// Perform actions
foreach (IndexedWord vertex_2 in danglingNodes)
{
tree.RemoveVertex(vertex_2);
changed = true;
}
foreach (SemanticGraphEdge edge_3 in invalidEdges)
{
tree.RemoveEdge(edge_3);
changed = true;
}
}
// Edge case: remove duplicate dobj to "that."
// This is a common parse error.
foreach (IndexedWord vertex_3 in tree.VertexSet())
{
SemanticGraphEdge thatEdge = null;
int dobjCount = 0;
foreach (SemanticGraphEdge edge in tree.OutgoingEdgeIterable(vertex_3))
{
if (Sharpen.Runtime.EqualsIgnoreCase("that", edge_2.GetDependent().Word()))
{
thatEdge = edge_2;
}
if ("dobj".Equals(edge_2.GetRelation().ToString()))
{
dobjCount += 1;
}
}
if (dobjCount > 1 && thatEdge != null)
{
// Case: there are two dobj edges, one of which goes to the word "that"
// Action: rewrite the dobj edge to "that" to be a "mark" edge.
tree.RemoveEdge(thatEdge);
tree.AddEdge(thatEdge.GetGovernor(), thatEdge.GetDependent(), GrammaticalRelation.ValueOf(thatEdge.GetRelation().GetLanguage(), "mark"), thatEdge.GetWeight(), thatEdge.IsExtra());
}
}
// Return
System.Diagnostics.Debug.Assert(IsTree(tree));
return(extraEdges);
}