Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2015 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.gui.awt.text;

import java.awt.Graphics2D;

import java.awt.font.TextLayout;

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Point2D;

/**

 * <p>A convenience class to easily draw rotated text which is positioned on

 * a specific side of the rotation point (TOP, BOTTOM, LEFT or RIGHT).

 * The text can be anchored by its central point or by the text corner.</p>

 * 

 * <p>The following diagrams illustrate the behaviour of each positioning and

 * anchor point in relation to the rotation point:</p>

 * <pre>

 * top center:         top corner:

 *        o                     o

 *       l                     l

 *      l                     l

 *     e                     e

 *    h                     h

 *      .                   . 

 * 

 * 

 * right center:      right corner:

 *                          o 

 *                         l 

 *        o               l

 *       l               e

 *   .  l              .h 

 *     e

 *    h

 * </pre>

 * 

 * <p>The  class provides 2 separate families of methods:

 * <ul>

 * <li><strong>draw methods</strong>, which rotate the graphics, draw the rotated text and

 * restore the graphics transformation</li>

 * <li><strong>getPosition methods</strong>, which are used to get the position of the

 * rotated text on an already rotated graphics (faster when drawing several

 * rotated texts using the same rotation angle). Note that this family of

 * methods deals with coordinates in 2 different coordinate spaces

 * (the original, non-rotated space and the rotated space). The origin point

 * coordinates has to be referred to the non-rotated space, while the returned

 * position is referred to the rotated space.</li>

 * </ul>

 *

 * Generally speaking the <code>draw</code> family of methods can be considered a simpler, higher level

 * API, while the <code>getPosition</code> family is conceptually more complex but faster for some

 * scenarios.

 * </p>

 * 

 * <p>

 * Example of <strong>draw</strong> method usage:

 * <pre>

 * // draw coordinates axis

 * Graphics2D g = ...

 * Point2D origin1 = new Point2D.Double(100, 200);

 * int lenght = 100;

 * g.drawLine((int)origin1.getX()-length, (int)origin1.getY(), (int)origin1.getX()+length, (int)origin1.getY());

 * g.drawLine((int)origin1.getX(), (int)origin1.getY()-length, (int)origin1.getX(), (int)origin1.getY()+length);

 * // draw the rotated text

 * RotatedTextUtils.draw(origin1, g, "Hello world", angle, RotatedTextUtils.PLACEMENT_BOTTOM, RotatedTextUtils.ANCHOR_CORNER);

 * </pre>

 * </p>

 * 

 * 

 * <p>

 * Example of <strong>getPosition</strong> method usage:

 * <pre>

 * // draw coordinates axis

 * Graphics2D g = ...

 * AffineTransform defaultAt = g.getTransform();

 * Point2D origin1 = new Point2D.Double(100, 200);

 * Point2D origin2 = new Point2D.Double(200, 200);

 * int lenght = 100;

 * g.drawLine((int)origin1.getX()-length, (int)origin1.getY(), (int)origin1.getX()+length, (int)origin1.getY());

 * g.drawLine((int)origin1.getX(), (int)origin1.getY()-length, (int)origin1.getX(), (int)origin1.getY()+length);

 * // draw the rotated text

 * AffineTransform finalTransform = g.getTransform();

 * finalTransform.rotate(angle);

 * g.setTransform(finalTransform);

 * TextLayout text = new TextLayout("Hello world", g.getFont(), g.getFontRenderContext());

 * Point2D p = RotatedTextUtils.getPosition(origin1, angle, text, RotatedTextUtils.PLACEMENT_BOTTOM, RotatedTextUtils.ANCHOR_CORNER);

 * text.draw(g, (float)p.getX(), (float)p.getY());

 * // faster than RotatedTextUtils.draw if we are writing the same rotated text at different points

 * p = RotatedTextUtils.getPosition(origin2, angle, text, RotatedTextUtils.PLACEMENT_BOTTOM, RotatedTextUtils.ANCHOR_CORNER);

 * text.draw(g, (float)p.getX(), (float)p.getY());

 * g.setTransform(defaultAt);

 * </pre>

 * </p>

 * 

 * @author Cesar Martinez Izquierdo <cmartinez@scolab.es>

 *

 */

public class RotatedTextUtils {

	/**

	 * PI/2

	 */

	private static final double PI_HALF = Math.PI/2;

	/**

	 * 3*PI/2

	 */

	private static final double PI_HALF3 = 3*Math.PI/2;

	/**

	 * 2*PI

	 */

	private static final double PI_HALF4 = 2*Math.PI;

	/**

	 * Anchor a corner of the text on the rotation center. In this way

	 * a corner (left or right) of the text string will be aligned

	 * with the rotation point.

	 * 

	 * The corner (left or right) to anchor will be automatically selected

	 * depending on the rotation angle (choosing the corner which is closer

	 * to the rotation center)

	 */

	public static final int ANCHOR_CORNER = 0;

