Application: gvSIG desktop

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

import java.awt.Graphics2D;

import java.awt.geom.AffineTransform;

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.operation.GeometryOperationException;

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

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

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;

            }

            ((CartographicSupport) symbol).setCartographicContext(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);

        } 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;

//    }

}