@Override public TreebankNode convert(JCas jCas, TopTreebankNode topNode) { TreebankNode node = topNode.getTerminals(this.terminalNumber); for (int i = 0; i < this.height; i++) node = node.getParent(); return node; }
public static TreebankNode getParent(TreebankNode node) { if (node != null) { node = node.getParent(); } return node; }
@Override public TreebankNode convert(JCas jCas, TopTreebankNode topNode) { return topNode.getTerminals(this.terminalNumber); }
@Override public List<Feature> extract(JCas view, T focusAnnotation) { List<Feature> features = new ArrayList<Feature>(); TreebankNode node = TreebankNodeUtil.selectMatchingLeaf(view, focusAnnotation); if (node != null) { node = node.getParent(); } if (node != null) { node = node.getParent(); } if (node != null) { node = node.getChildren(0); } if (node != null && node.getLeaf()) { features.add(new Feature(this.featureName, node.getCoveredText())); } return features; } }
/** * Format the TreebankNode as a Penn-Treebank-style parenthesized string. * * @param node * The TreebankNode to be formatted. * @return A parenthesized Penn-Treebank-style string. */ public static String toTreebankString(TreebankNode node) { StringBuilder builder = new StringBuilder(); builder.append('(').append(node.getNodeType()); if (node.getLeaf()) { builder.append(' ').append(node.getCoveredText()); } else { for (TreebankNode child : JCasUtil.select(node.getChildren(), TreebankNode.class)) { builder.append(' ').append(toTreebankString(child)); } } builder.append(')'); return builder.toString(); }
public List<Feature> extract(JCas jCas, T source, U target) { List<Feature> features = new ArrayList<Feature>(); TreebankNode sourceNode = TreebankNodeUtil.selectMatchingLeaf(jCas, source); TreebankNode targetNode = TreebankNodeUtil.selectMatchingLeaf(jCas, target); if (sourceNode != null && targetNode != null) { TreebankNodePath path = TreebankNodeUtil.getPath(sourceNode, targetNode); TreebankNode ancestor = path.getCommonAncestor(); features.add(new Feature("CommonAncestor", ancestor == null ? null : ancestor.getNodeType())); features.add(new Feature("SourceToAncestor", pathString(path.getSourceToAncestorPath()))); features.add(new Feature("TargetToAncestor", pathString(path.getTargetToAncestorPath()))); } return features; }
public static TreebankNode getAncestorWithType(TreebankNode node, String type) { while (node != null && !node.getNodeType().equals(type)) { node = node.getParent(); } return node; }
private Event getOrCreateEvent(JCas jCas, Anchor anchor, TreebankNode node) { if (anchor != null && anchor instanceof Event) { return (Event) anchor; } else if (this.createEvents) { Event event = new Event(jCas, node.getBegin(), node.getEnd()); event.setId("e" + this.eventID); this.eventID++; event.addToIndexes(); return event; } else { return null; } }
private boolean contains(TreebankNode node, TreebankNode descendant) { if (node == descendant) { return true; } for (int i = 0; i < node.getChildren().size(); i++) { boolean result = this.contains(node.getChildren(i), descendant); if (result) { return true; } } return false; }
private boolean isVerbPhrase(TreebankNode node) { return node.getNodeType().startsWith("VP"); }
/** * Get the path from the source TreebankNode to the target TreebankNode via the least common * ancestor. * * @param source * The TreebankNode where the path should start. * @param target * The TreebankNode where the path should end. * @return The path from the source node to the target node. */ public static TreebankNodePath getPath(TreebankNode source, TreebankNode target) { List<TreebankNode> sourceToRoot = getPathToRoot(source); List<TreebankNode> targetToRoot = getPathToRoot(target); TreebankNode ancestor = null; while (sourceToRoot.size() > 0 && targetToRoot.size() > 0 && sourceToRoot.get(sourceToRoot.size() - 1) == targetToRoot.get(targetToRoot.size() - 1)) { ancestor = sourceToRoot.remove(sourceToRoot.size() - 1); ancestor = targetToRoot.remove(targetToRoot.size() - 1); } return new TreebankNodePath(ancestor, sourceToRoot, targetToRoot); }
/** * A "pretty print" of this node that may be useful for e.g. debugging. */ public static void print(PrintStream out, TreebankNode node) { out.println(print(node, 0)); }
@Override public TreebankNode convert(JCas jCas, TopTreebankNode topNode) { TreebankNode node = topNode.getTerminals(this.terminalNumber); for (int i = 0; i < this.height; i++) node = node.getParent(); return node; }
TreebankNode findHead(TreebankNode parentNode) { TreebankNode cursor = parentNode; while (cursor.getChildren() != null && cursor.getChildren().size() > 0) cursor = findHead2(cursor); return cursor; }
public static TopTreebankNode getTopNode(TreebankNode node) { if (node instanceof TopTreebankNode) return (TopTreebankNode) node; TreebankNode parent = node.getParent(); while (parent != null) { if (parent instanceof TopTreebankNode) return (TopTreebankNode) parent; node = parent; parent = node.getParent(); } return null; }
private boolean isClause(TreebankNode node) { return node.getNodeType().startsWith("S"); }
@Override public TreebankNode convert(JCas jCas, TopTreebankNode topNode) { return topNode.getTerminals(this.terminalNumber); }
/** * Calculates the depth of the TreebankNode. The root node has depth 0, children of the root node * have depth 1, etc. * * @param node * The TreebankNode whose depth is to be calculated. * @return The depth of the TreebankNode. */ public static int getDepth(TreebankNode node) { int depth = -1; while (node != null) { depth += 1; node = node.getParent(); } return depth; }
private String toTagString(List<TreebankNode> nodes, String join) { StringBuilder builder = new StringBuilder(); for (TreebankNode node : nodes) { if (builder.length() > 0) { builder.append(join); } builder.append(node.getNodeType()); } return builder.toString(); } }
private List<TreebankNode> pathToRoot(TreebankNode leaf) { List<TreebankNode> result = new ArrayList<TreebankNode>(); TreebankNode curr = leaf; while (curr != null) { result.add(curr); curr = curr.getParent(); } return result; }