	/**

	 * Anchor the center of the text on the rotation center. In this way

	 * the center of the text string will be aligned with the rotation point.

	 */

	public static final int ANCHOR_CENTER = 1;

	/**

	 * Place the text on the top of the rotation point, meaning that no part

	 * of the text is under the rotation point. 

	 */

	public static final int PLACEMENT_TOP = 0;

	/**

	 * Place the text bellow the rotation point, meaning that no part

	 * of the text is over the rotation point. 

	 */

	public static final int PLACEMENT_BOTTOM = 1;

	/**

	 * Place the text on the left of the rotation point, meaning that no part

	 * of the text is on the right the rotation point. 

	 */

	public static final int PLACEMENT_LEFT = 2;

	/**

	 * Place the text on the right of the rotation point, meaning that no part

	 * of the text is on the left the rotation point. 

	 */

	public static final int PLACEMENT_RIGHT = 3;

    /**

     * Draws rotated text which is positioned on

     * a specific side of the rotation point (TOP, BOTTOM, LEFT or RIGHT).

     * The text can be anchored by its central point or by the text corner.

     * 

     * @param origin	The rotation center point

     * @param g			The target Graphics2D

     * @param strText 	The text to draw .Use the Graphics2D options (font,

     * color, etc) to style the text before calling this method.

     * @param angle		The rotation angle, in radians. The angle should be comprised

     * in the [0, 2*PI[ range, result is otherwise unexpected

     * (a convenience method is provided to normalize it:

     *  {@link RotatedTextUtils#normalizeAngle(double)})

     * @param relativePosition The position of the text compared with the origin point.

     *  See {@link #PLACEMENT_TOP}, {@link #PLACEMENT_LEFT}, {@link #PLACEMENT_RIGHT} and

     *  {@value #PLACEMENT_BOTTOM}.

     * @param anchor 	Whether the center of the label should be aligned with the

     * point ({@link #ANCHOR_CENTER}) or a corner of the label should be used

     * ({@link #ANCHOR_CORNER}).

     */

	public static void draw(Point2D origin, Graphics2D g, String strText, double angle, int relativePosition, int anchor) {

		AffineTransform defaultAt = g.getTransform();

		// affine transform containing the rotation plus the previous graphics transformations (if any)

		AffineTransform finalAt = g.getTransform();

		finalAt.rotate(angle);

		g.setTransform(finalAt);

		TextLayout text = new TextLayout(strText, g.getFont(), g.getFontRenderContext());

		Point2D position = null;

		if (anchor==ANCHOR_CORNER) {

			switch (relativePosition) {

			case PLACEMENT_RIGHT:

				position = getPositionRightCorner(origin, text, angle);

				break;

			case PLACEMENT_BOTTOM:

				position = getPositionBottomCorner(origin, text, angle);

				break;

			case PLACEMENT_LEFT:

				position = getPositionLeftCorner(origin, text, angle);

				break;

			case PLACEMENT_TOP:

			default:

				position = getPositionTopCorner(origin, text, angle);

				break;

			}

		}

		else {

			switch (relativePosition) {

			case PLACEMENT_RIGHT:

				position = getPositionRightCenter(origin, text, angle);

				break;

			case PLACEMENT_BOTTOM:

				position = getPositionBottomCenter(origin, text, angle);

				break;

			case PLACEMENT_LEFT:

				position = getPositionLeftCenter(origin, text, angle);

				break;

			case PLACEMENT_TOP:

			default:

				position = getPositionTopCenter(origin, text, angle);

				break;

			}

		}

		text.draw(g, (float)position.getX(), (float)position.getY());

		g.setTransform(defaultAt);

    }

    /**

     * <p>Gets the position in which the text should be drawn according to the

     * provided origin point, angle, align and anchor.</p>

     * 

     * <p>You may consider using

     * the higher level draw methods (e.g. {@link #draw(Point2D, Graphics2D, String, double, int, int)},

     * {@link #drawTopCenter(Point2D, Graphics2D, String, double)}, etc) if

     * you are drawing a single label, as this method makes some assumptions

     * for getting maximum performance when drawing several texts using the

     * same rotation. In particular, this method assumes that the target

     * Graphics2D has been rotated using the provided angle and the text

     * has been laid out for this rotated target Graphics2D.</p> 

	 * 

	 * <p>This method deals with coordinates in 2 different coordinate spaces

     * (the original, non-rotated space and the rotated space). The origin point

     * coordinates has to be referred to the non-rotated space, while the returned

     * position is referred to the rotated space.</p>

     * 

     * @param origin The point used as the center of the rotation

     * @param angle The rotation angle, in radians. The angle should be comprised

     * in the [0, 2*PI[ range, result is otherwise unexpected

     * (a convenience method is provided to normalize it:

     *  {@link RotatedTextUtils#normalizeAngle(double)}

     * @param text   The text to be positioned, which has to be prepared for

     * a rotated graphics, matching the rotation angle 

     * @param at    An affine transform matching the rotation angle 

     * @param relativePosition The position of the text compared with the origin point.

     *  See {@link #PLACEMENT_TOP}, {@link #PLACEMENT_LEFT}, {@link #PLACEMENT_RIGHT} and

     *  {@value #PLACEMENT_BOTTOM}.

     * @param anchor Whether the center of the label should be aligned with the

     * point ({@link #ANCHOR_CENTER}) or a corner of the label should be used

     * ({@link #ANCHOR_CORNER}).

     * @return The position in which the text should be drawn.

     * 

     * @throws NoninvertibleTransformException

     */

