com.levigo.util.base
Class AffineTransforms

java.lang.Object
  com.levigo.util.base.AffineTransforms

public class AffineTransforms
extends Object

A bunch of static utility methods useful in conjunction with AffineTransforms.

Method Summary

static boolean	containsTranslation(AffineTransform t)
static Rectangle	createTransformedBounds(AffineTransform tx, float x, float y, float w, float h) A short-cut method for AffineTransforms.createTransformedBounds(new Rectangle2D.Float(x,y,w,h)).
static Rectangle	createTransformedBounds(AffineTransform tx, Shape s) A short-cut method for AffineTransform.createTransformedShape(Shape).getBounds().
static Rectangle2D	createTransformedBounds2D(AffineTransform tx, float x, float y, float w, float h) A short-cut method for AffineTransforms.createTransformedBounds2D(new Rectangle2D.Float(x,y,w,h)).
static Rectangle2D	createTransformedBounds2D(AffineTransform tx, Shape s) A short-cut method for AffineTransform.createTransformedShape(Shape).getBounds2D().
static Shape	createTransformedShape(AffineTransform tx, Shape s) A replacement for AffineTransform.createTransformedShape(Shape) which contains optimizations for frequent cases like the transformation of Rectangle2Ds with only quadrant rotations etc.
static AffineTransform	getHorizontalFlip(double height) Creates an AffineTransform which performs a horizontal flipping with the following operations: Translate by the given height Horizontal flipping Typically, this can be used to switch from Cartesian to Screen coordinates or vice versa.
static AffineTransform	getNonTranslatingTransform(AffineTransform t) Return the non-translating part of the given transform.
static double	getPointRotation(AffineTransform tx, Point2D p) Determines the rotation component of the given transformation with respect to the X-axis, i.e.
static double	getUnitRotation(AffineTransform tx) Determines the rotation component of the given transformation with respect to the unit point (1,1) relative to the origin.
static double	getXAxisRotation(AffineTransform tx) Determines the rotation component of the given transformation with respect to the X-axis, i.e.
static double	getYAxisRotation(AffineTransform tx) Determines the rotation component of the given transformation with respect to the Y-axis, i.e.
static AffineTransform	immutableTransform(AffineTransform tx) Create an immutable incarnation of the given transform.
static boolean	isInvertible(AffineTransform affineTransform) Determine whether or not a given transformation is invertible.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

getXAxisRotation

public static double getXAxisRotation(AffineTransform tx)

Determines the rotation component of the given transformation with respect to the X-axis, i.e. the rotation of any point (excluding the origin) on the X-axis with relative to the origin.

Parameters:

tx - the transformation

Returns:

the rotation angle in radians

getYAxisRotation

public static double getYAxisRotation(AffineTransform tx)

Determines the rotation component of the given transformation with respect to the Y-axis, i.e. the rotation of any point (excluding the origin) on the Y-axis with relative to the origin.

Parameters:

tx - the transformation

Returns:

the rotation angle in radians

getUnitRotation

public static double getUnitRotation(AffineTransform tx)

Determines the rotation component of the given transformation with respect to the unit point (1,1) relative to the origin.

Parameters:

tx - the transformation

Returns:

the rotation angle in radians

getPointRotation

public static double getPointRotation(AffineTransform tx,
                                      Point2D p)

Determines the rotation component of the given transformation with respect to the X-axis, i.e. the rotation of any point (excluding the origin) on the X-axis with relative to the origin.

Parameters:

tx - the transformation

p - the point for which the rotation is determined.

Returns:

the rotation angle in radians

getNonTranslatingTransform

public static AffineTransform getNonTranslatingTransform(AffineTransform t)

Return the non-translating part of the given transform.

Parameters:

t -

Returns:

a new AffineTransform excluding the transformation part

containsTranslation

public static boolean containsTranslation(AffineTransform t)

Parameters:

t - the transformation

Returns:

whether t contains a translative component

createTransformedShape

public static Shape createTransformedShape(AffineTransform tx,
                                           Shape s)

A replacement for AffineTransform.createTransformedShape(Shape) which contains optimizations for frequent cases like the transformation of Rectangle2Ds with only quadrant rotations etc.

Parameters:

tx - the transformation to apply

s - the shape to transform

Returns:

the transformation result

createTransformedBounds2D

public static Rectangle2D createTransformedBounds2D(AffineTransform tx,
                                                    Shape s)

A short-cut method for AffineTransform.createTransformedShape(Shape).getBounds2D(). Using the latter idiom leads to the creation of an additional, transient Rectangle2D, even for simple cases. Using this method not only yields the savings of createTransformedShape(AffineTransform, Shape) but also gets rid of the extra Rectangle2D instance. This method will always return a new Rectangle2D instance.

Parameters:

tx - the transformation to apply

s - the shape to transform

Returns:

the resulting bounds

createTransformedBounds

public static Rectangle createTransformedBounds(AffineTransform tx,
                                                Shape s)

A short-cut method for AffineTransform.createTransformedShape(Shape).getBounds(). Using the latter idiom leads to the creation of an additional, transient Rectangle2D, even for simple cases. Using this method not only yields the savings of createTransformedShape(AffineTransform, Shape) but also gets rid of the extra Rectangle2D instance. This method will always return a new Rectangle instance.

Parameters:

tx - the transformation to apply

s - the shape to transform

Returns:

the resulting bounds

createTransformedBounds

public static Rectangle createTransformedBounds(AffineTransform tx,
                                                float x,
                                                float y,
                                                float w,
                                                float h)

A short-cut method for AffineTransforms.createTransformedBounds(new Rectangle2D.Float(x,y,w,h)). This method will always return a new Rectangle instance.

Parameters:

tx - the transformation to apply

Returns:

the resulting bounds

createTransformedBounds2D

public static Rectangle2D createTransformedBounds2D(AffineTransform tx,
                                                    float x,
                                                    float y,
                                                    float w,
                                                    float h)

A short-cut method for AffineTransforms.createTransformedBounds2D(new Rectangle2D.Float(x,y,w,h)). This method will always return a new Rectangle instance.

Parameters:

tx - the transformation to apply

Returns:

the resulting bounds

immutableTransform

public static AffineTransform immutableTransform(AffineTransform tx)

Create an immutable incarnation of the given transform. All accesses to mutators of the returned transform will throw an UnsupportedOperationException. Changes to the source transform made after the call to this method will not be reflected in the returned transform. Please note: the immutable transform returns mutable versions of itself upon calling AffineTransform.clone(). Therefore the following code is perfectly OK: AffineTransform tx = ...; AffineTransform immutableTx = AffineTransforms.immutableTransform(tx); immutableTx.clone().scale(something, something);

Parameters:

tx - the input transform

Returns:

an immutable transform with the same characteristics as the input transform

getHorizontalFlip

public static AffineTransform getHorizontalFlip(double height)

Creates an AffineTransform which performs a horizontal flipping with the following operations:

• Translate by the given height
• Horizontal flipping

Typically, this can be used to switch from Cartesian to Screen coordinates or vice versa.

Parameters:

height - height of the area to be flipped

Returns:

an AffineTransform to perform the flipping

isInvertible

public static boolean isInvertible(AffineTransform affineTransform)

Determine whether or not a given transformation is invertible. Non-invertible transformations will lead to exceptions when calling AffineTransform.createInverse().

Parameters:

affineTransform - the transformation to be considered

Returns:

true if the given transformation is invertible, false otherwise.