private boolean filterAntecedent(S begin, S end, S common) { if ( (begin.getAntecedent()==end) || (end.getAntecedent()==begin) ) { return true; } return false; }
/** * Returns the "real" node in the parse-tree that is the antecedent of * the given node. * <P> * If the given node has no antecedent - then the method returns the node itself. * Otherwise, it finds the antecedent of the antecedent of the antecedent of the ... that * is the "real" node (i.e., has no antecedent). * * @param node * @return */ public static <I extends Info, S extends AbstractNode<I, S>> S getDeepAntecedent(S node) { S ret = node; while (ret.getAntecedent()!=null) { ret = ret.getAntecedent(); } return ret; }
private static <T extends Info, S extends AbstractNode<T,S>> List<S> filterHasAntecedent(List<S> list) { List<S> ret = new ArrayList<S>(list.size()); for (S node : list) { if (null==node.getAntecedent()) { ret.add(node); } } return ret; }
private List<S> generateAllNodeList() throws CoreferenceResolutionException { List<S> allNodesList = new LinkedList<>(); for (S tree : trees) { Map<Integer, S> mapBySerial = new LinkedHashMap<>(); for (S node : TreeIterator.iterableTree(tree)) { if (node.getAntecedent()==null) { int serial = InfoGetFields.getSerial(node.getInfo()); if (mapBySerial.containsKey(serial)) {throw new CoreferenceResolutionException("Malformed input. The parse tree has more than one node with the serial "+serial);} mapBySerial.put(serial, node); } } List<Integer> serials = new ArrayList<>(mapBySerial.size()); serials.addAll(mapBySerial.keySet()); Collections.sort(serials); for (Integer serialKey : serials) { allNodesList.add(mapBySerial.get(serialKey)); } } return allNodesList; }
(!prepOughtToBePrepc(head, child)) && (null==child.getAntecedent())
/** * Given a node in the parse-tree, this method finds a direct-child of that node * that is connected to it via "ref" relation, and also has an antecedent. * * @param node * @return */ @StandardSpecific("stanford-dependencies") @ParserSpecific("easyfirst") public static <I extends Info, S extends AbstractNode<I, S>> S getRefWithAntecedent(S node) { S refWithAntecedent = null; if (node.hasChildren()) { for (S child : node.getChildren()) { if ("ref".equals(InfoGetFields.getRelation(child.getInfo()))) { if (child.getAntecedent()!=null) { refWithAntecedent = child; break; } } } } return refWithAntecedent; }
public static <T, S extends AbstractNode<T, S>> void integrateParserAntecedentToCoreference(List<S> textTrees, TreeCoreferenceInformation<S> coreferenceInformation) throws TreeCoreferenceInformationException { for (S tree : textTrees) { for (S node : TreeIterator.iterableTree(tree)) { if (!coreferenceInformation.isNodeExist(node)) { if (node.getAntecedent()!=null) { S deepAntecedent = AbstractNodeUtils.getDeepAntecedentOf(node); if (coreferenceInformation.isNodeExist(deepAntecedent)) { Integer deepAntecedentGroupId = coreferenceInformation.getIdOf(deepAntecedent); coreferenceInformation.addNodeToGroup(deepAntecedentGroupId, node); } } } } } }
boolean hasAntecedent = false; String antecedentId = null; if (node.getAntecedent()!=null) Info infoAntecedent = node.getAntecedent().getInfo(); if (infoAntecedent!=null) antecedentId = node.getAntecedent().getInfo().getId(); else antecedentId = "?";
if (node.getAntecedent()!=null) Info infoAntecedent = node.getAntecedent().getInfo(); if (infoAntecedent!=null) { } else {
boolean hasAntecedent = false; String antecedentId = null; if (node.getAntecedent()!=null) Info infoAntecedent = node.getAntecedent().getInfo(); if (infoAntecedent!=null) antecedentId = node.getAntecedent().getInfo().getId(); else antecedentId = "?";
boolean hasAntecedent = false; String antecedentId = null; if (node.getAntecedent()!=null) Info infoAntecedent = node.getAntecedent().getInfo(); if (infoAntecedent!=null) antecedentId = node.getAntecedent().getInfo().getId(); else antecedentId = "?";
if (node.getAntecedent()!=null) Info infoAntecedent = node.getAntecedent().getInfo(); if (infoAntecedent!=null) { } else {