    public static Point2D getPosition(Point2D origin, double angle, TextLayout text, int relativePosition, int anchor)  throws NoninvertibleTransformException {

    	if (anchor==ANCHOR_CORNER) {

    		switch (relativePosition) {

    		case PLACEMENT_RIGHT:

    			return getPositionRightCorner(origin, text, angle);

    		case PLACEMENT_BOTTOM:

    			return getPositionBottomCorner(origin, text, angle);

    		case PLACEMENT_LEFT:

    			return getPositionLeftCorner(origin, text, angle);

    		case PLACEMENT_TOP:

    		default:

    			return getPositionTopCorner(origin, text, angle);

    		}

    	}

    	else {

    		switch (relativePosition) {

    		case PLACEMENT_RIGHT:

    			return getPositionRightCenter(origin, text, angle);

    		case PLACEMENT_BOTTOM:

    			return getPositionBottomCenter(origin, text, angle);

    		case PLACEMENT_LEFT:

    			return getPositionLeftCenter(origin, text, angle);

    		case PLACEMENT_TOP:

    		default:

    			return getPositionTopCenter(origin, text, angle);

    		}

    	}

    }

    /**

     * <p>Gets the position in which the text should be drawn according to the

     * provided origin point and angle, placing the text at the top of the

     * point and using a corner of the text as anchor.</p>

     * 

     * <p>This method deals with coordinates in 2 different coordinate spaces

     * (the original, non-rotated space and the rotated space). The origin point

     * coordinates has to be referred to the non-rotated space, while the returned

     * position is referred to the rotated space.</p>

     *  

     * @param origin The center point of the rotation

     * @param text   The text to be drawn, created for the rotated Graphics2D

     * @param angle  The rotation angle, in radians. Angle is assumed to be normalized (see

     * {@link #normalizeAngle(double)}) 

     * @return The position in which the text should be drawn, referenced to the rotated

     * coordinate space

     * 

     * @throws NoninvertibleTransformException

     * @see {@link RotatedTextUtils#getPosition(Point2D, double, TextLayout, int, int)}

     * @see RotatedTextUtils#PLACEMENT_TOP

     * @see RotatedTextUtils#ANCHOR_CORNER

     */

    public static Point2D getPositionTopCorner(Point2D origin, TextLayout text, double angle) {

    	double height = text.getBounds().getHeight();

    	double descent = text.getBounds().getHeight()+text.getBounds().getY();

    	double width = text.getAdvance();

    	double yOffset;

    	double xOffset;

		double correctedOriginX = origin.getX()+getRotatedDescent2(descent, angle);

		double correctedOriginY = origin.getY()-getRotatedDescent1(descent, angle);

    	if (angle>0.0d && angle<PI_HALF) { // first quadrant

    		xOffset = -getRotatedWidth1(width, angle)-getRotatedWidth2(height, angle)/2.0d;

    		yOffset = -getRotatedHeight1(width, angle);

    	}

    	else if (angle<0.1d) { // when is 0

    		xOffset = 0.0d;

    		yOffset = 0.0d;

    	}

    	else if (angle>PI_HALF3) {  // fourth quadrant

    		xOffset = getRotatedWidth2(height, angle)/2.0d;

    		yOffset = 0.0d;

    	}

    	else if (angle<Math.PI) { // second quadrant

    		xOffset = getRotatedWidth1(width, angle)-getRotatedWidth2(height, angle)/2.0d;

    		yOffset = -(getRotatedHeight1(width, angle)+getRotatedHeight2(height, angle));

    	}

    	else { // third quadrant

    		xOffset = getRotatedWidth2(height, angle)/2.0d; 

    		yOffset = -getRotatedHeight2(height, angle);

    	}

    	Point2D result = new Point2D.Double(correctedOriginX+xOffset, correctedOriginY+yOffset);

    	// Transform the calculated drawing point from the non-rotated coordinate space

    	// to the final (rotated) coordinate space.

    	// All the above calculations have been made using the non-rotated coordinate space

    	AffineTransform at = AffineTransform.getRotateInstance(angle);

    	try {

			at.inverseTransform(result, result);

		} catch (NoninvertibleTransformException e) {

			// can't happen: rotation always has inverste tranform

		}

        return result;

    }

