private BasicNode buildNode(JCas jcas, int serial, int id, Token token, String depType, Token parent) throws CasTreeConverterException, UnsupportedPosTagStringException { String idString = Integer.toString(id); NodeInfo nodeInfo = buildNodeInfo(jcas, token, serial); EdgeInfo edgeInfo = buildEdgeInfo(jcas, depType); BasicNode node = new BasicNode(new DefaultInfo(idString, nodeInfo, edgeInfo)); nodes.add(node); if (parent != null) { registerChild(parent, token, node); } // Note that the first this method is called for each token, we build its non-deep node. // So for every token, the first node is always the non-deep one. All subsequent nodes // may be deep (if any). Note that the value collection in this MultiMap is a List. tokenToNode.put(token, node); return node; }
@Override public boolean equals(Object obj) { if (this == obj) return true; if (!super.equals(obj)) return false; if (getClass() != obj.getClass()) return false; ExtendedInfo other = (ExtendedInfo) obj; if (additionalNodeInformation == null) { if (other.additionalNodeInformation != null) return false; } else if (!additionalNodeInformation .equals(other.additionalNodeInformation)) return false; return true; }
@Override public int hashCode() { final int prime = 31; int result = super.hashCode(); result = prime * result + ((additionalNodeInformation == null) ? 0 : additionalNodeInformation.hashCode()); return result; }
protected static void createArtificialRoot(Set<Integer> roots,Map<Integer, BasicNode> id2node, Map<Integer, Integer> child2parent) { BasicNode root = new BasicNode(new DefaultInfo("EMPTY", new DefaultNodeInfo(null, null, 0, null, new DefaultSyntacticInfo(null)), new DefaultEdgeInfo(null))); int rootId = ARTIFICIAL_ROOT_ID; id2node.put(rootId,root); Iterator<Integer> it = roots.iterator(); while (it.hasNext()) { child2parent.put(it.next(),rootId); it.remove(); } roots.add(rootId); }
public Info newInfoRTT(Info nodeInfo, Info edgeInfo, Info additionalInformation) { return new DefaultInfo(nodeInfo.getId(), nodeInfo.getNodeInfo(), edgeInfo.getEdgeInfo()); }
public Info newInfoRT(Info nodeInfo, Info edgeInfo) { return new DefaultInfo(nodeInfo.getId(), nodeInfo.getNodeInfo(), edgeInfo.getEdgeInfo()); }
public Info newInfoFromTreeNodeAndRhsNodeAndRhsEdge(Info nodeInfo, Info ruleRhsNodeInfo, Info ruleRhsEdgeInfo) { return new DefaultInfo(nodeInfo.getId(), InfoServicesUtils.combineNodeInfo(nodeInfo, ruleRhsNodeInfo), ruleRhsEdgeInfo.getEdgeInfo()); }
public Info newInfoFromTreeNodeRhsNodeAndEdge(Info treeInfo, Info rhsInfo, Info edgeInfo) { return new DefaultInfo(treeInfo.getId(), InfoServicesUtils.combineNodeInfo(treeInfo, rhsInfo), edgeInfo.getEdgeInfo()); }
DefaultSyntacticInfo syntacticInfo = new DefaultSyntacticInfo(pos); DefaultNodeInfo defaultNodeInfo = new DefaultNodeInfo(word, lemma, this.serial, null, syntacticInfo); DefaultInfo info = new DefaultInfo(token.get("parseid"), defaultNodeInfo, defaultEdgeInfo);
protected BasicNode getBasicNodeFromConll(String[] toks) throws Exception { /* * items[0]: ID * items[1]: word form * items[2]: lemma * items[4]: POS * items[6]: head ID * items[7]: dependency label */ if (toks.length < 8) throw new Exception("Number of columns for each word should be at least 8: " + toks); String lemma = toks[2]; if (lemma.equals(UNKNOWN)) lemma = toks[1]; NodeInfo nodeInfo = new DefaultNodeInfo(toks[1],lemma,Integer.parseInt(toks[0]),null, new DefaultSyntacticInfo(pos.createNewPartOfSpeech(toks[4]))); EdgeInfo edgeInfo = new DefaultEdgeInfo(new DependencyRelation(toks[7],null)); Info info = new DefaultInfo(null,nodeInfo,edgeInfo); return new BasicNode(info); }
if (parser.equals(PARSER.MINIPAR)) { NodeInfo nodeInfo = fromStringNonVariable(info); ret = new BasicNode(new DefaultInfo(DEFAULT_ID, nodeInfo, relationToParent)); ret = new BasicNode(new DefaultInfo(DEFAULT_ID, verbNodeInfo, relationToParent)); BasicNode child = new BasicNode(new DefaultInfo(DEFAULT_ID, rpNodeInfo, new DefaultEdgeInfo(new DependencyRelation("prt", null)))); ret.addChild(child); ret = new BasicNode(new DefaultInfo(DEFAULT_ID, parentNodeInfo, relationToParent)); BasicNode child = new BasicNode(new DefaultInfo(DEFAULT_ID, childNodeInfo, new DefaultEdgeInfo(new DependencyRelation("nn", null)))); ret.addChild(child); ret = new BasicNode(new DefaultInfo(DEFAULT_ID, nodeInfo, relationToParent));
private ExtendedNode copy (ExtendedNode subtree, int depth, EdgeInfo edgeInfo) { ExtendedNode ret; if (null==edgeInfo) { ret = nodeConstructor.newNode(subtree.getInfo()); } else { ExtendedInfo originalInfo = subtree.getInfo(); if (null==originalInfo) originalInfo = ExtendedNodeConstructor.EMPTY_EXTENDED_INFO; ret = new ExtendedNode(new ExtendedInfo(new DefaultInfo(originalInfo.getId(), originalInfo.getNodeInfo(), edgeInfo), originalInfo.getAdditionalNodeInformation())); } mapOriginalToGenerated.put(subtree,ret); if ( (subtree.hasChildren()) && (depth>0) ) { for (ExtendedNode child : subtree.getChildren()) { ret.addChild(copy(child,depth-1,null)); } } return ret; }
node = new BasicConstructionNode(new DefaultInfo(counterString,new DefaultNodeInfo(word, lemma, serial, null, new DefaultSyntacticInfo(new PennPartOfSpeech(pos))),edgeInfo));
throw new ParserRunException("empty output"); BasicNode root = new BasicNode(new DefaultInfo("0",new DefaultNodeInfo("ROOT", "ROOT", 0, null, new DefaultSyntacticInfo(new StuttgartTreeTaggerPartOfSpeech("ROOT"))),new DefaultEdgeInfo(new DependencyRelation("ROOT", null)))); mapIdToNode.put(0, root); new BasicNode(new DefaultInfo(serial,new DefaultNodeInfo(lemma, lemma, id, null, new DefaultSyntacticInfo(new StuttgartTreeTaggerPartOfSpeech(pos))),new DefaultEdgeInfo(new DependencyRelation(relation, null)))); mapIdToNode.put(id, node); int parentId = Integer.parseInt(parent);
DefaultInfo rootInfo = new DefaultInfo(ROOT_NODE_ID,new DefaultNodeInfo(null,null,0,null,new DefaultSyntacticInfo(null)),new DefaultEdgeInfo(null)); root = new BasicConstructionNode(rootInfo);
public static BasicNode addArtificialRoot(BasicNode tree) { DefaultInfo rootInfo = new DefaultInfo(AbstractBasicParser.ROOT_NODE_ID,new DefaultNodeInfo(null,null,0,null,new DefaultSyntacticInfo(null)),new DefaultEdgeInfo(null)); BasicNode root = new BasicNode(rootInfo); root.addChild(tree); return root; } }
@Override protected void generateTheTree() throws OperationException { affectedNodes = new LinkedHashSet<ExtendedNode>(); //BidirectionalMap<AbstractNode<Info,?>, EnglishNode> copyMap = AbstractNodeUtils.copyTreeReturnMap(textTree.getTree(), new EnglishNodeConstructor()); BidirectionalMap<ExtendedNode, ExtendedNode> copyMap = AbstractNodeUtils.strictTypeCopyTree(textTree.getTree(), new ExtendedNodeConstructor()); ExtendedNode duplicatedNode = new ExtendedNode(new ExtendedInfo(new DefaultInfo(nodeToMove.getInfo().getId(), nodeToMove.getInfo().getNodeInfo(), this.newEdgeInfo), nodeToMove.getInfo().getAdditionalNodeInformation()) ); ExtendedNode parentInGeneratedTree = copyMap.leftGet(newParent); parentInGeneratedTree.addChild(duplicatedNode); if (nodeToMove.getAntecedent()!=null) { ExtendedNode antecedentInOriginal = nodeToMove.getAntecedent(); ExtendedNode antecedentInGenerated = copyMap.leftGet(antecedentInOriginal); duplicatedNode.setAntecedent(antecedentInGenerated); } affectedNodes.add(duplicatedNode); this.generatedTree = copyMap.leftGet(textTree.getTree()); this.mapOriginalToGenerated = new SimpleValueSetMap<ExtendedNode, ExtendedNode>(); for (ExtendedNode originalNode : copyMap.leftSet()) { mapOriginalToGenerated.put(originalNode,copyMap.leftGet(originalNode)); } mapOriginalToGenerated.put(nodeToMove,duplicatedNode); }
ret.addChild(new BasicNode(new DefaultInfo(DEFAULT_ID, childNodeInfo, childEdgeInfo))); ret.addChild(new BasicNode(new DefaultInfo(DEFAULT_ID, childNodeInfo, childEdgeInfo)));
BasicConstructionNode node = new BasicConstructionNode( new DefaultInfo(nodeID.toString(), nodeInfo, new DefaultEdgeInfo(relation))); nodeID++; return node;
DefaultInfo rootInfo = new DefaultInfo(ROOT_NODE_ID, new DefaultNodeInfo(null, null, 0, null, new DefaultSyntacticInfo(null)), new DefaultEdgeInfo(null)); root = new BasicConstructionNode(rootInfo);