Application: gvSIG desktop

 * 

 * 

    private static final String FIELD_DISTANCE_AREA = "distanceArea";

    private static final String FIELD_IMAGE_SIZE = "imageSize";

    private static final String FIELD_PROJ = "proj";

    private static final String FIELD_OFFSET = "offset";

    private static final String FIELD_MAP_UNITS = "mapUnits";

    private static final String FIELD_EXTENT = "extent";

    private static final String FIELD_EXTENTS = "extents";

    private static final String FIELD_DISTANCE_UNITS = "distanceUnits";

    private static final String FIELD_DIST3PIXEL = "dist3pixel";

    private static final String FIELD_DIST1PIXEL = "dist1pixel";

    private static final String FIELD_CLIP = "clip";

    private static final String FIELD_BACK_COLOR = "backColor";

    private static final String FIELD_ADJUSTED_EXTENT = "adjustedExtent";

    private static final GeometryManager geomManager =

        GeometryLocator.getGeometryManager();

    private static final Logger logger =

        LoggerFactory.getLogger(ViewPort.class);

    /**

     * <p>

     * Area selected by user using some tool.

     * </p>

     * 

     * <p>

     * When the zoom changes (for instance when using the zoom in or zoom out

     * tools, but also zooming to a selected feature or shape) the extent that

     * covers that area is the value returned by this method. It is not the

     * actual area shown in the view because it does not care about the aspect

     * ratio of the available area. However, any part of the real world

     * contained in this extent is shown in the view.

     * </p>

     * <p>

     * Probably this is not what you are looking for. If you are looking for the

     * complete extent currently shown, you must use

     * {@linkplain #getAdjustedExtent()} method which returns the extent that

     * contains this one but regarding the current view's aspect ratio.

     * </p>

     * 

     * @see #getExtent()

     * @see #setEnvelope(Envelope)

     */

    protected Rectangle2D extent;

    protected Time time;

    /**

     * <p>

     * Location and dimensions of the extent adjusted to the image size.

     * </p>

     * 

     * @see #getAdjustedExtent()

     */

    protected Rectangle2D adjustedExtent;

    /**

     * Draw version of the context. It's used for know when de componend has

     * changed any visualization property

     * 

     * @see getDrawVersion

     * @see updateDrawVersion

     */

    private long drawVersion = 0L;

    /**

     * <p>

     * History with the last extents of the view.

     * </p>

     * 

     * @see #setPreviousExtent()

     * @see #getExtents()

     */

    protected ExtentHistory extents = new ExtentHistory();

    /**

     * <p>

     * Size in <i>screen coordinates</i> of the rectangle where the image is

     * displayed.

     * </p>

     * <p>

     * Used by {@linkplain #calculateAffineTransform()} to calculate:<br>

     * 

     * <ul>

     * <li>The new {@link #scale scale} .

     * <li>The new {@link #adjustedExtent adjustableExtent} .

     * <li>The new {@link #trans trans} .

     * <li>The new real world coordinates equivalent to 1 pixel (

     * {@link #dist1pixel dist1pixel}) .

     * <li>The new real world coordinates equivalent to 3 pixels (

     * {@link #dist3pixel dist3pixel}) .

     * </ul>

     * </p>

     * 

     * @see #getImageSize()

     * @see #getImageHeight()

     * @see #getImageWidth()

     * @see #setImageSize(Dimension)

     */

    private Dimension imageSize;

    /**

     * <p>

     * the affine transformation between the {@link #extent extent} in <i>map 2D

     * coordinates</i> to the image area in the screen, in <i>screen 2D

     * coordinates</i> (pixels).

     * </p>

     * 

     * @see AffineTransform

     * 

     * @see #getAffineTransform()

     * @see #setAffineTransform(AffineTransform)

     * @see #calculateAffineTransform()

     */

    private AffineTransform trans = new AffineTransform();

    /**

     * <p>

     * Measurement unit used for measuring distances and displaying information.

     * </p>

     * 

     * @see #getDistanceUnits()

     * @see #setDistanceUnits(int)

     */

    private int distanceUnits = 1;

    /**

     * <p>

     * Measurement unit used for measuring areas and displaying information.

     * </p>

     * 

     * @see #getDistanceArea()

     * @see #setDistanceArea(int)

     */

    private int distanceArea = 1;

    /**

     * <p>

     * Measurement unit used by this view port for the map.

     * </p>

     * 

     * @see #getMapUnits()

     * @see #setMapUnits(int)

     */

    private int mapUnits = 1;

    /**

     * <p>

     * Array with the {@link ViewPortListener ViewPortListener}s registered to

     * this view port.

     * </p>

     * 

     * @see #addViewPortListener(ViewPortListener)

     * @see #removeViewPortListener(ViewPortListener)

     */

    private ArrayList listeners = new ArrayList();

    /**

     * <p>

     * The offset is the position where start drawing the map.

     * </p>

     * <p>

     * The offset of a <a href="http://www.gvsig.gva.es/">gvSIG</a>'s

     * <i>View</i> is always (0, 0) because the drawing area fits with the full

     * window area. But in a <a href="http://www.gvsig.gva.es/">gvSIG</a>'s

     * <i>Layout</i> it's up to the place where the <code>FFrameView</code> is

     * located.

     * </p>

     * 

     * @see #getOffset()

     * @see #setOffset(Point2D)

     */

    private Point2D offset = new Point2D.Double(0, 0);

    /**

     * <p>

     * Clipping area.

     * </p>

     */

    // private Rectangle2D clip;

    /**

     * <p>

     * Background color of this view.

     * </p>

     * 

     * @see #getBackColor()

     * @see #setBackColor(Color)

     */

    private Color backColor = null; // Color.WHITE;

    /**

     * <p>

     * Information about the map projection used in this view.

     * </p>

     * 

     * @see #getProjection()

     * @see #setProjection(IProjection)

     */

    private IProjection proj;

    /**

     * <p>

     * Represents the distance in <i>world coordinates</i> equivalent to 1 pixel

     * in the view with the current extent.

     * </p>

     * 

     * @see #getDist1pixel()

     * @see #setDist1pixel(double)

     */

    private double dist1pixel;

    /**

     * <p>

     * Represents the distance in <i>world coordinates</i> equivalent to 3

     * pixels in the view with the current extent.

     * </p>

     * 

     * @see #getDist3pixel()

     * @see #setDist3pixel(double)

     */

    private double dist3pixel;

    /**

     * <p>

     * Ratio between the size of <code>imageSize</code> and <code>extent</code>:

     * <br>

     * <i>

     * 

     * <pre>

     * min{(imageSize.getHeight()/extent.getHeight(), imageSize.getWidth()/extent.getWidth())}

     * </pre>

     * 

     * </i>

     * </p>

     */

    private double scale;

    /**

     * <p>

     * Clipping area.

     * </p>

     * 

     * @see #setClipRect(Rectangle2D)

     */

    private Rectangle2D cliprect;

    /**

     * <p>

     * Enables or disables the <i>"adjustable extent"</i> mode.

     * </p>

     * 

     * <p>

     * When calculates the affine transform, if

     * <ul>

     * <li><i>enabled</i>: the new <code>adjustedExtent</code> will have the (X,

     * Y) coordinates of the <code>extent</code> and an area that will be an

     * scale of the image size. That area will have different height or width

     * (not both) of the extent according the least ratio (height or width) in

     * 

     * <pre>

     * image.size/extent.size"

     * </pre>.

     * <li><i>disabled</i>: the new <code>adjustedExtent</code> will be like

     * <code>extent</code>.

     * </ul>

     * </p>

     * 

     * @see #setAdjustable(boolean)

     */

    private boolean adjustableExtent = true;

    /**

     * <p>

     * ViewPort resolution in <i>dots-per-inch</i>. 

     * Useful to calculate the geographic scale of the view.

     * </p>

     * 

     * @see Toolkit#getScreenResolution()

     * @see MapContext#getScaleView()

     */

    private Double dpi = null;

    public ViewPort() {

    }

    /**

     * <p>

     * Creates a new view port with the information of the projection in

     * <code>proj</code> argument, and default configuration:

     * </p>

     * <p>

     * <ul>

     * <li><i><code>distanceUnits</code></i> = meters

     * <li><i><code>mapUnits</code></i> = meters

     * <li><i><code>backColor</code></i> = <i>undefined</i>

     * <li><i><code>offset</code></i> = <code>new Point2D.Double(0, 0);</code>

     * </ul>

     * </p>

     * 

     * @param proj

     *            information of the projection for this view port

     */

    public ViewPort(IProjection proj) {

        // Por defecto

        this.proj = proj;

    }

    /**

     * <p>

     * Changes the status of the <i>"adjustable extent"</i> option to enabled or

     * disabled.

     * </p>

     * 

     * <p>

     * If view port isn't adjustable, won't bear in mind the aspect ratio of the

     * available rectangular area to calculate the affine transform from the

     * original map in real coordinates. (Won't scale the image to adapt it to

     * the available rectangular area).

     * </p>

     * 

     * @param boolean the boolean to be set

     */

    public void setAdjustable(boolean adjustable) {

        if (adjustable == adjustableExtent) {

            return;

        }

        adjustableExtent = adjustable;

        this.updateDrawVersion();

    }

    /**

     * <p>

     * Appends the specified {@link ViewPortListener ViewPortListener} listener

     * if weren't.

     * </p>

     * 

     * @param arg0

     *            the listener to add

     * 

     * @return <code>true</code> if has been added successfully

     * 

     * @see #removeViewPortListener(ViewPortListener)

     */

    public boolean addViewPortListener(ViewPortListener arg0) {

        if (!listeners.contains(arg0)) {

            return listeners.add(arg0);

        }

        return false;

    }

    /**

     * <p>

     * Removes the specified {@link ViewPortListener ViewPortListener} listener,

     * if existed.

     * </p>

     * 

     * @param arg0

     *            the listener to remove

     * 

     * @return <code>true</code> if the contained the specified listener.

     * 

     * @see #addViewPortListener(ViewPortListener)

     */

    public boolean removeViewPortListener(ViewPortListener arg0) {

        return listeners.remove(arg0);

    }

    /**

     * <p>

     * Converts and returns the distance <code>d</code>, that is in <i>map

     * coordinates</i> to <i>screen coordinates</i> using a <i>delta

     * transform</i> with the transformation affine information in the

     * {@link #trans #trans} attribute.

     * </p>

     * 

     * @param d

     *            distance in <i>map coordinates</i>

     * 

     * @return distance equivalent in <i>screen coordinates</i>

     * 

     * @see #toMapDistance(int)

     * @see AffineTransform#deltaTransform(Point2D, Point2D)S

     */

    public int fromMapDistance(double d) {

        Point2D.Double pWorld = new Point2D.Double(1, 1);

        Point2D.Double pScreen = new Point2D.Double();

        try {

            trans.deltaTransform(pWorld, pScreen);

        } catch (Exception e) {

            System.err.print(e.getMessage());

        }

        return (int) (d * pScreen.x);

    }

    /**

     * <p>

     * Converts and returns the 2D point <code>(x,y)</code>, that is in <i>map

     * coordinates</i> to <i>screen coordinates</i> (pixels) using the affine

     * transformation in the {@link #trans #trans} attribute.

     * </p>

     * 

     * @param x

     *            the <code>x</code> <i>map coordinate</i> of a 2D point

     * @param y

     *            the <code>y</code> <i>map coordinate</i> of a 2D point

     * 

     * @return 2D point equivalent in <i>screen coordinates</i> (pixels)

     * 

     * @see #fromMapPoint(Point2D)

     * @see AffineTransform#transform(Point2D, Point2D)

     */

    public Point2D fromMapPoint(double x, double y) {

        Point2D.Double pWorld = new Point2D.Double(x, y);

        Point2D.Double pScreen = new Point2D.Double();

        try {

            trans.transform(pWorld, pScreen);

        } catch (Exception e) {

            System.err.print(e.getMessage());

        }

        return pScreen;

    }

    /**

     * <p>

     * Converts and returns the 2D point argument, that is in <i>map

     * coordinates</i> to <i>screen coordinates</i> (pixels) using the affine

     * transformation in the {@link #trans #trans} attribute.

     * </p>

     * 

     * @param point

     *            the 2D point in <i>map coordinates</i>

     * 

     * @return 2D point equivalent in <i>screen coordinates</i> (pixels)

     * 

     * @see #toMapPoint(Point2D)

     * @see #fromMapPoint(double, double)

     */

    public Point2D fromMapPoint(Point2D point) {

        return fromMapPoint(point.getX(), point.getY());

    }

    /**

     * <p>

     * Converts and returns the 2D point <code>(x,y)</code>, that is in

     * <i>screen coordinates</i> (pixels) to <i>map coordinates</i> using the

     * affine transformation in the {@link #trans #trans} attribute.

     * </p>

     * 

     * @param x

     *            the <code>x</code> <i>screen coordinate</i> of a 2D point

     * @param y

     *            the <code>y</code> <i>screen coordinate</i> of a 2D point

     * 

     * @return 2D point equivalent in <i>map coordinates</i>

     * 

     * @see #toMapPoint(Point2D)

     * @see #fromMapPoint(double, double)

     * @deprecated use {@link #convertToMapPoint(int, int)}

     */

    public Point2D toMapPoint(int x, int y) {

        Point2D pScreen = new Point2D.Double(x, y);

        return toMapPoint(pScreen);

    /**

     * <p>

     * Converts and returns the {@link Rectangle2D Rectangle2D}, that is in

     * <i>screen coordinates</i> (pixels) to <i>map coordinates</i> using

     * {@linkplain #toMapDistance(int)}, and {@linkplain #toMapPoint(int, int)}.

     * </p>

     * 

     * @param r

     *            the 2D rectangle in <i>screen coordinates</i> (pixels)

     * @return 2D rectangle equivalent in <i>map coordinates</i>

     * 

     * @see #fromMapRectangle(Rectangle2D)

     * @see #toMapDistance(int)

     * @see #toMapPoint(int, int)

     */

    public Rectangle2D toMapRectangle(Rectangle2D r) {

        Rectangle2D rect = new Rectangle2D.Double();

        Point2D p1 = toMapPoint((int) r.getX(), (int) r.getY());

        Point2D p2 = toMapPoint((int) r.getMaxX(), (int) r.getMaxY());

        rect.setFrameFromDiagonal(p1, p2);

        return rect;

    /**

     * <p>

     * Converts and returns the distance <code>d</code>, that is in <i>screen

     * coordinates</i> to <i>map coordinates</i> using the transformation affine

     * information in the {@link #trans #trans} attribute.

     * </p>

     * 

     * @param d

     *            distance in pixels

     * 

     * @return distance equivalent in <i>map coordinates</i>

     * 

     * @see #fromMapDistance(double)

     * @see AffineTransform

     */

    public double toMapDistance(int d) {

        double dist = d / trans.getScaleX();

        return dist;

    /**

     * <p>

     * Converts and returns the 2D point argument, that is in <i>screen

     * coordinates</i> (pixels) to <i>map coordinates</i> using the inverse

     * affine transformation of the {@link #trans #trans} attribute.

     * </p>

     * 

     * @param pScreen

     *            the 2D point in <i>screen coordinates</i> (pixels)

     * 

     * @return 2D point equivalent in <i>map coordinates</i>

     * 

     * @see #toMapPoint(int, int)

     * @see AffineTransform#createInverse()

     * @see AffineTransform#transform(Point2D, Point2D)

     * @deprecated use {@link #convertToMapPoint(Point2D)}

     */

    public Point2D toMapPoint(Point2D pScreen) {

        Point2D.Double pWorld = new Point2D.Double();

        AffineTransform at;

        try {

            at = trans.createInverse();

            at.transform(pScreen, pWorld);

        } catch (NoninvertibleTransformException e) {

            throw new RuntimeException("Non invertible transform Exception", e);

        }

        return pWorld;

    public Point convertToMapPoint(Point2D pScreen) {

    	Point2D p = toMapPoint(pScreen);

		try {

			return geomManager.createPoint(

				p.getX(), 

				p.getY(), 

				Geometry.SUBTYPES.GEOM2D

			);

		} catch (CreateGeometryException e) {

			// FIXME: Use a most especific exception.

			throw new RuntimeException(e);

		}

    public Point convertToMapPoint(int x, int y) {

        Point2D pScreen = new Point2D.Double(x, y);

        return convertToMapPoint(pScreen);

    }

    /**

     * <p>

     * Returns the real distance (in <i>world coordinates</i>) at the graphic

     * layers of two 2D points (in <i>map coordinates</i>) of the plane where is

     * selected the <i>extent</i>.

     * </p>

     * <p>

     * If the projection of this view is UTM, considers the Earth curvature.

     * </p>

     * 

     * @param pt1

     *            a 2D point in <i>map coordinates</i>

     * @param pt2

     *            another 2D point in <i>map coordinates</i>

     * 

     * @return the distance in meters between the two points 2D

     * 

     * @see GeoCalcImpl#distanceVincenty(Point2D, Point2D)

     */

    public double distanceWorld(Point2D pt1, Point2D pt2) {

        double dist = 0;

        if (proj.isProjected()) {

            dist = pt1.distance(pt2);

            dist = dist * MapContext.getDistanceTrans2Meter()[getMapUnits()];

        } else {

            GeoCalc geocalc = new GeoCalc(proj);

            dist = geocalc.distanceVincenty(pt1, pt2);

        }

        return dist;

    }

    /**

     * <p>

     * Sets as extent and adjusted extent of this view port, the previous.

     * Recalculating its parameters.

     * </p>

     * 

     * @see #getExtents()

     * @see #calculateAffineTransform()

     * @deprecated use {@link ViewPort#setPreviousEnvelope()}

     */

    public void setPreviousExtent() {

        setPreviousEnvelope();

    }

    /**

     * <p>

     * Sets as envelope and adjusted envelope of this view port, the previous.

     * Recalculating its parameters.

     * </p>

     * 

     * @see #getExtents()

     * @see #calculateAffineTransform()

     */

    public void setPreviousEnvelope() {

        this.updateDrawVersion();

        extent = extents.removePrev();

        // Calcula la transformaci�n af�n

        calculateAffineTransform();

        // Lanzamos los eventos de extent cambiado

        callExtentChanged(getAdjustedExtent());

    }

    /**

     * <p>

     * Gets the area selected by user using some tool.

     * </p>

     * 

     * <p>

     * When the zoom changes (for instance using the <i>zoom in</i> or <i>zoom

     * out</i> tools, but also zooming to a selected feature or shape) the

     * extent that covers that area is the value returned by this method. It is

     * not the actual area shown because it doesn't care about the aspect ratio

     * of the image size of the view. However, any part of the real world

     * contained in this extent is shown in the view.

     * </p>

     * 

     * <p>

     * If you are looking for the complete extent currently shown, you must use

     * the {@linkplain #getAdjustedExtent()} method.

     * </p>

     * 

     * @return the current extent

     * 

     * @see #setEnvelope(Envelope)

     * @see #getAdjustedExtent()

     * @see #setPreviousExtent()

     * @see #getExtents()

     * 

     * @deprecated use {@link ViewPort#getEnvelope()}

     */

    public Rectangle2D getExtent() {

        return extent;

    /**

     * <p>

     * Gets the envelope selected by user using some tool.

     * </p>

     * 

     * <p>

     * When the zoom changes (for instance using the <i>zoom in</i> or <i>zoom

     * out</i> tools, but also zooming to a selected feature or shape) the

     * envelope that covers that area is the value returned by this method. It

     * is not the actual envelope shown because it doesn't care about the aspect

     * ratio of the image size of the view. However, any part of the real world

     * contained in this envelope is shown in the view.

     * </p>

     * 

     * <p>

     * If you are looking for the complete extent currently shown, you must use

     * the {@linkplain #getAdjustedEnvelope()} method.

     * </p>

     * 

     * @return the current envelope

     * 

     * @see #setEnvelope(Envelope)

     * @see #getAdjustedEnvelope()

     * @see #setPreviousEnvelope()

     * @see #getEnvelopes()

     */

    public Envelope getEnvelope() {

        if (this.extent == null) {

            return null;

        }

        try {

            return geomManager.createEnvelope(extent.getMinX(),

                extent.getMinY(),

                extent.getMaxX(),

                extent.getMaxY(),

                SUBTYPES.GEOM2D);

            // This class has to use Envelope instead of Rectangle2D. This catch

            // will disappear

        } catch (CreateEnvelopeException e) {

            logger.error("Error creating the envelope");

        }

        return null;

    /**

     * <p>

     * Changes the <i>extent</i> and <i>adjusted extent</i> of this view port:<br>

     * <ul>

     * <li>Stores the previous extent.

     * <li>Calculates the new extent using <code>r</code>:

     * 

     * <pre>

     * extent =

     *     new Rectangle2D.Double(r.getMinX() - 0.1,

     *         r.getMinY() - 0.1,

     *         r.getWidth() + 0.2,

     *         r.getHeight() + 0.2);

     * </pre>

     * 

     * <li>Executes {@linkplain #calculateAffineTransform()}: getting the new

     * scale, adjusted extent, affine transformation between map and screen

     * coordinates, the real world coordinates equivalent to 1 pixel, and the

     * real world coordinates equivalent to 3 pixels.

     * <li>Notifies all {@link ViewPortListener ViewPortListener} registered

     * that the extent has changed.

     * </ul>

     * </p>

     * 

     * @param r

     *            the new extent

     * 

     * @see #getExtent()

     * @see #getExtents()

     * @see #calculateAffineTransform()

     * @see #setPreviousExtent()

     */

    public void setEnvelope(Envelope r) {

        Rectangle2D newExtent = null;

        // Esto comprueba que el extent no es de anchura o altura = "0"

        // y si es as� lo redimensiona.

        if (r != null) {

            if ((r.getMaximum(0) - r.getMinimum(0) == 0)

                || (r.getMaximum(1) - r.getMinimum(1) == 0)) {

                newExtent =

                    new Rectangle2D.Double(r.getMinimum(0) - 0.1,

                        r.getMinimum(1) - 0.1,

                        r.getMaximum(0) - r.getMinimum(0) + 0.2,

                        r.getMaximum(1) - r.getMinimum(1) + 0.2);

            } else {

                newExtent =

                    new Rectangle2D.Double(r.getMinimum(0),

                        r.getMinimum(1),

                        Math.abs(r.getMaximum(0) - r.getMinimum(0)),

                        Math.abs(r.getMaximum(1) - r.getMinimum(1)));

            }

        }

        if (this.extent != null && this.extent.equals(newExtent)) {

            return;

        }

        if (extent != null) {

            extents.put(extent);

        }

        this.updateDrawVersion();

        this.extent = newExtent;

        // Calcula la transformaci�n af�n

        calculateAffineTransform();

        // Lanzamos los eventos de extent cambiado

        callExtentChanged(getAdjustedExtent());

    /**

     * <p>

     * Changes the <i>extent</i> and <i>adjusted extent</i> of this view port:<br>

     * <ul>

     * <li>Executes {@linkplain #calculateAffineTransform()}: getting the new

     * scale, adjusted extent, affine transformation between map and screen

     * coordinates, the real world coordinates equivalent to 1 pixel, and the

     * real world coordinates equivalent to 3 pixels.

     * <li>Notifies to all {@link ViewPortListener ViewPortListener} registered

     * that the extent has changed.

     * </ul>

     * </p>

     * 

     * @see #setEnvelope(Envelope)

     * @see #calculateAffineTransform()

     */

    public void refreshExtent() {

        // this.scale = scale;

        // Calcula la transformaci�n af�n

        calculateAffineTransform();

        // Lanzamos los eventos de extent cambiado

        callExtentChanged(getAdjustedExtent());

    }

    /**

     * <p>

     * Calculates and returns using the current projection of this view port,

     * the scale that is the extent in <i>screen coordinates</i> from the image

     * in <i>map coordinates</i>.

     * </p>

     * 

     * @return the scale <i>extent / image size</i> projected by this view port

     * 

     * @deprecated since 07/09/07, use {@linkplain MapContext#getScaleView()}

     */

    private double getScale() {

        double[] trans2Meter = MapContext.getDistanceTrans2Meter();

        if (proj == null) {

            double wmeters = ((getImageSize().width / this.getDPI()) * 0.0254);

            return (long) (

                (trans2Meter[getMapUnits()] * getAdjustedEnvelope().getLength(0))

                / wmeters);

        } else {

            return Math.round(proj.getScale(

                getAdjustedEnvelope().getMinimum(0)*trans2Meter[getMapUnits()],

                getAdjustedEnvelope().getMaximum(0)*trans2Meter[getMapUnits()],

                getImageSize().width,

                this.getDPI()));

        }

        /*

        return proj.getScale(extent.getMinX(),

            extent.getMaxX(),

            imageSize.width,

            dpi);

        */

    /**

     * <p>

     * Affine transformation between <i>map 2D coordinates</i> to <i>screen 2D

     * coordinates</i> (pixels), preserving the "straightness" and "parallelism"

     * of the lines.

     * </p>

     * 

     * @return the affine transformation

     * 

     * @see #setAffineTransform(AffineTransform)

     * @see #calculateAffineTransform()

     */

    public AffineTransform getAffineTransform() {

        return trans;