    /**

     * <p>Gets the position in which the text should be drawn according to the

     * provided origin point and angle, placing the text at the top of the

     * point and using the center of the text as anchor.</p>

     * 

     * <p>This method deals with coordinates in 2 different coordinate spaces

     * (the original, non-rotated space and the rotated space). The origin point

     * coordinates has to be referred to the non-rotated space, while the returned

     * position is referred to the rotated space.</p>

     *  

     * @param origin The center point of the rotation

     * @param text   The text to be drawn, created for the rotated Graphics2D

     * @param angle  The rotation angle, in radians. Angle is assumed to be normalized (see

     * {@link #normalizeAngle(double)}) 

     * @return The position in which the text should be drawn, referenced to the rotated

     * coordinate space

     * 

     * @throws NoninvertibleTransformException

     * @see {@link RotatedTextUtils#getPosition(Point2D, double, TextLayout, int, int)}

     * @see RotatedTextUtils#PLACEMENT_TOP

     * @see RotatedTextUtils#ANCHOR_CENTER

     */

    public static Point2D getPositionTopCenter(Point2D origin, TextLayout text, double angle) {

    	double height = text.getBounds().getHeight();

    	double descent = text.getBounds().getHeight()+text.getBounds().getY();

    	double width = text.getAdvance();

    	double yOffset;

    	double xOffset;

		double correctedOriginX = origin.getX()+getRotatedDescent2(descent, angle);

		double correctedOriginY = origin.getY()-getRotatedDescent1(descent, angle);

    	if (angle>0.0d && angle<PI_HALF) { // first quadrant

    		xOffset = -(getRotatedWidth1(width, angle)+getRotatedWidth2(height, angle))/2.0d;

    		yOffset = -getRotatedHeight1(width, angle);

    	}

    	else if (angle<0.1d) { // when is 0

    		xOffset = -width/2.0d;

    		yOffset = 0.0d;

    	}

    	else if (angle>PI_HALF3) {  // fourth quadrant

    		xOffset = (getRotatedWidth2(height, angle)-getRotatedWidth1(width, angle))/2.0d;

    		yOffset = 0.0d;

    	}

    	else if (angle<Math.PI) { // second quadrant

    		xOffset = (getRotatedWidth1(width, angle)-getRotatedWidth2(height, angle))/2.0d;

    		yOffset = -(getRotatedHeight1(width, angle)+getRotatedHeight2(height, angle));

    	}

    	else { // third quadrant

    		xOffset = (getRotatedWidth1(width, angle) + getRotatedWidth2(height, angle))/2.0d; 

    		yOffset = -getRotatedHeight2(height, angle);

    	}

    	Point2D result = new Point2D.Double(correctedOriginX+xOffset, correctedOriginY+yOffset);

    	// Transform the calculated drawing point from the non-rotated coordinate space

    	// to the final (rotated) coordinate space.

    	// All the above calculations have been made using the non-rotated coordinate space

    	AffineTransform at = AffineTransform.getRotateInstance(angle);

    	try {

			at.inverseTransform(result, result);

		} catch (NoninvertibleTransformException e) {

			// can't happen: rotation always has inverste tranform

		}

        return result;

    }

    /**

     * <p>Gets the position in which the text should be drawn according to the

     * provided origin point and angle, placing the text at the right of the

     * point and using a corner of the text as anchor.</p>

     * 

     * <p>This method deals with coordinates in 2 different coordinate spaces

     * (the original, non-rotated space and the rotated space). The origin point

     * coordinates has to be referred to the non-rotated space, while the returned

     * position is referred to the rotated space.</p>

     *  

     * @param origin The center point of the rotation

     * @param text   The text to be drawn, created for the rotated Graphics2D

     * @param angle  The rotation angle, in radians. Angle is assumed to be normalized (see

     * {@link #normalizeAngle(double)}) 

     * @return The position in which the text should be drawn, referenced to the rotated

     * coordinate space

     * 

     * @throws NoninvertibleTransformException

     * @see {@link RotatedTextUtils#getPosition(Point2D, double, TextLayout, int, int)}

     * @see RotatedTextUtils#PLACEMENT_RIGHT

     * @see RotatedTextUtils#ANCHOR_CORNER

     */

