private Tree<String> makeTree(
List<List<Map<Object, Triplet<Integer, Object, Object>>>> backs,
int begin,
int end,
Object A) {
Triplet<Integer, Object, Object> backptr = backs.get(begin).get(end).get(A);
String tag = getParent(A);
// System.out.println("makeTree: begin=" + begin + ",end=" + end + ",A=" + A + " : " +
// "backptr=" + backptr);
List<Tree<String>> children = new ArrayList<Tree<String>>();
if (backptr == null) {
// No back pointer. Terminal
Tree<String> child = new Tree<String>(((UnaryRule) A).getChild());
children.add(child);
} else if (backptr.getFirst() < 0) {
// Single back pointer. Unary rule
Object B = backptr.getSecond();
Tree<String> child = makeTree(backs, begin, end, B);
children.add(child);
} else {
// Two back pointers. Binary rule
int split = backptr.getFirst();
Object B = backptr.getSecond();
Object C = backptr.getThird();
Tree<String> childB = makeTree(backs, begin, split, B);
Tree<String> childC = makeTree(backs, split, end, C);
children.add(childB);
children.add(childC);
}
return new Tree<String>(tag, children);
}
public Tree<String> getParseTreeOld(
List<String> sentence,
HashMap<String, Triplet<Integer, String, String>> backHash,
int begin,
int end,
String parent) {
// Start from the root and keep going down till you reach the leafs.
// System.out.println("In recursion!!");
if (begin == end - 1) {
if ((begin + " " + end).equals("0 1")) {
// System.out.println("CounterMap");
// System.out.println(parseScores.getCounter(begin+" "+end).toString());
// backHash.get(begin+ " " + end+ " "+parent);
}
// String parent = parseScores.getCounter(begin+" "+end).argMax();
// System.out.println("Terminal cond :"+begin+ " "+ end+ " "+parent);
Triplet<Integer, String, String> triplet = backHash.get(begin + " " + end + " " + parent);
int split = -1;
if (triplet != null) {
split = triplet.getFirst();
}
if ((begin + " " + end).equals("0 1")) {
// System.out.println("CounterMap");
// System.out.println(parseScores.getCounter(begin+" "+end).toString());
// System.out.println(backHash.get(begin+ " " + end+ " "+parent).toString());
}
Tree<String> topTree = new Tree<String>(parent);
Tree<String> tree = topTree;
while (triplet != null && split == -1) {
Tree<String> singleTree = new Tree<String>(triplet.getSecond());
tree.setChildren(Collections.singletonList(singleTree));
triplet = backHash.get(begin + " " + end + " " + triplet.getSecond());
if (triplet != null) {
split = triplet.getFirst();
}
tree = tree.getChildren().get(0);
}
// return new Tree<String>(tree.getLabel(), ));
tree.setChildren(Collections.singletonList(new Tree<String>(sentence.get(begin))));
return topTree;
}
/*if((begin +" " + end).equals("1 5")){
System.out.println("CounterMap");
System.out.println(parseScores.getCounter(begin+" "+end).toString());
//backHash.get(begin+ " " + end+ " "+parent);
}*/
// String parent = parseScores.getCounter(begin+" "+end).argMax();
// System.out.println(parent);
Triplet<Integer, String, String> triplet = backHash.get(begin + " " + end + " " + parent);
// System.out.println(triplet.getSecond() + " " + triplet.getFirst());
if ((begin + " " + end).equals("0 6")) {
// System.out.println("CounterMap");
// System.out.println(parent);
// System.out.println(backHash.get(begin+ " " + end+ " "+parent).toString());
}
if (triplet == null) {
System.out.println(begin + " " + end + " " + parent);
}
int split = triplet.getFirst();
Tree<String> topTree = new Tree<String>(parent);
Tree<String> tree = topTree;
// System.out.println("parent : " +parent);
while (split == -1) {
// System.out.println(tree.toString());
Tree<String> singleTree = new Tree<String>(triplet.getSecond());
// System.out.println(triplet.getSecond());
tree.setChildren(Collections.singletonList(singleTree));
// System.out.println(tree.toString());
// System.out.println("XXXXXXXXXXXXXXXXXXXXXXXXXXXxx");
// System.out.println(triplet.getSecond());
triplet = backHash.get(begin + " " + end + " " + triplet.getSecond());
if (triplet != null) {
split = triplet.getFirst();
}
tree = tree.getChildren().get(0);
}
// System.out.println(tree.toString());
Tree<String> leftTree =
getParseTreeOld(sentence, backHash, begin, split, triplet.getSecond());
Tree<String> rightTree = getParseTreeOld(sentence, backHash, split, end, triplet.getThird());
// System.out.println("leftTree: "+ leftTree.toString());
// System.out.println("rightTree :" +rightTree.toString());
// System.out.println("topTree :"+topTree.toString());
List<Tree<String>> children = new ArrayList<Tree<String>>();
children.add(leftTree);
children.add(rightTree);
tree.setChildren(children);
return topTree;
}
public Tree<String> getParseTree(
List<String> sentence,
HashMap<Triplet<Integer, Integer, String>, Triplet<Integer, String, String>> backHash,
int begin,
int end,
String parent) {
// Start from the root and keep going down till you reach the leafs.
if (begin == end - 1) {
Triplet<Integer, String, String> triplet =
backHash.get(new Triplet<Integer, Integer, String>(begin, end, parent));
int split = -1;
if (triplet != null) {
split = triplet.getFirst();
}
Tree<String> topTree = new Tree<String>(parent);
Tree<String> tree = topTree;
while (triplet != null && split == -1) {
Tree<String> singleTree = new Tree<String>(triplet.getSecond());
tree.setChildren(Collections.singletonList(singleTree));
triplet =
backHash.get(new Triplet<Integer, Integer, String>(begin, end, triplet.getSecond()));
if (triplet != null) {
split = triplet.getFirst();
}
tree = tree.getChildren().get(0);
}
tree.setChildren(Collections.singletonList(new Tree<String>(sentence.get(begin))));
return topTree;
}
Triplet<Integer, String, String> triplet =
backHash.get(new Triplet<Integer, Integer, String>(begin, end, parent));
if (triplet == null) {
System.out.println(begin + " " + end + " " + parent);
}
int split = triplet.getFirst();
Tree<String> topTree = new Tree<String>(parent);
Tree<String> tree = topTree;
while (split == -1) {
Tree<String> singleTree = new Tree<String>(triplet.getSecond());
tree.setChildren(Collections.singletonList(singleTree));
triplet =
backHash.get(new Triplet<Integer, Integer, String>(begin, end, triplet.getSecond()));
if (triplet != null) {
split = triplet.getFirst();
}
tree = tree.getChildren().get(0);
}
Tree<String> leftTree = getParseTree(sentence, backHash, begin, split, triplet.getSecond());
Tree<String> rightTree = getParseTree(sentence, backHash, split, end, triplet.getThird());
List<Tree<String>> children = new ArrayList<Tree<String>>();
children.add(leftTree);
children.add(rightTree);
tree.setChildren(children);
return topTree;
}
