private void getRightYield(Tree<T> node, List<T> rightYield) { for (int rightChildId = node.getPositionAmongParentsChildren() + 1; rightChildId < node .getParent().getNumberOfChildren(); rightChildId++) { List<Tree<T>> rightChildYield = node.getParent().getChild(rightChildId).getYield(); for (Tree<T> rightYieldItem : rightChildYield) { rightYield.add(rightYieldItem.getLabel()); } } }
private Tree<Constituent> getConstituentSubTree(Tree<Pair<String, IntPair>> parseTree) { Pair<String, IntPair> rootLabel = parseTree.getLabel(); Constituent root = createConstituent(rootLabel); Tree<Constituent> constituentTree = new Tree<>(root); for (Tree<Pair<String, IntPair>> child : parseTree.getChildren()) { if (child.isLeaf()) continue; constituentTree.addSubtree(getConstituentSubTree(child)); } return constituentTree; }
/** * Get the labels of all siblings of a given tree node. * * @param node The node whose siblings are required. * @return The labels of the siblings of the input node, as an array of strings. If the input is * the root of the tree, then a string array of size zero is returned to indicate that * the corresponding parse tree node does not have any siblings. */ public static String[] getAllSiblingLabels(Tree<String> node) { List<String> siblings = new ArrayList<>(); if (node.isRoot()) return new String[0]; Tree<String> parent = node.getParent(); for (Tree<String> child : parent.childrenIterator()) { siblings.add(child.getLabel()); } return siblings.toArray(new String[siblings.size()]); }
patternRoot.getParent(); Collections.reverse(l); leftYield.addAll(l); tree = tree.getParent(); } while (!tree.isRoot()); getRightYield(tree, r); rightYield.addAll(r); tree = tree.getParent(); } while (!tree.isRoot()); else { Tree<T> node = dfsPatternMatches.get(item.getFirst()); for (Tree<T> nodeChild : node.getChildren()) { List<Tree<T>> yield = nodeChild.getYield(); for (Tree<T> t : yield) { substitutionList.add(t.getLabel());
if (!c.isRoot() && !c.isLeaf() && !c.getChild(0).isLeaf()) { int start = c.getLabel().getSecond().getFirst() + predicateSentenceStart; int end = c.getLabel().getSecond().getSecond() + predicateSentenceStart; Tree<Pair<String, IntPair>> predicateNode = spanLabeledTree.getYield().get(predicatePosition); for (Tree<Pair<String, IntPair>> sibling : predicateNode.getParent().getParent().getChildren()) { Pair<String, IntPair> siblingNode = sibling.getLabel(); IntPair siblingSpan = siblingNode.getSecond(); int siblingSpanFirst = siblingSpan.getFirst(); Tree<Pair<String, IntPair>> node = predicateNode.getParent(); while (!node.isRoot() && !ParseTreeProperties.isNonTerminalVerb(node.getLabel().getFirst())) node = node.getParent(); for (Tree<Pair<String, IntPair>> verbCandidate : node.getYield()) { if (POSUtils.isPOSVerb(verbCandidate.getParent().getLabel().getFirst())) { int start = verbCandidate.getLabel().getSecond().getFirst() + predicateSentenceStart; int end = start + 1; node = predicateNode.getParent(); while (!node.isRoot()) { String label = node.getLabel().getFirst(); if (label.startsWith("S")) break; for (Tree<Pair<String, IntPair>> nominalCandidate : node.getYield()) { if (POSUtils.isPOSPossessivePronoun(nominalCandidate.getParent().getLabel().getFirst())) {
private Tree<S> parseExpr(Tree<S> tree) { String currentToken = tokens.get(currentTokenId); if (currentToken.equals("(")) { currentTokenId++; currentToken = tokens.get(currentTokenId); Tree<S> newTree = new Tree<>(nodeParser.parseNode(currentToken)); currentTokenId++; newTree = parseSequence(newTree); currentToken = tokens.get(currentTokenId); if (currentToken.equals(")")) { currentTokenId++; tree.addSubtree(newTree); return tree; } else { throw new IllegalArgumentException("Missing close parenthesis near " + currentToken); } } else { tree.addLeaf(nodeParser.parseNode(currentToken)); currentTokenId++; return tree; } }
public static String[] getTerminalStringSentence(Tree<String> tree) { List<String> words = new ArrayList<>(); for (Tree<String> y : tree.getYield()) { if (!ParseTreeProperties.isNullLabel(y.getParent().getLabel())) words.add(ParseUtils.convertBracketsFromPTBFormat(y.getLabel())); } return words.toArray(new String[words.size()]); }
public static <T, S> Tree<S> mapTree(final Tree<T> tree, final ITransformer<Tree<T>, S> transformer) { Tree<S> t = new Tree<>(transformer.transform(tree)); for (Tree<T> treeChild : tree.getChildren()) { t.addSubtree(mapTree(treeChild, transformer)); } return t; }
/** * Assuming that the tree comes with lexical items and POS tags, the subcat frame for the verb * can be found by going to the parent of the POS tag (which is probably a VP) and listing its * children. */ public static String getSubcatFrame(Tree<String> yieldNode) { StringBuilder sb = new StringBuilder(); Tree<String> node = yieldNode.getParent().getParent(); for (Tree<String> t : node.childrenIterator()) { sb.append(t.getLabel()).append(" "); } return sb.toString(); }
private List<String> getUniqueList(Tree<String> tree) { List<String> f = new ArrayList<>(); f.add(tree.getLabel()); for (Tree<String> child : tree.getChildren()) { f.add(child.toString().replaceAll("\\s+", " ")); } Collections.sort(f); return f; }
public static <T, S> Tree<S> mapTreePostfixConditional(Tree<T> tree, ITransformer<Tree<T>, S> transformer, ITransformer<Tree<T>, Boolean> predicate) { List<Tree<S>> children = new ArrayList<>(); for (Tree<T> child : tree.getChildren()) { children.add(mapTreePostfixConditional(child, transformer, predicate)); } Tree<S> newTree = new Tree<>(transformer.transform(tree)); for (int i = 0; i < children.size(); i++) { Tree<S> child = children.get(i); Tree<T> originalChild = tree.getChild(i); if (predicate.transform(originalChild)) newTree.addSubtree(child); } return newTree; }
public static <T, S> Tree<S> mapTree(final Tree<T> tree, final ITransformer<Tree<T>, S> nodeTransformer, final ITransformer<T, S> edgeTransformer) { Tree<S> t = new Tree<>(nodeTransformer.transform(tree)); for (int i = 0; i < tree.getNumberOfChildren(); i++) { Tree<T> treeChild = tree.getChild(i); T edgeLabel = tree.getChildrenEdgeLabels().get(i); t.addSubtree(mapTree(treeChild, nodeTransformer, edgeTransformer), edgeTransformer.transform(edgeLabel)); } return t; }
/** * We need to adjust the tree span offsets, they are relative to the start of the sentence, * we will make them relative to the start of the text. * @param tree the label, span intpair pairs of pairs of pairs. * @param offset the amount to advance the spans. */ private void adjustTree(Tree<Pair<String, IntPair>> tree, int offset) { IntPair span = tree.getLabel().getSecond(); span.setFirst(span.getFirst()+offset); span.setSecond(span.getSecond()+offset); for (Tree<Pair<String, IntPair>> child : tree.getChildren()) { adjustTree(child, offset); } }
@Override public String transform(Tree<String> input) { return input.getLabel(); } });