    public static Point2D getPositionRightCorner(Point2D origin, TextLayout text, double angle) {

    	double height = text.getBounds().getHeight();

    	double descent = text.getBounds().getHeight()+text.getBounds().getY();

    	double width = text.getAdvance();

    	double yOffset;

    	double xOffset;

		double correctedOriginX = origin.getX()+getRotatedDescent2(descent, angle);

		double correctedOriginY = origin.getY()-getRotatedDescent1(descent, angle);

    	if (angle>0.0d && angle<PI_HALF) { // first quadrant

    		xOffset = 0.0d;

    		yOffset = getRotatedHeight2(height, angle)/2.0d;

    	}

    	else if (angle<0.1d) { // when is 0

    		xOffset = 0.0d;

    		yOffset = height/2.0d;

    	}

    	else if (angle>PI_HALF3) {  // fourth quadrant

    		xOffset = getRotatedWidth2(height, angle);

    		yOffset = getRotatedHeight2(height, angle)/2.0d;

    	}

    	else if (angle<Math.PI) { // second quadrant

    		xOffset = getRotatedWidth1(width, angle);

    		yOffset = -getRotatedHeight1(width, angle)-(getRotatedHeight2(height, angle))/2.0d;

    	}

    	else { // third quadrant

    		xOffset = getRotatedWidth1(width, angle) + getRotatedWidth2(height, angle);

    		yOffset = -getRotatedHeight2(height, angle)/2.0d +getRotatedHeight1(width, angle);

    	}

    	Point2D result = new Point2D.Double(correctedOriginX+xOffset, correctedOriginY+yOffset);

    	// Transform the calculated drawing point from the non-rotated coordinate space

    	// to the final (rotated) coordinate space.

    	// All the above calculations have been made using the non-rotated coordinate space

    	AffineTransform at = AffineTransform.getRotateInstance(angle);

    	try {

			at.inverseTransform(result, result);

		} catch (NoninvertibleTransformException e) {

			// can't happen: rotation always has inverste tranform

		}

    	return result;

    }

    /**

     * <p>Gets the position in which the text should be drawn according to the

     * provided origin point and angle, placing the text at the right of the

     * point and using the center of the text as anchor.</p>

     * 

     * <p>This method deals with coordinates in 2 different coordinate spaces

     * (the original, non-rotated space and the rotated space). The origin point

     * coordinates has to be referred to the non-rotated space, while the returned

     * position is referred to the rotated space.</p>

     *  

     * @param origin The center point of the rotation

     * @param text   The text to be drawn, created for the rotated Graphics2D

     * @param angle  The rotation angle, in radians. Angle is assumed to be normalized (see

     * {@link #normalizeAngle(double)}) 

     * @return The position in which the text should be drawn, referenced to the rotated

     * coordinate space

     * 

     * @throws NoninvertibleTransformException

     * @see {@link RotatedTextUtils#getPosition(Point2D, double, TextLayout, int, int)}

     * @see RotatedTextUtils#PLACEMENT_RIGHT

     * @see RotatedTextUtils#ANCHOR_CENTER

     */

    public static Point2D getPositionRightCenter(Point2D origin, TextLayout text, double angle) {

    	double height = text.getBounds().getHeight();

    	double descent = text.getBounds().getHeight()+text.getBounds().getY();

    	double width = text.getAdvance();

    	double yOffset;

    	double xOffset;

		double correctedOriginX = origin.getX()+getRotatedDescent2(descent, angle);

		double correctedOriginY = origin.getY()-getRotatedDescent1(descent, angle);

    	if (angle>0.0d && angle<PI_HALF) { // first quadrant

    		xOffset = 0.0;

    		yOffset = (getRotatedHeight2(height, angle)-getRotatedHeight1(width, angle))/2.0d;

    	}

    	else if (angle<0.1d) { // when is 0

    		xOffset = 0.0;

    		yOffset = height/2.0d;

    	}

    	else if (angle>PI_HALF3) {  // fourth quadrant

    		xOffset = (getRotatedWidth2(height, angle));

    		yOffset = (getRotatedHeight1(width, angle)+getRotatedHeight2(height, angle))/2.0d;

    	}

    	else if (angle<Math.PI) { // second quadrant

    		xOffset = getRotatedWidth1(width, angle);

    		yOffset = -(getRotatedHeight2(height, angle)+getRotatedHeight1(width, angle))/2.0d;

    	}

    	else { // third quadrant

    		xOffset = getRotatedWidth1(width, angle)+getRotatedWidth2(height, angle); 

    		yOffset = (getRotatedHeight1(width, angle)-getRotatedHeight2(height, angle))/2.0d;

    	}

    	Point2D result = new Point2D.Double(correctedOriginX+xOffset, correctedOriginY+yOffset);

    	// Transform the calculated drawing point from the non-rotated coordinate space

    	// to the final (rotated) coordinate space.

    	// All the above calculations have been made using the non-rotated coordinate space

    	AffineTransform at = AffineTransform.getRotateInstance(angle);

    	try {

			at.inverseTransform(result, result);

		} catch (NoninvertibleTransformException e) {

			// can't happen: rotation always has inverste tranform

		}

    	return result;

    }

