/** * Set the value for the label (if one is stored). * * @param value The value for the label */ public void setValue(String value) { Label lab = label(); if (lab != null) { lab.setValue(value); } }
@Override public void setValue(String value) { Label lab = label(); if (lab != null) { lab.setValue(value); } }
public static void redoTags(Tree tree, Tagger tagger) { List<Word> words = tree.yieldWords(); List<TaggedWord> tagged = tagger.apply(words); List<Label> tags = tree.preTerminalYield(); if (tags.size() != tagged.size()) { throw new AssertionError("Tags are not the same size"); } for (int i = 0; i < tags.size(); ++i) { tags.get(i).setValue(tagged.get(i).tag()); } }
public Tree transformTree(Tree tree) { for (Tree leaf : tree.getLeaves()) { Label label = leaf.label(); label.setValue(transform.apply(label.value())); } return tree; } }
/** * Looks for new names, destructively strips them out. * Destructively unescapes escaped chars, including "=", as well. */ private void initializeNamesNodesMaps(Tree t) { for (Tree node : t.subTreeList()) { Matcher m = namePattern.matcher(node.label().value()); if (m.find()) { namesToNodes.put(m.group(2), node); nodesToNames.put(node, m.group(2)); node.label().setValue(m.group(1)); } node.label().setValue(unescape(node.label().value())); } }
/** * Sets all of the labels on a tree to the given default value. */ public static void setUnknownLabels(Tree tree, Integer defaultLabel) { if (tree.isLeaf()) { return; } for (Tree child : tree.children()) { setUnknownLabels(child, defaultLabel); } tree.label().setValue(defaultLabel.toString()); }
private static Label headMark(Label l) { Label l1 = l.labelFactory().newLabel(l); l1.setValue(l1.value() + headMark); return l1; }
/** * Sets the labels on the tree to be the indices of the nodes. * Starts counting at the root and does a postorder traversal. */ private static int setIndexLabels(Tree tree, int index) { if (tree.isLeaf()) { return index; } tree.label().setValue(Integer.toString(index)); index++; for (Tree child : tree.children()) { index = setIndexLabels(child, index); } return index; }
public static void setPredictedLabels(Tree tree) { if (tree.isLeaf()) { return; } for (Tree child : tree.children()) { setPredictedLabels(child); } tree.label().setValue(Integer.toString(RNNCoreAnnotations.getPredictedClass(tree))); }
public static void setLabels(Tree tree, Map<String, String> labelMap, MissingLabels missing, String defaultLabel, Set<String> unknowns) { if (tree.isLeaf()) { return; } String text = SentenceUtils.listToString(tree.yield()); String label = labelMap.get(text); if (label != null) { tree.label().setValue(label); } else { switch (missing) { case FAIL: throw new RuntimeException("No label for '" + text + "'"); case DEFAULT: tree.label().setValue(defaultLabel); unknowns.add(text); break; case KEEP_ORIGINAL: // do nothing break; default: throw new IllegalArgumentException("Unknown MissingLabels mode " + missing); } } for (Tree child : tree.children()) { setLabels(child, labelMap, missing, defaultLabel, unknowns); } }
private static Tree findFootNodeHelper(Tree t) { Tree foundDtr = null; if (t.isLeaf()) { Matcher m = footNodeLabelPattern.matcher(t.label().value()); if (m.matches()) { t.label().setValue(m.group(1)); return t; } else { return null; } } for (Tree child : t.children()) { Tree thisFoundDtr = findFootNodeHelper(child); if (thisFoundDtr != null) { if (foundDtr != null) { throw new TsurgeonParseException("Error -- two foot nodes in subtree" + t.toString()); } else { foundDtr = thisFoundDtr; } } } Matcher m = escapedFootNodeCharacter.matcher(t.label().value()); t.label().setValue(m.replaceAll(footNodeCharacter)); return foundDtr; }
@Override public Tree evaluate(Tree tree, TregexMatcher tregex) { int newIndex = coindexer.generateIndex(); for(TsurgeonMatcher child : childMatcher) { Tree node = child.evaluate(tree, tregex); node.label().setValue(node.label().value() + coindexationIntroductionString + newIndex); } return tree; } }
public static Tree normalizeTree(Tree tree, TreeNormalizer tn, TreeFactory tf) { for (Tree node : tree) { if (node.isLeaf()) { node.label().setValue(tn.normalizeTerminal(node.label().value())); } else { node.label().setValue(tn.normalizeNonterminal(node.label().value())); } } return tn.normalizeWholeTree(tree, tf); }
token.setWord(toks[0]); if (token instanceof Label) { ((Label) token).setValue(toks[0]);
Tree tagNode = tf.newTreeNode(goalStr, Collections.singletonList(wordNode)); if (originalTags[start] != null) { tagNode.label().setValue(originalTags[start].tag());
private static void processTree(Tree t, String tag, Morphology morpha) { if (t.isPreTerminal()) { tag = t.label().value(); } if (t.isLeaf()) { t.label().setValue(morpha.lemma(t.label().value(), tag)); } else { for (Tree kid : t.children()) { processTree(kid, tag, morpha); } } }
if (t.numChildren() == 3 && t.firstChild().label().value().equals("NN") && t.getChild(1).label().value().equals("$.")) { log.info("Correcting treebank error: giving phrase label DL to " + t); t.label().setValue("DL");
private static int markStrahler(Tree t) { if (t.isLeaf()) { // don't annotate the words at leaves! return 1; } else { String cat = t.label().value(); int maxStrahler = -1; int maxMultiplicity = 0; for (int i = 0; i < t.numChildren(); i++) { int strahler = markStrahler(t.getChild(i)); if (strahler > maxStrahler) { maxStrahler = strahler; maxMultiplicity = 1; } else if (strahler == maxStrahler) { maxMultiplicity++; } } if (maxMultiplicity > 1) { maxStrahler++; // this is the one case where it grows } cat = cat + '~' + maxStrahler; Label label = t.label().labelFactory().newLabel(t.label()); label.setValue(cat); t.setLabel(label); return maxStrahler; } }