joshua.ui.tree_visualizer.DerivationTreeTransformer.java Source code

Introduction

Here is the source code for joshua.ui.tree_visualizer.DerivationTreeTransformer.java

Source

/* This file is part of the Joshua Machine Translation System.
 *
 * Joshua is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1
 * of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free
 * Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307 USA
 */
package joshua.ui.tree_visualizer;

import org.apache.commons.collections15.Transformer;

import edu.uci.ics.jung.algorithms.layout.TreeLayout;
import edu.uci.ics.jung.graph.DelegateForest;

import java.awt.Dimension;
import java.awt.geom.Point2D;

public class DerivationTreeTransformer implements Transformer<Node, Point2D> {
    private TreeLayout<Node, DerivationTreeEdge> treeLayout;
    private DerivationTree graph;
    private Node root;
    private Node sourceRoot;

    private boolean isAnchored;
    private Point2D anchorPoint;

    private double Y_DIST;
    private double X_DIST;

    public DerivationTreeTransformer(DerivationTree t, Dimension d, boolean isAnchored) {
        this.isAnchored = isAnchored;
        anchorPoint = new Point2D.Double(0, 0);
        graph = t;
        DelegateForest<Node, DerivationTreeEdge> del = new DelegateForest<Node, DerivationTreeEdge>(t);
        del.setRoot(t.getRoot());
        del.setRoot(t.getSourceRoot());
        root = t.getRoot();
        sourceRoot = t.getSourceRoot();
        Y_DIST = d.getHeight() / (2 * (1 + distanceToLeaf(root)));
        int leafCount = 0;
        for (Node n : t.getVertices()) {
            if (t.outDegree(n) == 0)
                leafCount++;
        }
        X_DIST = d.getWidth() / leafCount;

        treeLayout = new TreeLayout<Node, DerivationTreeEdge>(del, (int) Math.round(X_DIST));
    }

    public Point2D transform(Node n) {
        double x, y;
        Point2D t = treeLayout.transform(n);
        if (n.isSource()) {
            x = /*treeLayout.transform(root).getX() +*/ (t.getX() - treeLayout.transform(sourceRoot).getX()
                    + treeLayout.transform(root).getX());
            y = Y_DIST * (distanceToLeaf(n) + 1);
        } else {
            x = t.getX();
            y = Y_DIST * (-1) * distanceToLeaf(n);
        }
        if (isAnchored) {
            x += anchorPoint.getX();
            y += anchorPoint.getY();
        }
        return new Point2D.Double(x, y + Y_DIST * (1 + distanceToLeaf(root)));
    }

    private int distanceToLeaf(Node n) {
        if (graph.getSuccessors(n).isEmpty())
            return 0;
        int result = 0;
        for (Object x : graph.getSuccessors(n)) {
            int tmp = distanceToLeaf((Node) x);
            if (tmp > result)
                result = tmp;
        }
        return 1 + result;
    }

    public Dimension getSize() {
        int height = (int) Math.round(2 * Y_DIST * (1 + distanceToLeaf(root)));
        int width = (int) Math.round(2 * treeLayout.transform(root).getX());
        Dimension ret = new Dimension(width, height);
        return ret;
    }

    public Point2D getAnchorPosition(DerivationViewer.AnchorType type) {
        switch (type) {
        case ANCHOR_ROOT:
            return transform(root);
        case ANCHOR_LEFTMOST_LEAF:
            Node n = root;
            while (graph.getSuccessorCount(n) != 0)
                n = (Node) graph.getSuccessors(n).toArray()[0];
            return transform(n);
        default:
            return new Point2D.Double(0, 0);
        }
    }

    public void setAnchorPoint(DerivationViewer.AnchorType type, Point2D viewerAnchor) {
        Point2D oldAnchor = getAnchorPosition(type);
        double x = viewerAnchor.getX() - oldAnchor.getX();
        double y = viewerAnchor.getY() - oldAnchor.getY();
        anchorPoint = new Point2D.Double(x, y);
    }
}