    /**

     * <p>Gets the position in which the text should be drawn according to the

     * provided origin point and angle, placing the text at the bottom of the

     * point and using a corner of the text as anchor.</p>

     * 

     * <p>This method deals with coordinates in 2 different coordinate spaces

     * (the original, non-rotated space and the rotated space). The origin point

     * coordinates has to be referred to the non-rotated space, while the returned

     * position is referred to the rotated space.</p>

     *  

     * @param origin The center point of the rotation

     * @param text   The text to be drawn, created for the rotated Graphics2D

     * @param angle  The rotation angle, in radians. Angle is assumed to be normalized (see

     * {@link #normalizeAngle(double)}) 

     * @return The position in which the text should be drawn, referenced to the rotated

     * coordinate space

     * 

     * @throws NoninvertibleTransformException

     * @see {@link RotatedTextUtils#getPosition(Point2D, double, TextLayout, int, int)}

     * @see RotatedTextUtils#PLACEMENT_BOTTOM

     * @see RotatedTextUtils#ANCHOR_CORNER

     */

    public static Point2D getPositionBottomCorner(Point2D origin, TextLayout text, double angle) {

    	double height = text.getBounds().getHeight();

    	double descent = text.getBounds().getHeight()+text.getBounds().getY();

    	double width = text.getAdvance();

    	double yOffset;

    	double xOffset;

		double correctedOriginX = origin.getX()+getRotatedDescent2(descent, angle);

		double correctedOriginY = origin.getY()-getRotatedDescent1(descent, angle);

    	if (angle>0.0d && angle<=PI_HALF) { // first quadrant

    		xOffset = -getRotatedWidth2(height, angle)/2.0d;

    		yOffset = getRotatedHeight2(height, angle);

    	}

    	else if (angle<0.1d) { // when is 0

    		xOffset = 0.0d;

    		yOffset = height;

    	}

    	else if (angle>=PI_HALF3) {  // fourth quadrant

    		xOffset = getRotatedWidth2(height, angle)/2.0d-getRotatedWidth1(width, angle);

    		yOffset = getRotatedHeight1(width, angle)+getRotatedHeight2(height, angle);

    	}

    	else if (angle<Math.PI) { // second quadrant

    		xOffset = -getRotatedWidth2(height, angle)/2.0d;

    		yOffset = 0.0d;

    	}

    	else { // third quadrant

    		xOffset = getRotatedWidth1(width, angle) + getRotatedWidth2(height, angle)/2.0d; 

    		yOffset = getRotatedHeight1(width, angle);

    	}

    	Point2D result = new Point2D.Double(correctedOriginX+xOffset, correctedOriginY+yOffset);

    	// Transform the calculated drawing point from the non-rotated coordinate space

    	// to the final (rotated) coordinate space.

    	// All the above calculations have been made using the non-rotated coordinate space

    	AffineTransform at = AffineTransform.getRotateInstance(angle);

    	try {

			at.inverseTransform(result, result);

		} catch (NoninvertibleTransformException e) {

			// can't happen: rotation always has inverste tranform

		}

    	return result;

    }

    /**

     * <p>Gets the position in which the text should be drawn according to the

     * provided origin point and angle, placing the text at the bottom of the

     * point and using the center of the text as anchor.</p>

     * 

     * <p>This method deals with coordinates in 2 different coordinate spaces

     * (the original, non-rotated space and the rotated space). The origin point

     * coordinates has to be referred to the non-rotated space, while the returned

     * position is referred to the rotated space.</p>

     *  

     * @param origin The center point of the rotation

     * @param text   The text to be drawn, created for the rotated Graphics2D

     * @param angle  The rotation angle, in radians. Angle is assumed to be normalized (see

     * {@link #normalizeAngle(double)}) 

     * @return The position in which the text should be drawn, referenced to the rotated

     * coordinate space

     * 

     * @throws NoninvertibleTransformException

     * @see {@link RotatedTextUtils#getPosition(Point2D, double, TextLayout, int, int)}

     * @see RotatedTextUtils#PLACEMENT_BOTTOM

     * @see RotatedTextUtils#ANCHOR_CENTER

     */

    public static Point2D getPositionBottomCenter(Point2D origin, TextLayout text, double angle) {

    	double height = text.getBounds().getHeight();

    	double descent = text.getBounds().getHeight()+text.getBounds().getY();

    	double width = text.getAdvance();

    	double yOffset;

    	double xOffset;

		double correctedOriginX = origin.getX()+getRotatedDescent2(descent, angle);

		double correctedOriginY = origin.getY()-getRotatedDescent1(descent, angle);

    	if (angle>0.0d && angle<PI_HALF) { // first quadrant

    		xOffset = -(getRotatedWidth1(width, angle)+getRotatedWidth2(height, angle))/2.0d;

    		yOffset = getRotatedHeight2(height, angle);

    	}

    	else if (angle<0.1d) { // when is 0

    		xOffset = -width/2.0d;

    		yOffset = height;

    	}

    	else if (angle>PI_HALF3) {  // fourth quadrant

    		xOffset = (getRotatedWidth2(height, angle)-getRotatedWidth1(width, angle))/2.0d;

    		yOffset = getRotatedHeight1(width, angle)+getRotatedHeight2(height, angle);

    	}

    	else if (angle<Math.PI) { // second quadrant

    		xOffset = (getRotatedWidth1(width, angle)-getRotatedWidth2(height, angle))/2.0d;

    		yOffset = 0.0d;

    	}

    	else { // third quadrant

    		xOffset = (getRotatedWidth1(width, angle) + getRotatedWidth2(height, angle))/2.0d; 

    		yOffset = getRotatedHeight1(width, angle);

    	}

    	Point2D result = new Point2D.Double(correctedOriginX+xOffset, correctedOriginY+yOffset);

    	// Transform the calculated drawing point from the non-rotated coordinate space

    	// to the final (rotated) coordinate space.

    	// All the above calculations have been made using the non-rotated coordinate space

    	AffineTransform at = AffineTransform.getRotateInstance(angle);

    	try {

			at.inverseTransform(result, result);

		} catch (NoninvertibleTransformException e) {

			// can't happen: rotation always has inverste tranform

		}

    	return result;

    }

