/// <summary>
/// Return the node containing the head tag for this node (or
/// <code>null</code> if none), as recorded in this node's {@link
/// CoreLabel <code>CoreLabel</code>}. (In contrast to {@link
/// edu.stanford.nlp.ling.CategoryWordTag
/// <code>CategoryWordTag</code>}, we store head words and head
/// tags as references to nodes, not merely as <code>string</code>s.)
/// </summary>
/// <returns>the node containing the head tag for this node</returns>
public TreeGraphNode HeadTagNode()
{
TreeGraphNode htn = SafeCast(_label.Get(typeof(TreeCoreAnnotations.HeadTagAnnotation)));
if (htn == null || (htn.TreeGraph() != null && !(htn.TreeGraph().Equals(this.TreeGraph()))))
{
return(null);
}
return(htn);
}
/// <summary>
/// Checks the node's ancestors to find the highest ancestor with the
/// same <code>headWordNode</code> as this node
/// </summary>
public TreeGraphNode HighestNodeWithSameHead()
{
TreeGraphNode node = this;
while (true)
{
TreeGraphNode parent = SafeCast(node.Parent());
if (parent == null || parent.HeadWordNode() != node.HeadWordNode())
{
return(node);
}
node = parent;
}
}
/// <summary>
/// Create a new <code>TreeGraphNode</code> having the same tree structure
/// and label values as an existing tree (but no shared storage).
/// Operates recursively to construct an entire subtree
/// </summary>
/// <param name="t">the tree to copy</param>
/// <param name="parent">the parent node</param>
protected TreeGraphNode(Tree t, TreeGraphNode parent)
{
this._parent = parent;
Tree[] tKids = t.Children();
int numKids = tKids.Length;
_children = new TreeGraphNode[numKids];
for (int i = 0; i < numKids; i++)
{
_children[i] = new TreeGraphNode(tKids[i], this);
if (t.IsPreTerminal())
{
// add the tags to the leaves
_children[i]._label.SetTag(t.Label().Value());
}
}
this._label = (CoreLabel)Mlf.NewLabel(t.Label());
}
/// <summary>
/// Uses the specified {@link HeadFinder <code>HeadFinder</code>}
/// to determine the heads for this node and all its descendants,
/// and to store references to the head word node and head tag node
/// in this node's {@link CoreLabel <code>CoreLabel</code>} and the
/// <code>CoreLabel</code>s of all its descendants.
///
/// Note that, in contrast to {@link Tree#percolateHeads
/// <code>Tree.percolateHeads()</code>}, which assumes {@link
/// edu.stanford.nlp.ling.CategoryWordTag
/// <code>CategoryWordTag</code>} labels and therefore stores head
/// words and head tags merely as <code>string</code>s, this
/// method stores references to the actual nodes. This mitigates
/// potential problems in sentences which contain the same word more than once.
/// </summary>
/// <param name="hf">The headfinding algorithm to use</param>
public override void PercolateHeads(IHeadFinder hf)
{
if (IsLeaf())
{
TreeGraphNode hwn = HeadWordNode();
if (hwn == null)
{
SetHeadWordNode(this);
}
}
else
{
foreach (Tree child in Children())
{
child.PercolateHeads(hf);
}
TreeGraphNode head = SafeCast(hf.DetermineHead(this, _parent));
if (head != null)
{
TreeGraphNode hwn = head.HeadWordNode();
if (hwn == null && head.IsLeaf())
{
// below us is a leaf
SetHeadWordNode(head);
}
else
{
SetHeadWordNode(hwn);
}
TreeGraphNode htn = head.HeadTagNode();
if (htn == null && head.IsLeaf())
{
// below us is a leaf
SetHeadTagNode(this);
}
else
{
SetHeadTagNode(htn);
}
}
}
}
/// <summary>
/// Given a {@code Tree} node {@code t}, attempts to
/// return a list of nodes to which node {@code t} has this
/// grammatical relation, with {@code t} as the governor.
/// </summary>
/// <param name="t">Target for finding dependents of t related by this GR</param>
/// <param name="root">The root of the Tree</param>
/// <returns>A Collection of dependent nodes to which t bears this GR</returns>
public ICollection <TreeGraphNode> GetRelatedNodes(TreeGraphNode t, TreeGraphNode root, IHeadFinder headFinder)
{
Set <TreeGraphNode> nodeList = new Util.HashSet <TreeGraphNode>();
foreach (TregexPattern p in targetPatterns)
{
// cdm: I deleted: && nodeList.isEmpty()
// Initialize the TregexMatcher with the HeadFinder so that we
// can use the same HeadFinder through the entire process of
// building the dependencies
TregexMatcher m = p.Matcher(root, headFinder);
while (m.FindAt(t))
{
var target = (TreeGraphNode)m.GetNode("target");
if (target == null)
{
throw new InvalidDataException("Expression has no target: " + p);
}
nodeList.Add(target);
}
}
return(nodeList);
}
// TODO it's not really clear what graph the copy should be a part of
public TreeGraphNode(TreeGraphNode t) :
this(t, t._parent)
{
this.SetTreeGraph(t.TreeGraph());
}
/// <summary>
/// Store the node containing the head tag for this node by
/// storing it in this node's {@link CoreLabel <code>CoreLabel</code>}.
/// (In contrast to {@link edu.stanford.nlp.ling.CategoryWordTag
/// <code>CategoryWordTag</code>}, we store head words and head
/// tags as references to nodes, not merely as
/// <code>string</code>s.)
/// </summary>
/// <param name="htn">the node containing the head tag for this node</param>
private void SetHeadTagNode(TreeGraphNode htn)
{
_label.Set(typeof(TreeCoreAnnotations.HeadTagAnnotation), htn);
}
/// <summary>
/// Store the node containing the head word for this node by
/// storing it in this node's {@link CoreLabel
/// <code>CoreLabel</code>}. (In contrast to {@link
/// edu.stanford.nlp.ling.CategoryWordTag
/// <code>CategoryWordTag</code>}, we store head words and head
/// tags as references to nodes, not merely as <code>string</code>s.)
/// </summary>
/// <param name="hwn">the node containing the head word for this node</param>
private void SetHeadWordNode(TreeGraphNode hwn)
{
_label.Set(typeof(TreeCoreAnnotations.HeadWordAnnotation), hwn);
}
/// <summary>
/// Set the parent for the current node
/// </summary>
public void SetParent(TreeGraphNode parent)
{
this._parent = parent;
}
// TODO it's not really clear what graph the copy should be a part of
public TreeGraphNode(TreeGraphNode t) :
this(t, t._parent)
{
this.SetTreeGraph(t.TreeGraph());
}
/// <summary>
/// Store the node containing the head tag for this node by
/// storing it in this node's {@link CoreLabel <code>CoreLabel</code>}.
/// (In contrast to {@link edu.stanford.nlp.ling.CategoryWordTag
/// <code>CategoryWordTag</code>}, we store head words and head
/// tags as references to nodes, not merely as
/// <code>string</code>s.)
/// </summary>
/// <param name="htn">the node containing the head tag for this node</param>
private void SetHeadTagNode(TreeGraphNode htn)
{
_label.Set(typeof (TreeCoreAnnotations.HeadTagAnnotation), htn);
}
/// <summary>
/// Store the node containing the head word for this node by
/// storing it in this node's {@link CoreLabel
/// <code>CoreLabel</code>}. (In contrast to {@link
/// edu.stanford.nlp.ling.CategoryWordTag
/// <code>CategoryWordTag</code>}, we store head words and head
/// tags as references to nodes, not merely as <code>string</code>s.)
/// </summary>
/// <param name="hwn">the node containing the head word for this node</param>
private void SetHeadWordNode(TreeGraphNode hwn)
{
_label.Set(typeof (TreeCoreAnnotations.HeadWordAnnotation), hwn);
}
/// <summary>
/// Set the parent for the current node
/// </summary>
public void SetParent(TreeGraphNode parent)
{
this._parent = parent;
}
/// <summary>
/// Create a new <code>TreeGraphNode</code> having the same tree structure
/// and label values as an existing tree (but no shared storage).
/// Operates recursively to construct an entire subtree
/// </summary>
/// <param name="t">the tree to copy</param>
/// <param name="parent">the parent node</param>
protected TreeGraphNode(Tree t, TreeGraphNode parent)
{
this._parent = parent;
Tree[] tKids = t.Children();
int numKids = tKids.Length;
_children = new TreeGraphNode[numKids];
for (int i = 0; i < numKids; i++)
{
_children[i] = new TreeGraphNode(tKids[i], this);
if (t.IsPreTerminal())
{
// add the tags to the leaves
_children[i]._label.SetTag(t.Label().Value());
}
}
this._label = (CoreLabel) Mlf.NewLabel(t.Label());
}