Application: gvSIG desktop

package org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl;

import java.awt.Graphics2D;

import java.awt.geom.AffineTransform;

import java.awt.geom.PathIterator;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryException;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.aggregate.Aggregate;

import org.gvsig.fmap.geom.aggregate.MultiLine;

import org.gvsig.fmap.geom.aggregate.MultiPolygon;

import org.gvsig.fmap.geom.aggregate.MultiSurface;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.primitive.Curve;

import org.gvsig.fmap.geom.primitive.GeneralPathX;

import org.gvsig.fmap.geom.primitive.Surface;

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.rendering.symbols.CartographicSupport;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.tools.task.Cancellable;

public class DrawUtils {

    private static GeometryManager geometryManager = null;

    private static GeometryManager getGeometryManager() {

        if( geometryManager == null ) {

            geometryManager = GeometryLocator.getGeometryManager();

        }

        return geometryManager;

    }

    public static void drawInts(Graphics2D g, ViewPort viewPort, Cancellable cancel, double dpi, ISymbol symbol, Feature feature, Geometry geom) throws GeometryOperationException {

        try {

            if( geom instanceof Aggregate ) {

                for( Geometry prim : (Aggregate) geom ) {

                    drawInts(g, viewPort, cancel, dpi, symbol, feature, prim);

                }

                return;

            }

            double previousSize = ((CartographicSupport) symbol).toCartographicSize(viewPort, dpi, geom);

            // draw it as normally

            Geometry transformedGeometry;

            transformedGeometry = transformGeometry(geom.cloneGeometry(), viewPort.getAffineTransform());

            // the AffineTransform has to be null because the transformToInts method reprojects the geometry

            symbol.draw(g, null, transformedGeometry, feature, cancel);

            // restore previous size

            ((CartographicSupport) symbol).setCartographicSize(previousSize, geom);

        } catch (GeometryException e) {

            throw new GeometryOperationException(e);

        }

    }

    public static void drawInts(Graphics2D g, ViewPort viewPort, ISymbol symbol, Feature feature, Geometry geom) throws GeometryOperationException {

        try {

            if( geom instanceof Aggregate ) {

                for( Geometry prim : (Aggregate) geom ) {

                    drawInts(g, viewPort, symbol, feature, prim);

                }

                return;

            }

            Geometry transformedGeometry = transformGeometry(geom.cloneGeometry(), viewPort.getAffineTransform());

            symbol.draw(g, viewPort.getAffineTransform(), transformedGeometry, feature, null);

        } catch (GeometryException e) {

            throw new GeometryOperationException(e);

        }

    }

    /**

     * @param geom

     * @param affineTransform

     * @return

     * @throws GeometryException

     */

    private static Geometry transformGeometry(Geometry geom, AffineTransform affineTransform) throws GeometryException {

        if( geom.canBeTransformed(affineTransform) ) {

            geom.transform(affineTransform);

            return geom;

        }

        if( geom instanceof Curve || geom instanceof Curve ) {

            MultiLine lines = geom.toLines();

            lines.transform(affineTransform);

            return lines;

        }

        if( geom instanceof Surface || geom instanceof MultiSurface ) {

            MultiPolygon polygons = geom.toPolygons();

            polygons.transform(affineTransform);

            return polygons;

        }

        return null;

    }

    private static Geometry transformToInts(Geometry gp, AffineTransform at) throws CreateGeometryException {

        GeneralPathX newGp = new GeneralPathX();

        double[] theData = new double[6];

        double[] aux = new double[6];

        // newGp.reset();

        PathIterator theIterator;

        int theType;

        int numParts = 0;

        java.awt.geom.Point2D ptDst = new java.awt.geom.Point2D.Double();

        java.awt.geom.Point2D ptSrc = new java.awt.geom.Point2D.Double();

        boolean bFirst = true;

        int xInt, yInt, antX = -1, antY = -1;

        theIterator = gp.getPathIterator(null); //, flatness);

        int numSegmentsAdded = 0;

        while( !theIterator.isDone() ) {

            theType = theIterator.currentSegment(theData);

            switch( theType ) {

            case PathIterator.SEG_MOVETO:

                numParts++;

                ptSrc.setLocation(theData[0], theData[1]);

                at.transform(ptSrc, ptDst);

                antX = (int) ptDst.getX();

                antY = (int) ptDst.getY();

                newGp.moveTo(antX, antY);

                numSegmentsAdded++;

                bFirst = true;

                break;

            case PathIterator.SEG_LINETO:

                ptSrc.setLocation(theData[0], theData[1]);

                at.transform(ptSrc, ptDst);

                xInt = (int) ptDst.getX();

                yInt = (int) ptDst.getY();

                if( (bFirst) || ((xInt != antX) || (yInt != antY)) ) {

                    newGp.lineTo(xInt, yInt);

                    antX = xInt;

                    antY = yInt;

                    bFirst = false;

                    numSegmentsAdded++;

                }

                break;

            case PathIterator.SEG_QUADTO:

                at.transform(theData, 0, aux, 0, 2);

                newGp.quadTo(aux[0], aux[1], aux[2], aux[3]);

                numSegmentsAdded++;

                break;

            case PathIterator.SEG_CUBICTO:

                at.transform(theData, 0, aux, 0, 3);

                newGp.curveTo(aux[0], aux[1], aux[2], aux[3], aux[4], aux[5]);

                numSegmentsAdded++;

                break;

            case PathIterator.SEG_CLOSE:

                if( numSegmentsAdded < 3 ) {

                    newGp.lineTo(antX, antY);

                }

                newGp.closePath();

                break;

            } //end switch

            theIterator.next();

        } //end while loop

        Geometry geom = null;

        GeometryType geometryType = gp.getGeometryType();

        if( geometryType.isTypeOf(Geometry.TYPES.POINT) ) {

            geom = getGeometryManager().createPoint(ptDst.getX(), ptDst.getY(), Geometry.SUBTYPES.GEOM2D);

        } else if( geometryType.isTypeOf(Geometry.TYPES.MULTIPOINT) ) {

            geom = getGeometryManager().createMultiPoint(newGp, Geometry.SUBTYPES.GEOM2D);

        } else if( geometryType.isTypeOf(Geometry.TYPES.CURVE) ) {

            geom = getGeometryManager().createCurve(newGp, Geometry.SUBTYPES.GEOM2D);

        } else if( geometryType.isTypeOf(Geometry.TYPES.MULTICURVE) ) {

            geom = getGeometryManager().createMultiCurve(newGp, Geometry.SUBTYPES.GEOM2D);

        } else if( geometryType.isTypeOf(Geometry.TYPES.SURFACE) ) {

            geom = getGeometryManager().createSurface(newGp, Geometry.SUBTYPES.GEOM2D);

        } else if( geometryType.isTypeOf(Geometry.TYPES.MULTISURFACE) ) {

            geom = getGeometryManager().createMultiSurface(newGp, Geometry.SUBTYPES.GEOM2D);

        }

        return geom;

    }

}