Map<AnnotationType, List<Annotation>> getReferencedAnnotations() { Map<AnnotationType, List<Annotation>> referenced = new HashMap<AnnotationType, List<Annotation>>(); List<Annotation> terms = new ArrayList<Annotation>(); terms.add(this.getFrom()); terms.add(this.getTo()); referenced.put(AnnotationType.TERM, terms); return referenced; }
public String getLabel() { if (this.label == null) { final StringBuilder builder = new StringBuilder(); Term term = this.terms.get(0); for (final Dep dep : this.deps) { builder.append(dep.getRfunc().toLowerCase()); if (term.equals(dep.getFrom())) { builder.append('D'); term = dep.getTo(); } else { builder.append('U'); term = dep.getFrom(); } } this.label = builder.toString(); } return this.label; }
/** Creates a new dependency. The Dep is added to the document object. * @param from the origin term of the dependency. * @param to the target term of the dependency. * @param rfunc relational function of the dependency. * @return a new dependency. */ public Dep newDep(Term from, Term to, String rfunc) { Dep newDep = new Dep(from, to, rfunc); annotationContainer.add(newDep, Layer.DEPS, AnnotationType.DEP); return newDep; }
Element depsElem = new Element("deps"); for (Dep dep : deps) { Comment depComment = new Comment(dep.getStr()); depsElem.addContent(depComment); Element depElem = new Element("dep"); depElem.setAttribute("from", dep.getFrom().getId()); depElem.setAttribute("to", dep.getTo().getId()); depElem.setAttribute("rfunc", dep.getRfunc()); if (dep.hasCase()) { depElem.setAttribute("case", dep.getCase());
public static Term srlToSyntacticHead(final KAFDocument document, final Term term) { final Dep dep = document.getDepToTerm(term); if (dep != null) { final String func = dep.getRfunc(); if ("VC".equals(func) || "IM".equals(func)) { return srlToSyntacticHead(document, dep.getFrom()); } } return term; }
public List<Dep> getDepsFromTerm(final Term term) { final List<Dep> result = new ArrayList<Dep>(); for (final Dep dep : getDepsByTerm(term)) { if (dep.getFrom() == term) { result.add(dep); } } return result; }
public Dep getDepToTerm(final Term term) { for (final Dep dep : getDepsByTerm(term)) { if (dep.getTo() == term) { return dep; } } return null; }
public static String extendedPos(final KAFDocument document, final Term term) { final String pos = term.getMorphofeat(); final String lemma = term.getLemma().toLowerCase(); if ("some".equals(lemma) || "many".equals(lemma) || "all".equals(lemma) || "few".equals(lemma) || "this".equals(lemma) || "these".equals(lemma) || "that".equals(lemma) || "those".equals(lemma)) { final Dep dep = document.getDepToTerm(term); if (dep == null || !"NMOD".equals(dep.getRfunc())) { return pos + "P"; // determiner (DT) or adj (JJ) used as demonstrative pronoun } } return pos; }
String depcase = getOptAttribute("case", depElem); if (depcase != null) { newDep.setCase(depcase);
@Override public String toString() { return getStr(); }
Element depsElem = new Element("deps"); for (Dep dep : deps) { Comment depComment = new Comment(StringEscapeUtils.escapeXml11(dep.getStr())); depsElem.addContent(depComment); Element depElem = new Element("dep"); depElem.setAttribute("from", dep.getFrom().getId()); depElem.setAttribute("to", dep.getTo().getId()); depElem.setAttribute("rfunc", dep.getRfunc()); if (dep.hasCase()) { depElem.setAttribute("case", dep.getCase());
&& ("CONJ".equals(dep.getRfunc()) || "COORD".equals(dep.getRfunc())); dep = document .getDepToTerm(dep.getFrom())) { if (clusters.keySet().contains(dep.getFrom())) { clusters.get(head).add(dep.getFrom()); clusters.get(dep.getFrom()).add(head); } else if ("CO".indexOf(dep.getFrom().getPos()) < 0) { break; // don't include intermediate terms that are not conjunctions or commas final List<Term> path = Lists.newArrayList(); for (Dep dep = document.getDepToTerm(head); dep != null; dep = document .getDepToTerm(dep.getFrom())) { final Term term = dep.getFrom(); path.add(term); if (heads.contains(term)) {
private static boolean extractHeadsHelper(final KAFDocument document, final Term term, final java.util.function.Predicate<Term> predicate, final Collection<Term> result) { final String pos = extendedPos(document, term); boolean accepted = false; if (pos.startsWith("V")) { final Term srlHead = syntacticToSRLHead(document, term); if (!term.equals(srlHead)) { accepted = extractHeadsHelper(document, srlHead, predicate, result); } } if (!accepted && (predicate == null || predicate.test(term))) { result.add(term); accepted = true; } if (accepted) { for (final Dep dep : document.getDepsFromTerm(term)) { if (dep.getRfunc().toUpperCase().contains("COORD")) { extractHeadsHelper(document, dep.getTo(), predicate, result); } } } else { for (final Dep dep : document.getDepsFromTerm(term)) { extractHeadsHelper(document, dep.getTo(), predicate, result); } } return accepted; }
public List<Dep> getDepsFromTerm(final Term term) { final List<Dep> result = new ArrayList<Dep>(); for (final Dep dep : (List<Dep>)(List<?>)annotationContainer.getInverse(term, AnnotationType.DEP)) { if (dep.getFrom() == term) { result.add(dep); } } return result; }
public Dep getDepToTerm(final Term term) { for (final Dep dep : getDepsByTerm(term)) { if (dep.getTo() == term) { return dep; } } return null; }
private void emitOpinionArgument(final URI opinionID, @Nullable final URI spanProperty, @Nullable final URI headProperty, @Nullable final Span<Term> span, @Nullable final Set<Term> heads) { if (span != null) { outer: for (final Term term : span.getTargets()) { final Annotation ann = this.annotations.get(term.getId()); URI uri = ann == null ? null : ann.objectURI != null ? ann.objectURI : ann.predicateURI; if (uri == null && "AGV".contains(term.getPos())) { for (final Dep dep : this.document.getDepsFromTerm(term)) { if (dep.getRfunc().equals("VC")) { continue outer; } } uri = emitTerm(term); } if (uri != null) { if (spanProperty != null) { emitFact(opinionID, spanProperty, uri, null, null); } if (headProperty != null && heads != null && heads.contains(term)) { emitFact(opinionID, headProperty, uri, null, null); } } } } }
String depcase = getOptAttribute("case", depElem); if (depcase != null) { newDep.setCase(depcase);
private static String getDepPathString(final Term from, final Iterable<Dep> path) { final StringBuilder builder = new StringBuilder("_"); Term term = from; // current node in the path for (final Dep dep : path) { char prefix; if (dep.getFrom() == term) { prefix = '+'; term = dep.getTo(); } else { prefix = '-'; term = dep.getFrom(); } for (final String label : dep.getRfunc().split("-")) { final Character letter = getDepPathChar(label); builder.append(prefix).append(letter); } builder.append("_"); } return builder.toString(); }