Transform.java

package nodebox.graphics;

import java.awt.*;
import java.awt.geom.AffineTransform;
import java.awt.geom.NoninvertibleTransformException;
import java.awt.geom.Point2D;
import java.util.ArrayList;
import java.util.List;

public class Transform implements Cloneable {

    public enum Mode {
        CORNER, CENTER
    }

    private AffineTransform affineTransform;

    public static Transform translated(double tx, double ty) {
        Transform t = new Transform();
        t.translate(tx, ty);
        return t;
    }

    public static Transform translated(Point t) {
        return translated(t.x, t.y);
    }

    public static Transform rotated(double degrees) {
        Transform t = new Transform();
        t.rotate(degrees);
        return t;
    }

    public static Transform rotatedRadians(double radians) {
        Transform t = new Transform();
        t.rotateRadians(radians);
        return t;
    }

    public static Transform scaled(double scale) {
        Transform t = new Transform();
        t.scale(scale);
        return t;
    }

    public static Transform scaled(double sx, double sy) {
        Transform t = new Transform();
        t.scale(sx, sy);
        return t;
    }

    public static Transform scaled(Point s) {
        return scaled(s.x, s.y);
    }

    public static Transform skewed(double skew) {
        Transform t = new Transform();
        t.skew(skew);
        return t;
    }

    public static Transform skewed(double kx, double ky) {
        Transform t = new Transform();
        t.skew(kx, ky);
        return t;
    }

    public Transform() {
        affineTransform = new AffineTransform();
    }

    public Transform(double m00, double m10, double m01, double m11, double m02, double m12) {
        affineTransform = new AffineTransform(m00, m10, m01, m11, m02, m12);
    }

    public Transform(AffineTransform affineTransform) {
        this.affineTransform = affineTransform;
    }

    public Transform(Transform other) {
        this.affineTransform = (AffineTransform) other.affineTransform.clone();
    }

    //// Transform changes ////

    public void translate(Point point) {
        affineTransform.translate(point.x, point.y);
    }

    public void translate(double tx, double ty) {
        affineTransform.translate(tx, ty);
    }

    public void rotate(double degrees) {
        double radians = degrees * Math.PI / 180;
        affineTransform.rotate(radians);
    }

    public void rotateRadians(double radians) {
        affineTransform.rotate(radians);
    }

    public void scale(double scale) {
        affineTransform.scale(scale, scale);
    }

    public void scale(double sx, double sy) {
        affineTransform.scale(sx, sy);
    }

    public void skew(double skew) {
        skew(skew, skew);
    }

    public void skew(double kx, double ky) {
        kx = Math.PI * kx / 180.0;
        ky = Math.PI * ky / 180.0;
        affineTransform.concatenate(new AffineTransform(1, Math.tan(ky), -Math.tan(kx), 1, 0, 0));
    }

    public boolean invert() {
        try {
            affineTransform = affineTransform.createInverse();
            return true;
        } catch (NoninvertibleTransformException e) {
            return false;
        }
    }

    public void append(Transform t) {
        affineTransform.concatenate(t.affineTransform);
    }

    public void prepend(Transform t) {
        affineTransform.preConcatenate(t.affineTransform);
    }

    //// Operations ////

    public Point map(Point p) {
        Point2D.Double p2 = new Point2D.Double();
        affineTransform.transform(p.toPoint2D(), p2);
        return new Point(p2);
    }

    public Rect map(Rect r) {
        // TODO: The size conversion might be incorrect. (using deltaTransform) In that case, make topLeft and bottomRight points.
        Point2D origin = new Point2D.Double(r.getX(), r.getY());
        Point2D size = new Point2D.Double(r.getWidth(), r.getHeight());
        Point2D transformedOrigin = new Point2D.Double();
        Point2D transformedSize = new Point2D.Double();
        affineTransform.transform(origin, transformedOrigin);
        affineTransform.deltaTransform(size, transformedSize);
        return new Rect(transformedOrigin.getX(), transformedOrigin.getY(), transformedSize.getX(), transformedSize.getY());
    }

    public IGeometry map(IGeometry shape) {
        if (shape instanceof Path) {
            return map((Path) shape);
        } else if (shape instanceof Geometry) {
            return map((Geometry) shape);
        } else {
            throw new RuntimeException("Unsupported geometry type " + shape);
        }
    }

    public Path map(Path p) {
        Path newPath = new Path(p, false);
        for (Contour c : p.getContours()) {
            Contour newContour = new Contour(map(c.getPoints()), c.isClosed());
            newPath.add(newContour);
        }
        return newPath;
    }

    public Geometry map(Geometry g) {
        Geometry newGeometry = new Geometry();
        for (Path p : g.getPaths()) {
            Path newPath = map(p);
            newGeometry.add(newPath);
        }
        return newGeometry;
    }

    /**
     * Transform all the given points and return a list of transformed points.
     * Points are immutable, so they can not be transformed in-place.
     *
     * @param points The points to transform.
     * @return The list of transformed points.
     */
    public List<Point> map(List<Point> points) {
        // Prepare the points for the AffineTransform transformation.
        double[] coords = new double[points.size() * 2];
        int i = 0;
        for (Point pt : points) {
            coords[i++] = pt.x;
            coords[i++] = pt.y;
        }
        affineTransform.transform(coords, 0, coords, 0, points.size());

        // Convert the transformed points into a new List.
        List<Point> transformed = new ArrayList<Point>(points.size());
        int pointIndex = 0;
        for (i = 0; i < coords.length; i += 2) {
            transformed.add(new Point(coords[i], coords[i + 1], points.get(pointIndex).type));
            pointIndex++;
        }
        return transformed;
    }

    public Rect convertBoundsToFrame(Rect bounds) {
        AffineTransform t = fullTransform(bounds);
        Point2D transformedOrigin = new Point2D.Double();
        Point2D transformedSize = new Point2D.Double();
        t.transform(new Point2D.Double(bounds.getX(), bounds.getY()), transformedOrigin);
        t.deltaTransform(new Point2D.Double(bounds.getWidth(), bounds.getHeight()), transformedSize);
        return new Rect(transformedOrigin.getX(), transformedOrigin.getY(), transformedSize.getX(), transformedSize.getY());
    }

    private AffineTransform fullTransform(Rect bounds) {
        double cx = bounds.getX() + bounds.getWidth() / 2;
        double cy = bounds.getY() + bounds.getHeight() / 2;
        AffineTransform t = new AffineTransform();
        t.translate(cx, cy);
        t.preConcatenate(affineTransform);
        t.translate(-cx, -cy);
        return t;
    }

    @Override
    protected Transform clone() {
        return new Transform(this);
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Transform)) return false;
        return getAffineTransform().equals(((Transform) obj).getAffineTransform());
    }

    public void apply(Graphics2D g, Rect bounds) {
        AffineTransform t = fullTransform(bounds);
        g.transform(t);
    }

    public AffineTransform getAffineTransform() {
        return affineTransform;
    }
}