    /**

     * <p>Gets the position in which the text should be drawn according to the

     * provided origin point and angle, placing the text at the left of the

     * point and using a corner of the text as anchor.</p>

     * 

     * <p>This method deals with coordinates in 2 different coordinate spaces

     * (the original, non-rotated space and the rotated space). The origin point

     * coordinates has to be referred to the non-rotated space, while the returned

     * position is referred to the rotated space.</p>

     *  

     * @param origin The center point of the rotation

     * @param text   The text to be drawn, created for the rotated Graphics2D

     * @param angle  The rotation angle, in radians. Angle is assumed to be normalized (see

     * {@link #normalizeAngle(double)}) 

     * @return The position in which the text should be drawn, referenced to the rotated

     * coordinate space

     * 

     * @throws NoninvertibleTransformException

     * @see {@link RotatedTextUtils#getPosition(Point2D, double, TextLayout, int, int)}

     * @see RotatedTextUtils#PLACEMENT_LEFT

     * @see RotatedTextUtils#ANCHOR_CORNER

     */

    public static Point2D getPositionLeftCorner(Point2D origin, TextLayout text, double angle) {

    	double height = text.getBounds().getHeight();

    	double descent = text.getBounds().getHeight()+text.getBounds().getY();

    	double width = text.getAdvance();

    	double yOffset;

    	double xOffset;

		double correctedOriginX = origin.getX()+getRotatedDescent2(descent, angle);

		double correctedOriginY = origin.getY()-getRotatedDescent1(descent, angle);

    	if (angle>0.0d && angle<PI_HALF) { // first quadrant

    		xOffset = -(getRotatedWidth1(width, angle)+getRotatedWidth2(height, angle));

    		yOffset = getRotatedHeight2(height, angle)/2.0d -getRotatedHeight1(width, angle);

    	}

    	else if (angle<0.1d) { // when is 0

    		xOffset = -width;

    		yOffset = height/2.0d;

    	}

    	else if (angle>PI_HALF3) {  // fourth quadrant

    		xOffset = (-getRotatedWidth1(width, angle));

    		yOffset = getRotatedHeight1(width, angle)+(getRotatedHeight2(height, angle))/2.0d;

    	}

    	else if (angle<Math.PI) { // second quadrant

    		xOffset = -(getRotatedWidth2(height, angle));

    		yOffset = -getRotatedHeight2(height, angle)/2.0d;

    	}

    	else { // third quadrant

    		xOffset = 0.0d; 

    		yOffset = -getRotatedHeight2(height, angle)/2.0d;

    	}

    	Point2D result = new Point2D.Double(correctedOriginX+xOffset, correctedOriginY+yOffset);

    	// Transform the calculated drawing point from the non-rotated coordinate space

    	// to the final (rotated) coordinate space.

    	// All the above calculations have been made using the non-rotated coordinate space

    	AffineTransform at = AffineTransform.getRotateInstance(angle);

    	try {

			at.inverseTransform(result, result);

		} catch (NoninvertibleTransformException e) {

			// can't happen: rotation always has inverste tranform

		}

    	return result;

    }

    /**

     * <p>Gets the position in which the text should be drawn according to the

     * provided origin point and angle, placing the text at the left of the

     * point and using the center of the text as anchor.</p>

     * 

     * <p>This method deals with coordinates in 2 different coordinate spaces

     * (the original, non-rotated space and the rotated space). The origin point

     * coordinates has to be referred to the non-rotated space, while the returned

     * position is referred to the rotated space.</p>

     *  

     * @param origin The center point of the rotation

     * @param text   The text to be drawn, created for the rotated Graphics2D

     * @param angle  The rotation angle, in radians. Angle is assumed to be normalized (see

     * {@link #normalizeAngle(double)}) 

     * @return The position in which the text should be drawn, referenced to the rotated

     * coordinate space

     * 

     * @throws NoninvertibleTransformException

     * @see {@link RotatedTextUtils#getPosition(Point2D, double, TextLayout, int, int)}

     * @see RotatedTextUtils#PLACEMENT_LEFT

     * @see RotatedTextUtils#ANCHOR_CENTER

     */

