/** * Returns the set of incoming edges for the given node that have the given * relation. * * Because certain edges may remain in string form (prepcs), check for both * string and object form of relations. */ public static List<SemanticGraphEdge> incomingEdgesWithReln(IndexedWord node, SemanticGraph sg, GrammaticalRelation reln) { return edgesWithReln(sg.incomingEdgeIterable(node), reln); }
public List<SemanticGraphEdge> incomingEdgeList(IndexedWord v) { return CollectionUtils.toList(incomingEdgeIterable(v)); }
/** * Given a set of vertices from the same graph, returns the set of all edges between these * vertices. */ public static Set<SemanticGraphEdge> allEdgesInSet(Iterable<IndexedWord> vertices, SemanticGraph sg) { Set<SemanticGraphEdge> edges = Generics.newHashSet(); for (IndexedWord v1 : vertices) { for (SemanticGraphEdge edge : sg.outgoingEdgeIterable(v1)) { edges.add(edge); } for (SemanticGraphEdge edge : sg.incomingEdgeIterable(v1)) { edges.add(edge); } } return edges; }
@Override public void evaluate(SemanticGraph sg, SemgrexMatcher sm) { IndexedWord tgtNode = getNamedNode(nodeName, sm); for (SemanticGraphEdge edge : sg.incomingEdgeIterable(tgtNode)) { sg.removeEdge(edge); } }
/** The head of the subject of this relation triple. */ @Override public CoreLabel subjectHead() { if (subject.size() == 1) { return subject.get(0); } Span subjectSpan = Span.fromValues(subject.get(0).index(), subject.get(subject.size() - 1).index()); for (int i = subject.size() - 1; i >= 0; --i) { for (SemanticGraphEdge edge : sourceTree.incomingEdgeIterable(new IndexedWord(subject.get(i)))) { if (edge.getGovernor().index() < subjectSpan.start() || edge.getGovernor().index() >= subjectSpan.end()) { return subject.get(i); } } } return subject.get(subject.size() - 1); }
/** The head of the object of this relation triple. */ @Override public CoreLabel objectHead() { if (object.size() == 1) { return object.get(0); } Span objectSpan = Span.fromValues(object.get(0).index(), object.get(object.size() - 1).index()); for (int i = object.size() - 1; i >= 0; --i) { for (SemanticGraphEdge edge : sourceTree.incomingEdgeIterable(new IndexedWord(object.get(i)))) { if (edge.getGovernor().index() < objectSpan.start() || edge.getGovernor().index() >= objectSpan.end()) { return object.get(i); } } } return object.get(object.size() - 1); }
/** * Returns true if vertex has an incoming relation reln * * @param vertex A node in this graph * @param reln The relation we want to check * @return true if vertex has an incoming relation reln */ public boolean hasParentWithReln(IndexedWord vertex, GrammaticalRelation reln) { if (!containsVertex(vertex)) { throw new IllegalArgumentException(); } for (SemanticGraphEdge edge : incomingEdgeIterable(vertex)) { if (edge.getRelation().equals(reln)) { return true; } } return false; }
protected static void crawl(IndexedWord vertex, SemanticGraph sg, Set<IndexedWord> seenVerts) { seenVerts.add(vertex); for (SemanticGraphEdge edge : sg.incomingEdgeIterable(vertex)) { IndexedWord gov = edge.getGovernor(); if (!seenVerts.contains(gov)) { crawl(gov, sg, seenVerts); } } for (SemanticGraphEdge edge : sg.outgoingEdgeIterable(vertex)) { IndexedWord dep = edge.getDependent(); if (!seenVerts.contains(dep)) { crawl(dep, sg, seenVerts); } } }
/** The head of the relation of this relation triple. */ @Override public CoreLabel relationHead() { if (relation.size() == 1) { return relation.get(0); } CoreLabel guess = null; CoreLabel newGuess = super.relationHead(); int iters = 0; // make sure we don't infinite loop... while (guess != newGuess && iters < 100) { guess = newGuess; iters += 1; for (SemanticGraphEdge edge : sourceTree.incomingEdgeIterable(new IndexedWord(guess))) { // find a node in the relation list which is a governor of the candidate root Optional<CoreLabel> governor = relation.stream().filter(x -> x.index() == edge.getGovernor().index()).findFirst(); // if we found one, this is the new root. The for loop continues if (governor.isPresent()) { newGuess = governor.get(); } } } // Return if (iters >= 100) { err("Likely cycle in relation tree"); } return guess; }
/** * Returns a set of all parents bearing a certain grammatical relation, or an * empty set if none. */ public Set<IndexedWord> getParentsWithReln(IndexedWord vertex, String relnName) { if (vertex.equals(IndexedWord.NO_WORD)) return Collections.emptySet(); if (!containsVertex(vertex)) throw new IllegalArgumentException(); Set<IndexedWord> parentList = wordMapFactory.newSet(); for (SemanticGraphEdge edge : incomingEdgeIterable(vertex)) { if (edge.getRelation().toString().equals(relnName)) { parentList.add(edge.getSource()); } } return parentList; }
/** * Returns a list of pairs of a relation name and the parent * IndexedFeatureLabel to which we bear that relation. */ public List<Pair<GrammaticalRelation, IndexedWord>> parentPairs(IndexedWord vertex) { if (!containsVertex(vertex)) { throw new IllegalArgumentException(); } List<Pair<GrammaticalRelation, IndexedWord>> parentPairs = Generics.newArrayList(); for (SemanticGraphEdge e : incomingEdgeIterable(vertex)) { parentPairs.add(new Pair<>(e.getRelation(), e.getSource())); } return parentPairs; }
/** * Returns a set of all parents bearing a certain grammatical relation, or an * empty set if none. */ public Set<IndexedWord> getParentsWithReln(IndexedWord vertex, GrammaticalRelation reln) { if (vertex.equals(IndexedWord.NO_WORD)) return Collections.emptySet(); if (!containsVertex(vertex)) throw new IllegalArgumentException(); Set<IndexedWord> parentList = wordMapFactory.newSet(); for (SemanticGraphEdge edge : incomingEdgeIterable(vertex)) { if (edge.getRelation().equals(reln)) { parentList.add(edge.getSource()); } } return parentList; }
@Override public String toString() { List<Pair<String, Integer>> glosses = new ArrayList<>(); for (CoreLabel word : words) { // Add the word itself glosses.add(Pair.makePair(word.word(), word.index() - 1)); String addedConnective = null; // Find additional connectives for (SemanticGraphEdge edge : parseTree.incomingEdgeIterable(new IndexedWord(word))) { String rel = edge.getRelation().toString(); if (rel.contains("_")) { // for Stanford dependencies only addedConnective = rel.substring(rel.indexOf('_') + 1); } } if (addedConnective != null) { // Found a connective (e.g., a preposition or conjunction) Pair<Integer, Integer> yield = parseTree.yieldSpan(new IndexedWord(word)); glosses.add(Pair.makePair(addedConnective.replaceAll("_", " "), yield.first - 1)); } } // Sort the sentence Collections.sort(glosses, (a, b) -> a.second - b.second); // Return the sentence return StringUtils.join(glosses.stream().map(Pair::first), " "); }
for (SemanticGraphEdge reverse : tree.incomingEdgeIterable(edge.getDependent())) { if (reverse == edge) { foundReverse = true; } for (SemanticGraphEdge edge : tree.incomingEdgeIterable(vertex)) { boolean foundReverse = false; for (SemanticGraphEdge reverse : tree.outgoingEdgeIterable(edge.getGovernor())) {
for (SemanticGraphEdge inEdge : graph.incomingEdgeIterable(vertex)) { IndexedWord governor = inEdge.getGovernor(); int govIndex = governor.index() - 1; for (SemanticGraphEdge inEdge : graph.incomingEdgeIterable(indexedWords[vertex])) { int governor = inEdge.getGovernor().index() - 1; if (backpointers[vertex] == governor) {
.filter(vertex -> fragmentTree.getFirstRoot() != vertex && tree.getFirstRoot() != vertex && !fragmentTree.incomingEdgeIterable(vertex).iterator().hasNext()) .forEach(vertex -> { SemanticGraphEdge edge = tree.incomingEdgeIterable(vertex).iterator().next(); fragmentTree.addEdge(fragmentTree.getFirstRoot(), edge.getDependent(), edge.getRelation(), edge.getWeight(), edge.isExtra());
/** * Strip away case edges, if the incoming edge is a preposition. * This replicates the behavior of the old Stanford dependencies on universal dependencies. * @param tree The tree to modify in place. */ public static void stripPrepCases(SemanticGraph tree) { // Find incoming case edges that have an 'nmod' incoming edge List<SemanticGraphEdge> toClean = new ArrayList<>(); for (SemanticGraphEdge edge : tree.edgeIterable()) { if ("case".equals(edge.getRelation().toString())) { boolean isPrepTarget = false; for (SemanticGraphEdge incoming : tree.incomingEdgeIterable(edge.getGovernor())) { if ("nmod".equals(incoming.getRelation().getShortName())) { isPrepTarget = true; break; } } if (isPrepTarget && !tree.outgoingEdgeIterator(edge.getDependent()).hasNext()) { toClean.add(edge); } } } // Delete these edges for (SemanticGraphEdge edge : toClean) { tree.removeEdge(edge); tree.removeVertex(edge.getDependent()); assert isTree(tree); } }
for (SemanticGraphEdge edge : sg.incomingEdgeIterable(rootNode)) { sg.addEdge(edge.getGovernor(), newNode, edge.getRelation(), edge.getWeight(), edge.isExtra());
@Override public void evaluate(SemanticGraph sg, SemgrexMatcher sm) { boolean govWild = govName.equals(WILDCARD_NODE); boolean depWild = depName.equals(WILDCARD_NODE); IndexedWord govNode = getNamedNode(govName, sm); IndexedWord depNode =getNamedNode(depName, sm); if (govNode != null && depNode != null) { SemanticGraphEdge edge = sg.getEdge(govNode, depNode, relation); if (edge != null) { @SuppressWarnings("unused") boolean successFlag = sg.removeEdge(edge); } } else if (depNode != null && govWild) { // dep known, wildcard gov for (SemanticGraphEdge edge : sg.incomingEdgeIterable(depNode)) { if (edge.getRelation().equals(relation) && sg.containsEdge(edge) ) { sg.removeEdge(edge); } } } else if (govNode != null && depWild) { // gov known, wildcard dep for (SemanticGraphEdge edge : sg.outgoingEdgeIterable(govNode)) { if (edge.getRelation().equals(relation) && sg.containsEdge(edge) ) { sg.removeEdge(edge); } } } }
for (SemanticGraphEdge candidateAppos : tree.incomingEdgeIterable(extraEdge.getDependent())) { if (candidateAppos.getRelation().toString().equals("appos")) { extraEdges.add(new SemanticGraphEdge(extraEdge.getGovernor(), candidateAppos.getGovernor(), extraEdge.getRelation(), extraEdge.getWeight(), extraEdge.isExtra())); for (SemanticGraphEdge incomingEdge : tree.incomingEdgeIterable(root)) { rootIncomingEdges.add(incomingEdge);