< prev index next >

modules/graphics/src/main/java/com/sun/javafx/scene/transform/TransformUtils.java

Print this page

        

@@ -1,7 +1,7 @@
 /*
- * Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this

@@ -23,18 +23,11 @@
  * questions.
  */
 
 package com.sun.javafx.scene.transform;
 
-import com.sun.javafx.geom.transform.Affine2D;
-import com.sun.javafx.geom.transform.Affine3D;
-import com.sun.javafx.geom.transform.BaseTransform;
-import javafx.geometry.Point2D;
-import javafx.geometry.Point3D;
-import javafx.scene.transform.NonInvertibleTransformException;
 import javafx.scene.transform.Transform;
-import javafx.scene.transform.Affine;
 
 /**
  * Internal utilities for transformations
  */
 public class TransformUtils {

@@ -46,11 +39,11 @@
      */
     public static Transform immutableTransform(
                 double mxx, double mxy, double mxz, double tx,
                 double myx, double myy, double myz, double ty,
                 double mzx, double mzy, double mzz, double tz) {
-        return new ImmutableTransform(
+        return TransformHelper.createImmutableTransform(
                 mxx, mxy, mxz, tx,
                 myx, myy, myz, ty,
                 mzx, mzy, mzz, tz);
     }
 

@@ -59,11 +52,11 @@
      * from the given transformation.
      * This method is not intended for public use, users should use the Affine
      * class.
      */
     public static Transform immutableTransform(Transform t) {
-        return new ImmutableTransform(
+        return TransformHelper.createImmutableTransform(
                 t.getMxx(), t.getMxy(), t.getMxz(), t.getTx(),
                 t.getMyx(), t.getMyy(), t.getMyz(), t.getTy(),
                 t.getMzx(), t.getMzy(), t.getMzz(), t.getTz());
     }
 

@@ -78,24 +71,16 @@
     public static Transform immutableTransform(Transform reuse,
                 double mxx, double mxy, double mxz, double tx,
                 double myx, double myy, double myz, double ty,
                 double mzx, double mzy, double mzz, double tz) {
 
-        if (reuse == null) {
-            return new ImmutableTransform(
+        return TransformHelper.createImmutableTransform(reuse,
                 mxx, mxy, mxz, tx,
                 myx, myy, myz, ty,
                 mzx, mzy, mzz, tz);
         }
 
-        ((ImmutableTransform) reuse).setToTransform(
-                mxx, mxy, mxz, tx,
-                myx, myy, myz, ty,
-                mzx, mzy, mzz, tz);
-        return reuse;
-    }
-
     /**
      * Creates an immutable transformation filled with current values
      * from the given transformation.
      * If the given instance is not null, it is reused.
      * This method is not intended for public use, users should use the Affine

@@ -103,11 +88,11 @@
      * @throws ClassCastException if the given transform to be reused
      *                            is not instance of ImmutableTransform
      */
     public static Transform immutableTransform(Transform reuse,
                 Transform t) {
-        return immutableTransform((ImmutableTransform) reuse,
+        return TransformHelper.createImmutableTransform(reuse,
                 t.getMxx(), t.getMxy(), t.getMxz(), t.getTx(),
                 t.getMyx(), t.getMyy(), t.getMyz(), t.getTy(),
                 t.getMzx(), t.getMzy(), t.getMzz(), t.getTz());
     }
 

@@ -121,753 +106,9 @@
      *                            is not instance of ImmutableTransform
      */
     public static Transform immutableTransform(Transform reuse,
             Transform left, Transform right) {
 
-        if (reuse == null) {
-            reuse = new ImmutableTransform();
-        }
-
-        ((ImmutableTransform) reuse).setToConcatenation(
-                (ImmutableTransform) left, ((ImmutableTransform) right));
-
-        return reuse;
-    }
-
-    /**
-     * Immutable transformation with performance optimizations based on Affine.
-     *
-     * From user's perspective, this transform is immutable. However, we can
-     * modify it internally. This allows for reusing instances that were
-     * not handed to users. The caller is responsible for not modifying
-     * user-visible instances.
-     *
-     * Note: can't override Transform's package private methods so they cannot
-     * be optimized. Currently not a big deal.
-     */
-    static class ImmutableTransform extends Transform {
-
-        private static final int APPLY_IDENTITY = 0;
-        private static final int APPLY_TRANSLATE = 1;
-        private static final int APPLY_SCALE = 2;
-        private static final int APPLY_SHEAR = 4;
-        private static final int APPLY_NON_3D = 0;
-        private static final int APPLY_3D_COMPLEX = 4;
-        private transient int state2d;
-        private transient int state3d;
-
-        private double xx;
-        private double xy;
-        private double xz;
-        private double yx;
-        private double yy;
-        private double yz;
-        private double zx;
-        private double zy;
-        private double zz;
-        private double xt;
-        private double yt;
-        private double zt;
-
-        public ImmutableTransform() {
-            xx = yy = zz = 1.0;
-        }
-
-        public ImmutableTransform(Transform transform) {
-            this(transform.getMxx(), transform.getMxy(), transform.getMxz(),
-                                                                 transform.getTx(),
-                 transform.getMyx(), transform.getMyy(), transform.getMyz(),
-                                                                 transform.getTy(),
-                 transform.getMzx(), transform.getMzy(), transform.getMzz(),
-                                                                 transform.getTz());
-        }
-
-        public ImmutableTransform(double mxx, double mxy, double mxz, double tx,
-                      double myx, double myy, double myz, double ty,
-                      double mzx, double mzy, double mzz, double tz) {
-            xx = mxx;
-            xy = mxy;
-            xz = mxz;
-            xt = tx;
-
-            yx = myx;
-            yy = myy;
-            yz = myz;
-            yt = ty;
-
-            zx = mzx;
-            zy = mzy;
-            zz = mzz;
-            zt = tz;
-
-            updateState();
-        }
-
-        // Beware: this is modifying immutable transform!
-        // It is private and it is there just for the purpose of reusing
-        // instances not given to users
-        private void setToTransform(double mxx, double mxy, double mxz, double tx,
-                                    double myx, double myy, double myz, double ty,
-                                    double mzx, double mzy, double mzz, double tz)
-        {
-            xx = mxx;
-            xy = mxy;
-            xz = mxz;
-            xt = tx;
-            yx = myx;
-            yy = myy;
-            yz = myz;
-            yt = ty;
-            zx = mzx;
-            zy = mzy;
-            zz = mzz;
-            zt = tz;
-            updateState();
-        }
-
-        // Beware: this is modifying immutable transform!
-        // It is private and it is there just for the purpose of reusing
-        // instances not given to users
-        private void setToConcatenation(ImmutableTransform left, ImmutableTransform right) {
-            if (left.state3d == APPLY_NON_3D && right.state3d == APPLY_NON_3D) {
-                xx = left.xx * right.xx + left.xy * right.yx;
-                xy = left.xx * right.xy + left.xy * right.yy;
-                xt = left.xx * right.xt + left.xy * right.yt + left.xt;
-                yx = left.yx * right.xx + left.yy * right.yx;
-                yy = left.yx * right.xy + left.yy * right.yy;
-                yt = left.yx * right.xt + left.yy * right.yt + left.yt;
-                if (state3d != APPLY_NON_3D) {
-                    xz = yz = zx = zy = zt = 0.0;
-                    zz = 1.0;
-                    state3d = APPLY_NON_3D;
-                }
-                updateState2D();
-            } else {
-                xx = left.xx * right.xx + left.xy * right.yx + left.xz * right.zx;
-                xy = left.xx * right.xy + left.xy * right.yy + left.xz * right.zy;
-                xz = left.xx * right.xz + left.xy * right.yz + left.xz * right.zz;
-                xt = left.xx * right.xt + left.xy * right.yt + left.xz * right.zt + left.xt;
-                yx = left.yx * right.xx + left.yy * right.yx + left.yz * right.zx;
-                yy = left.yx * right.xy + left.yy * right.yy + left.yz * right.zy;
-                yz = left.yx * right.xz + left.yy * right.yz + left.yz * right.zz;
-                yt = left.yx * right.xt + left.yy * right.yt + left.yz * right.zt + left.yt;
-                zx = left.zx * right.xx + left.zy * right.yx + left.zz * right.zx;
-                zy = left.zx * right.xy + left.zy * right.yy + left.zz * right.zy;
-                zz = left.zx * right.xz + left.zy * right.yz + left.zz * right.zz;
-                zt = left.zx * right.xt + left.zy * right.yt + left.zz * right.zt + left.zt;
-                updateState();
-            }
-            // could be further optimized using the states, but that would
-            // require a lot of code (see Affine and all its append* methods)
-        }
-
-        @Override
-        public double getMxx() {
-            return xx;
-        }
-
-        @Override
-        public double getMxy() {
-            return xy;
-        }
-
-        @Override
-        public double getMxz() {
-            return xz;
-        }
-
-        @Override
-        public double getTx() {
-            return xt;
+        return TransformHelper.createImmutableTransform(reuse, left, right);
         }
 
-        @Override
-        public double getMyx() {
-            return yx;
-        }
-
-        @Override
-        public double getMyy() {
-            return yy;
-        }
-
-        @Override
-        public double getMyz() {
-            return yz;
-        }
-
-        @Override
-        public double getTy() {
-            return yt;
-        }
-
-        @Override
-        public double getMzx() {
-            return zx;
-        }
-
-        @Override
-        public double getMzy() {
-            return zy;
-        }
-
-        @Override
-        public double getMzz() {
-            return zz;
-        }
-
-        @Override
-        public double getTz() {
-            return zt;
-        }
-
-    /* *************************************************************************
-     *                                                                         *
-     *                           State getters                                 *
-     *                                                                         *
-     **************************************************************************/
-
-        @Override
-        public double determinant() {
-            switch(state3d) {
-                default:
-                    stateError();
-                    // cannot reach
-                case APPLY_NON_3D:
-                    switch (state2d) {
-                        default:
-                            stateError();
-                            // cannot reach
-                        case APPLY_SHEAR | APPLY_SCALE | APPLY_TRANSLATE:
-                        case APPLY_SHEAR | APPLY_SCALE:
-                            return xx * yy - xy * yx;
-                        case APPLY_SHEAR | APPLY_TRANSLATE:
-                        case APPLY_SHEAR:
-                            return -(xy* yx);
-                        case APPLY_SCALE | APPLY_TRANSLATE:
-                        case APPLY_SCALE:
-                            return xx * yy;
-                        case APPLY_TRANSLATE:
-                        case APPLY_IDENTITY:
-                            return 1.0;
-                    }
-                case APPLY_TRANSLATE:
-                    return 1.0;
-                case APPLY_SCALE:
-                case APPLY_SCALE | APPLY_TRANSLATE:
-                    return xx * yy * zz;
-                case APPLY_3D_COMPLEX:
-                    return (xx* (yy * zz - zy * yz) +
-                            xy* (yz * zx - zz * yx) +
-                            xz* (yx * zy - zx * yy));
-            }
-        }
-
-        @Override
-        public Transform createConcatenation(Transform transform) {
-            javafx.scene.transform.Affine a = new Affine(this);
-            a.append(transform);
-            return a;
-        }
-
-        @Override
-        public javafx.scene.transform.Affine createInverse() throws NonInvertibleTransformException {
-            javafx.scene.transform.Affine t = new Affine(this);
-            t.invert();
-            return t;
-        }
-
-        @Override
-        public Transform clone() {
-            return new ImmutableTransform(this);
-        }
-
-        /* *************************************************************************
-         *                                                                         *
-         *                     Transform, Inverse Transform                        *
-         *                                                                         *
-         **************************************************************************/
-
-        @Override
-        public Point2D transform(double x, double y) {
-            ensureCanTransform2DPoint();
-
-            switch (state2d) {
-                default:
-                    stateError();
-                    // cannot reach
-                case APPLY_SHEAR | APPLY_SCALE | APPLY_TRANSLATE:
-                    return new Point2D(
-                        xx * x + xy * y + xt,
-                        yx * x + yy * y + yt);
-                case APPLY_SHEAR | APPLY_SCALE:
-                    return new Point2D(
-                        xx * x + xy * y,
-                        yx * x + yy * y);
-                case APPLY_SHEAR | APPLY_TRANSLATE:
-                    return new Point2D(
-                            xy * y + xt,
-                            yx * x + yt);
-                case APPLY_SHEAR:
-                    return new Point2D(xy * y, yx * x);
-                case APPLY_SCALE | APPLY_TRANSLATE:
-                    return new Point2D(
-                            xx * x + xt,
-                            yy * y + yt);
-                case APPLY_SCALE:
-                    return new Point2D(xx * x, yy * y);
-                case APPLY_TRANSLATE:
-                    return new Point2D(x + xt, y + yt);
-                case APPLY_IDENTITY:
-                    return new Point2D(x, y);
-            }
-        }
-
-        @Override
-        public Point3D transform(double x, double y, double z) {
-            switch (state3d) {
-                default:
-                    stateError();
-                    // cannot reach
-                case APPLY_NON_3D:
-                    switch (state2d) {
-                        default:
-                            stateError();
-                            // cannot reach
-                        case APPLY_SHEAR | APPLY_SCALE | APPLY_TRANSLATE:
-                            return new Point3D(
-                                xx * x + xy * y + xt,
-                                yx * x + yy * y + yt, z);
-                        case APPLY_SHEAR | APPLY_SCALE:
-                            return new Point3D(
-                                xx * x + xy * y,
-                                yx * x + yy * y, z);
-                        case APPLY_SHEAR | APPLY_TRANSLATE:
-                            return new Point3D(
-                                    xy * y + xt, yx * x + yt,
-                                    z);
-                        case APPLY_SHEAR:
-                            return new Point3D(xy * y, yx * x, z);
-                        case APPLY_SCALE | APPLY_TRANSLATE:
-                            return new Point3D(
-                                    xx * x + xt, yy * y + yt,
-                                    z);
-                        case APPLY_SCALE:
-                            return new Point3D(xx * x, yy * y, z);
-                        case APPLY_TRANSLATE:
-                            return new Point3D(x + xt, y + yt, z);
-                        case APPLY_IDENTITY:
-                            return new Point3D(x, y, z);
-                    }
-                case APPLY_TRANSLATE:
-                    return new Point3D(x + xt, y + yt, z + zt);
-                case APPLY_SCALE:
-                    return new Point3D(xx * x, yy * y, zz * z);
-                case APPLY_SCALE | APPLY_TRANSLATE:
-                    return new Point3D(
-                            xx * x + xt,
-                            yy * y + yt,
-                            zz * z + zt);
-                case APPLY_3D_COMPLEX:
-                    return new Point3D(
-                        xx * x + xy * y + xz * z + xt,
-                        yx * x + yy * y + yz * z + yt,
-                        zx * x + zy * y + zz * z + zt);
-            }
-        }
-
-        @Override
-        public Point2D deltaTransform(double x, double y) {
-            ensureCanTransform2DPoint();
-
-            switch (state2d) {
-                default:
-                    stateError();
-                    // cannot reach
-                case APPLY_SHEAR | APPLY_SCALE | APPLY_TRANSLATE:
-                case APPLY_SHEAR | APPLY_SCALE:
-                    return new Point2D(
-                        xx * x + xy * y,
-                        yx * x + yy * y);
-                case APPLY_SHEAR | APPLY_TRANSLATE:
-                case APPLY_SHEAR:
-                    return new Point2D(xy * y, yx * x);
-                case APPLY_SCALE | APPLY_TRANSLATE:
-                case APPLY_SCALE:
-                    return new Point2D(xx * x, yy * y);
-                case APPLY_TRANSLATE:
-                case APPLY_IDENTITY:
-                    return new Point2D(x, y);
-            }
-        }
-
-        @Override
-        public Point3D deltaTransform(double x, double y, double z) {
-            switch (state3d) {
-                default:
-                    stateError();
-                    // cannot reach
-                case APPLY_NON_3D:
-                    switch (state2d) {
-                        default:
-                            stateError();
-                            // cannot reach
-                        case APPLY_SHEAR | APPLY_SCALE | APPLY_TRANSLATE:
-                        case APPLY_SHEAR | APPLY_SCALE:
-                            return new Point3D(
-                                xx * x + xy * y,
-                                yx * x + yy * y, z);
-                        case APPLY_SHEAR | APPLY_TRANSLATE:
-                        case APPLY_SHEAR:
-                            return new Point3D(xy * y, yx * x, z);
-                        case APPLY_SCALE | APPLY_TRANSLATE:
-                        case APPLY_SCALE:
-                            return new Point3D(xx * x, yy * y, z);
-                        case APPLY_TRANSLATE:
-                        case APPLY_IDENTITY:
-                            return new Point3D(x, y, z);
-                    }
-                case APPLY_TRANSLATE:
-                    return new Point3D(x, y, z);
-                case APPLY_SCALE:
-                case APPLY_SCALE | APPLY_TRANSLATE:
-                    return new Point3D(xx * x, yy * y, zz * z);
-                case APPLY_3D_COMPLEX:
-                    return new Point3D(
-                        xx * x + xy * y + xz * z,
-                        yx * x + yy * y + yz * z,
-                        zx * x + zy * y + zz * z);
-            }
-        }
-
-        @Override
-        public Point2D inverseTransform(double x, double y)
-                throws NonInvertibleTransformException {
-            ensureCanTransform2DPoint();
-
-            switch (state2d) {
-                default:
-                    return super.inverseTransform(x, y);
-                case APPLY_SHEAR | APPLY_TRANSLATE:
-                    if (xy == 0.0 || yx == 0.0) {
-                        throw new NonInvertibleTransformException("Determinant is 0");
-                    }
-                    return new Point2D(
-                            (1.0 / yx) * y - yt / yx,
-                            (1.0 / xy) * x - xt / xy);
-                case APPLY_SHEAR:
-                    if (xy == 0.0 || yx == 0.0) {
-                        throw new NonInvertibleTransformException("Determinant is 0");
-                    }
-                    return new Point2D((1.0 / yx) * y, (1.0 / xy) * x);
-                case APPLY_SCALE | APPLY_TRANSLATE:
-                    if (xx == 0.0 || yy == 0.0) {
-                        throw new NonInvertibleTransformException("Determinant is 0");
-                    }
-                    return new Point2D(
-                            (1.0 / xx) * x - xt / xx,
-                            (1.0 / yy) * y - yt / yy);
-                case APPLY_SCALE:
-                    if (xx == 0.0 || yy == 0.0) {
-                        throw new NonInvertibleTransformException("Determinant is 0");
-                    }
-                    return new Point2D((1.0 / xx) * x, (1.0 / yy) * y);
-                case APPLY_TRANSLATE:
-                    return new Point2D(x - xt, y - yt);
-                case APPLY_IDENTITY:
-                    return new Point2D(x, y);
-            }
-        }
-
-        @Override
-        public Point3D inverseTransform(double x, double y, double z)
-                throws NonInvertibleTransformException {
-            switch(state3d) {
-                default:
-                    stateError();
-                    // cannot reach
-                case APPLY_NON_3D:
-                    switch (state2d) {
-                        default:
-                            return super.inverseTransform(x, y, z);
-                        case APPLY_SHEAR | APPLY_TRANSLATE:
-                            if (xy == 0.0 || yx == 0.0) {
-                                throw new NonInvertibleTransformException(
-                                        "Determinant is 0");
-                            }
-                            return new Point3D(
-                                    (1.0 / yx) * y - yt / yx,
-                                    (1.0 / xy) * x - xt / xy, z);
-                        case APPLY_SHEAR:
-                            if (xy == 0.0 || yx == 0.0) {
-                                throw new NonInvertibleTransformException(
-                                        "Determinant is 0");
-                            }
-                            return new Point3D(
-                                    (1.0 / yx) * y,
-                                    (1.0 / xy) * x, z);
-                        case APPLY_SCALE | APPLY_TRANSLATE:
-                            if (xx == 0.0 || yy == 0.0) {
-                                throw new NonInvertibleTransformException(
-                                        "Determinant is 0");
-                            }
-                            return new Point3D(
-                                    (1.0 / xx) * x - xt / xx,
-                                    (1.0 / yy) * y - yt / yy, z);
-                        case APPLY_SCALE:
-                            if (xx == 0.0 || yy == 0.0) {
-                                throw new NonInvertibleTransformException(
-                                        "Determinant is 0");
-                            }
-                            return new Point3D((1.0 / xx) * x, (1.0 / yy) * y, z);
-                        case APPLY_TRANSLATE:
-                            return new Point3D(x - xt, y - yt, z);
-                        case APPLY_IDENTITY:
-                            return new Point3D(x, y, z);
-                    }
-                case APPLY_TRANSLATE:
-                    return new Point3D(x - xt, y - yt, z - zt);
-                case APPLY_SCALE:
-                    if (xx == 0.0 || yy == 0.0 || zz == 0.0) {
-                        throw new NonInvertibleTransformException("Determinant is 0");
-                    }
-                    return new Point3D(
-                            (1.0 / xx) * x,
-                            (1.0 / yy) * y,
-                            (1.0 / zz) * z);
-                case APPLY_SCALE | APPLY_TRANSLATE:
-                    if (xx == 0.0 || yy == 0.0 || zz == 0.0) {
-                        throw new NonInvertibleTransformException("Determinant is 0");
-                    }
-                    return new Point3D(
-                            (1.0 / xx) * x - xt / xx,
-                            (1.0 / yy) * y - yt / yy,
-                            (1.0 / zz) * z - zt / zz);
-                case APPLY_3D_COMPLEX:
-                    return super.inverseTransform(x, y, z);
-            }
-        }
-
-        @Override
-        public Point2D inverseDeltaTransform(double x, double y)
-                throws NonInvertibleTransformException {
-            ensureCanTransform2DPoint();
-
-            switch (state2d) {
-                default:
-                    return super.inverseDeltaTransform(x, y);
-                case APPLY_SHEAR | APPLY_TRANSLATE:
-                case APPLY_SHEAR:
-                    if (xy == 0.0 || yx == 0.0) {
-                        throw new NonInvertibleTransformException("Determinant is 0");
-                    }
-                    return new Point2D((1.0 / yx) * y, (1.0 / xy) * x);
-                case APPLY_SCALE | APPLY_TRANSLATE:
-                case APPLY_SCALE:
-                    if (xx == 0.0 || yy == 0.0) {
-                        throw new NonInvertibleTransformException("Determinant is 0");
-                    }
-                    return new Point2D((1.0 / xx) * x, (1.0 / yy) * y);
-                case APPLY_TRANSLATE:
-                case APPLY_IDENTITY:
-                    return new Point2D(x, y);
-            }
-        }
-
-        @Override
-        public Point3D inverseDeltaTransform(double x, double y, double z)
-                throws NonInvertibleTransformException {
-            switch(state3d) {
-                default:
-                    stateError();
-                    // cannot reach
-                case APPLY_NON_3D:
-                    switch (state2d) {
-                        default:
-                            return super.inverseDeltaTransform(x, y, z);
-                        case APPLY_SHEAR | APPLY_TRANSLATE:
-                        case APPLY_SHEAR:
-                            if (xy == 0.0 || yx == 0.0) {
-                                throw new NonInvertibleTransformException(
-                                        "Determinant is 0");
-                            }
-                            return new Point3D(
-                                    (1.0 / yx) * y,
-                                    (1.0 / xy) * x, z);
-                        case APPLY_SCALE | APPLY_TRANSLATE:
-                        case APPLY_SCALE:
-                            if (xx == 0.0 || yy == 0.0) {
-                                throw new NonInvertibleTransformException(
-                                        "Determinant is 0");
-                            }
-                            return new Point3D(
-                                    (1.0 / xx) * x,
-                                    (1.0 / yy) * y, z);
-                        case APPLY_TRANSLATE:
-                        case APPLY_IDENTITY:
-                            return new Point3D(x, y, z);
-                    }
-
-                case APPLY_TRANSLATE:
-                    return new Point3D(x, y, z);
-                case APPLY_SCALE | APPLY_TRANSLATE:
-                case APPLY_SCALE:
-                    if (xx == 0.0 || yy == 0.0 || zz == 0.0) {
-                        throw new NonInvertibleTransformException("Determinant is 0");
-                    }
-                    return new Point3D(
-                            (1.0 / xx) * x,
-                            (1.0 / yy) * y,
-                            (1.0 / zz) * z);
-                case APPLY_3D_COMPLEX:
-                    return super.inverseDeltaTransform(x, y, z);
-            }
-        }
-
-        /* *************************************************************************
-         *                                                                         *
-         *                               Other API                                 *
-         *                                                                         *
-         **************************************************************************/
-
-        @Override
-        public String toString() {
-           final StringBuilder sb = new StringBuilder("Transform [\n");
-
-            sb.append("\t").append(xx);
-            sb.append(", ").append(xy);
-            sb.append(", ").append(xz);
-            sb.append(", ").append(xt);
-            sb.append('\n');
-            sb.append("\t").append(yx);
-            sb.append(", ").append(yy);
-            sb.append(", ").append(yz);
-            sb.append(", ").append(yt);
-            sb.append('\n');
-            sb.append("\t").append(zx);
-            sb.append(", ").append(zy);
-            sb.append(", ").append(zz);
-            sb.append(", ").append(zt);
-
-            return sb.append("\n]").toString();
-        }
-
-        /* *************************************************************************
-         *                                                                         *
-         *                    Internal implementation stuff                        *
-         *                                                                         *
-         **************************************************************************/
-
-        private void updateState() {
-            updateState2D();
-
-            state3d = APPLY_NON_3D;
-
-            if (xz != 0.0 ||
-                yz != 0.0 ||
-                zx != 0.0 ||
-                zy != 0.0)
-            {
-                state3d = APPLY_3D_COMPLEX;
-            } else {
-                if ((state2d & APPLY_SHEAR) == 0) {
-                    if (zt != 0.0) {
-                        state3d |= APPLY_TRANSLATE;
-                    }
-                    if (zz != 1.0) {
-                        state3d |= APPLY_SCALE;
-                    }
-                    if (state3d != APPLY_NON_3D) {
-                        state3d |= (state2d & (APPLY_SCALE | APPLY_TRANSLATE));
-                    }
-                } else {
-                    if (zz != 1.0 || zt != 0.0) {
-                        state3d = APPLY_3D_COMPLEX;
-                    }
-                }
-            }
-        }
-
-        private void updateState2D() {
-            if (xy == 0.0 && yx == 0.0) {
-                if (xx == 1.0 && yy == 1.0) {
-                    if (xt == 0.0 && yt == 0.0) {
-                        state2d = APPLY_IDENTITY;
-                    } else {
-                        state2d = APPLY_TRANSLATE;
-                    }
-                } else {
-                    if (xt == 0.0 && yt == 0.0) {
-                        state2d = APPLY_SCALE;
-                    } else {
-                        state2d = (APPLY_SCALE | APPLY_TRANSLATE);
-                    }
-                }
-            } else {
-                if (xx == 0.0 && yy == 0.0) {
-                    if (xt == 0.0 && yt == 0.0) {
-                        state2d = APPLY_SHEAR;
-                    } else {
-                        state2d = (APPLY_SHEAR | APPLY_TRANSLATE);
-                    }
-                } else {
-                    if (xt == 0.0 && yt == 0.0) {
-                        state2d = (APPLY_SHEAR | APPLY_SCALE);
-                    } else {
-                        state2d = (APPLY_SHEAR | APPLY_SCALE | APPLY_TRANSLATE);
-                    }
-                }
-            }
-        }
-
-        void ensureCanTransform2DPoint() throws IllegalStateException {
-            if (state3d != APPLY_NON_3D) {
-                throw new IllegalStateException("Cannot transform 2D point "
-                        + "with a 3D transform");
-            }
-        }
-
-        private static void stateError() {
-            throw new InternalError("missing case in a switch");
-        }
-
-        /**
-         * @treatAsPrivate implementation detail
-         * @deprecated This is an internal API that is not intended for use and will be removed in the next version
-         */
-        @Deprecated
-        @Override
-        public void impl_apply(final Affine3D trans) {
-            trans.concatenate(xx, xy, xz, xt,
-                              yx, yy, yz, yt,
-                              zx, zy, zz, zt);
-        }
-
-        /**
-         * @treatAsPrivate implementation detail
-         * @deprecated This is an internal API that is not intended for use and will be removed in the next version
-         */
-        @Deprecated
-        @Override
-        public BaseTransform impl_derive(final BaseTransform trans) {
-            return trans.deriveWithConcatenation(xx, xy, xz, xt,
-                                                 yx, yy, yz, yt,
-                                                 zx, zy, zz, zt);
-        }
-
-        /**
-         * Used only by tests to check the 2d matrix state
-         */
-        int getState2d() {
-            return state2d;
-        }
-
-        /**
-         * Used only by tests to check the 3d matrix state
-         */
-        int getState3d() {
-            return state3d;
-        }
-
-    }
 }
-
< prev index next >