    public static Point2D getPositionLeftCenter(Point2D origin, TextLayout text, double angle) {

    	double height = text.getBounds().getHeight();

    	double descent = text.getBounds().getHeight()+text.getBounds().getY();

    	double width = text.getAdvance();

    	double yOffset;

    	double xOffset;

		double correctedOriginX = origin.getX()+getRotatedDescent2(descent, angle);

		double correctedOriginY = origin.getY()-getRotatedDescent1(descent, angle);

    	if (angle>0.0d && angle<PI_HALF) { // first quadrant

    		xOffset = -(getRotatedWidth1(width, angle)+getRotatedWidth2(height, angle));

    		yOffset = (getRotatedHeight2(height, angle)-getRotatedHeight1(width, angle))/2.0d;

    	}

    	else if (angle<0.1d) { // when is 0

    		xOffset = -width;

    		yOffset = height/2.0d;

    	}

    	else if (angle>PI_HALF3) {  // fourth quadrant

    		xOffset = (-getRotatedWidth1(width, angle));

    		yOffset = (getRotatedHeight1(width, angle)+getRotatedHeight2(height, angle))/2.0d;

    	}

    	else if (angle<Math.PI) { // second quadrant

    		xOffset = -(getRotatedWidth2(height, angle));

    		yOffset = -(getRotatedHeight2(height, angle)+getRotatedHeight1(width, angle))/2.0d;

    	}

    	else { // third quadrant

    		xOffset = 0.0d; 

    		yOffset = (getRotatedHeight1(width, angle)-getRotatedHeight2(height, angle))/2.0d;

    	}

    	Point2D result = new Point2D.Double(correctedOriginX+xOffset, correctedOriginY+yOffset);

    	// Transform the calculated drawing point from the non-rotated coordinate space

    	// to the final (rotated) coordinate space.

    	// All the above calculations have been made using the non-rotated coordinate space

    	AffineTransform at = AffineTransform.getRotateInstance(angle);

    	try {

			at.inverseTransform(result, result);

		} catch (NoninvertibleTransformException e) {

			// can't happen: rotation always has inverste tranform

		}

    	return result;

    }

    /**

     * Draws the provided text rotated by angle radians using location as rotation center

     * without any positioning or anchoring adjustments.

     * Use the Graphics2D options (font, color, etc) to style the text before calling

     * this method.

     * 

     * @param location The rotation center

     * @param g        The Graphics2D on which the text should be drawn

     * @param strText  The text to be drawn

     * @param angle    The rotation angle, in radians

     */

    public static void drawRotated(Point2D location, Graphics2D g, String strText, double angle) {

    	AffineTransform defaultAt = g.getTransform();

    	AffineTransform at = AffineTransform.getRotateInstance(angle);

        g.setTransform(at);

        TextLayout text = new TextLayout(strText, g.getFont(), g.getFontRenderContext());

        Point2D result = new Point2D.Double(location.getX(), location.getY());

    	try {

			at.inverseTransform(result, result);

		} catch (NoninvertibleTransformException e) {

			// can't happen: rotation always has inverste tranform

		}

        text.draw(g, (float)result.getX(), (float)result.getY());

        g.setTransform(defaultAt);

    }

	/**

	 * Normalizes an angle, in radians. A normalized angle

	 * is an angle contained in the range [0, 2*PI[.

	 * 

	 * @param angle The angle to normalize, in radians

	 * @return Normalized angled, in radians

	 */

	public static double normalizeAngle(double angle) {

		double module = angle%(PI_HALF4);

		if (module>=0) {

			return module;

		}

		else {

			return (angle + PI_HALF4);

		}

	}

    private static double getRotatedHeight1(double width, double angle) {

    	return Math.abs(width*Math.sin(angle));

    }

    private static double getRotatedHeight2(double height, double angle) {

    	return Math.abs(height*Math.cos(angle));

    }

    private static double getRotatedWidth1(double width, double angle) {

    	return Math.abs(width*Math.cos(angle));

    }

    private static double getRotatedWidth2(double height, double angle) {

    	return Math.abs(height*Math.sin(angle));

    }

    private static double getRotatedDescent1(double descent, double angle) {

    	return descent*Math.sin(angle+PI_HALF);

    }

    private static double getRotatedDescent2(double descent, double angle) {

    	return descent*Math.sin(angle);

    }

    private static double getRotatedOffsetX1(double baseOffsetX, double angle) {

    	return Math.abs(baseOffsetX*Math.cos(angle+PI_HALF));

    }

    private static double getRotatedOffsetX2(double baseOffsetX, double angle) {

    	return Math.abs(baseOffsetX*Math.sin(angle));

    }

}