Application: gvSIG desktop » gvSIG 3D

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-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 2

 * 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.view3d.swing.impl.data;

import gov.nasa.worldwind.WWObjectImpl;

import gov.nasa.worldwind.avlist.AVKey;

import gov.nasa.worldwind.avlist.AVList;

import gov.nasa.worldwind.data.BufferedImageRaster;

import gov.nasa.worldwind.data.DataRaster;

import gov.nasa.worldwind.geom.Sector;

import java.awt.Dimension;

import java.awt.Graphics2D;

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import java.awt.image.BufferedImage;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.exception.ReadException;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.layers.FLayer;

import org.gvsig.tools.task.Cancellable;

/**

 * @author <a href="mailto:lmarques@disid.com">Lluis Marques</a>

 *

 */

@SuppressWarnings("deprecation")

public class GvSIGLayerDataRaster extends WWObjectImpl implements DataRaster {

    private static final Logger LOG = LoggerFactory

        .getLogger(GvSIGLayerDataRaster.class);

    private MapContext mapContext;

    private FLayer layer;

    /**

     * 

     */

    public GvSIGLayerDataRaster(MapContext mapContext, FLayer theLayer,

        AVList params) {

        if (params == null || mapContext == null || theLayer == null) {

            throw new IllegalArgumentException();

        }

        this.layer = theLayer;

        this.mapContext = mapContext;

        this.setValues(params.copy());

    }

    public void dispose() {

        //TODO

    }

    public int getWidth() {

        return (Integer) this.getValue(AVKey.WIDTH);

    }

    public int getHeight() {

        return (Integer) this.getValue(AVKey.HEIGHT);

    }

    public Sector getSector() {

        return (Sector) this.getValue(AVKey.SECTOR);

    }

    public void drawOnTo(DataRaster canvas) {

        if (canvas == null) {

            throw new IllegalArgumentException();

        }

        if (!canvas.getSector().intersects(getSector())) {

            return;

        }

        Sector overlap = this.getSector().intersection(canvas.getSector());

        ViewPort viewPort = new ViewPort(mapContext.getProjection());

        // Set adjustable to false to avoid problems with adjusted envelope

        viewPort.setAdjustable(false);

        GeometryManager geoManager = GeometryLocator.getGeometryManager();

        Envelope envelope = null;

        double[] degrees = overlap.asDegreesArray();

        try {

            IProjection projection = layer.getProjection();

            if (projection == null) {

                projection = mapContext.getProjection();

            }

            ICoordTrans ct = CRSFactory.getCRS("EPSG:4326").getCT(projection);

            Point2D p1 = convert(ct, new Point2D.Double(degrees[2], degrees[0]));

            Point2D p2 = convert(ct, new Point2D.Double(degrees[3], degrees[1]));

            envelope =

                geoManager.createEnvelope(Math.min(p1.getX(), p2.getX()),

                    Math.min(p1.getY(), p2.getY()),

                    Math.max(p1.getX(), p2.getX()),

                    Math.max(p1.getY(), p2.getY()), SUBTYPES.GEOM2D);

            /**

             *  Check if request tile intersect with layer envelope to avoid

             *  the creation of useless tiles. 

             */

            if (!envelope.intersects(layer.getFullEnvelope())) {

                return;

            }

            viewPort.setEnvelope(envelope);

        } catch (CreateEnvelopeException e) {

            LOG.error(

                "Can't create envelope from sector tile:  minLat {} maxLat {} minLon {} maxLon {}",

                new Object[] { degrees[0], degrees[1], degrees[2], degrees[3] });

            return;

        } catch (ReadException e) {

            LOG.warn("Can't get full envelope of {}", layer.getInfoString());

        }

        int canvasWidth = canvas.getWidth();

        int canvasHeight = canvas.getHeight();

        java.awt.Rectangle clipRect = this.computeClipRect(overlap, this);

        if (null == clipRect || clipRect.width == 0 || clipRect.height == 0) {

            return;

        }

        // Apply the transform that correctly maps the image onto the canvas.

        java.awt.geom.AffineTransform affineTransform =

            this.computeSourceToDestTransform(clipRect.width, clipRect.height,

                overlap, canvasWidth, canvasHeight, canvas.getSector());

        // Trick to apply transform to size value

        Point2D srcSizePoint =

            new Point2D.Double(clipRect.width, clipRect.height);

        Point2D dstSizePoint = new Point2D.Double();

        affineTransform.transform(srcSizePoint, dstSizePoint);

        int clipWidth =

            (int) Math.ceil((dstSizePoint.getX() >= canvasWidth) ? canvasWidth

                : dstSizePoint.getX());

        int clipHeight =

            (int) Math.ceil((dstSizePoint.getY() >= canvasHeight)

                ? canvasHeight : dstSizePoint.getY());

        if (clipWidth <= 0 || clipHeight <= 0) {

            return;

        }

        BufferedImage image =

            new BufferedImage(clipWidth, clipHeight,

                BufferedImage.TYPE_INT_ARGB);

        viewPort.setImageSize(new Dimension(clipWidth, clipHeight));

        viewPort.refreshExtent();

        try {

            layer.draw(image, (Graphics2D) image.getGraphics(), viewPort,

                new Cancellable() {

                    private boolean canceled = false;

                    public void setCanceled(boolean flag) {

                        canceled = flag;

                    }

                    public boolean isCanceled() {

                        return canceled;

                    }

                }, getScale(viewPort));

        } catch (ReadException e) {

            LOG.warn(

                "Can't draw required zone of layer {}, can't read legend",

                layer.getInfoString());

            return;

        }

        BufferedImageRaster bufferedImageRaster =

            new BufferedImageRaster(overlap, image);

        bufferedImageRaster.drawOnTo(canvas);

    }

    private Point2D convert(ICoordTrans ct, Point2D srcPoint){

        if(ct == null){

            return srcPoint;

        }

        return ct.convert(srcPoint, null);

    }

    private java.awt.geom.AffineTransform computeSourceToDestTransform(

        int sourceWidth, int sourceHeight, Sector sourceSector, int destWidth,

        int destHeight, Sector destSector) {

        // Compute the the transform from source to destination coordinates. In

        // this computation a pixel is assumed

        // to cover a finite area.

        double ty =

            destHeight

                * -(sourceSector.getMaxLatitude().degrees - destSector

                    .getMaxLatitude().degrees)

                / destSector.getDeltaLatDegrees();

        double tx =

            destWidth

                * (sourceSector.getMinLongitude().degrees - destSector

                    .getMinLongitude().degrees)

                / destSector.getDeltaLonDegrees();

        double sy =

            ((double) destHeight / (double) sourceHeight)

                * (sourceSector.getDeltaLatDegrees() / destSector

                    .getDeltaLatDegrees());

        double sx =

            ((double) destWidth / (double) sourceWidth)

                * (sourceSector.getDeltaLonDegrees() / destSector

                    .getDeltaLonDegrees());

        java.awt.geom.AffineTransform transform =

            new java.awt.geom.AffineTransform();

        transform.translate(tx, ty);

        transform.scale(sx, sy);

        return transform;

    }

    private double getScale(ViewPort viewPort) {

        MapContext mapContextCloned = mapContext.cloneFMap();

        mapContextCloned.setViewPort(viewPort);

        double scale = mapContextCloned.getScaleView();

        mapContextCloned.dispose();

        return scale;

    }

    private Rectangle computeClipRect(Sector clipSector,

        DataRaster clippedRaster) {

        AffineTransform geographicToRaster =

            this.computeGeographicToRasterTransform(clippedRaster.getWidth(),

                clippedRaster.getHeight(), clippedRaster.getSector());

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

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

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

        geoPoint.setLocation(clipSector.getMinLongitude().degrees,

            clipSector.getMaxLatitude().degrees);

        geographicToRaster.transform(geoPoint, ul);

        geoPoint.setLocation(clipSector.getMaxLongitude().degrees,

            clipSector.getMinLatitude().degrees);

        geographicToRaster.transform(geoPoint, lr);

        int x = (int) Math.floor(ul.getX());

        int y = (int) Math.floor(ul.getY());

        int width = (int) Math.ceil(lr.getX() - ul.getX());

        int height = (int) Math.ceil(lr.getY() - ul.getY());

        return new Rectangle(x, y, width, height);

    }

    private java.awt.geom.AffineTransform computeGeographicToRasterTransform(

        int width, int height, Sector sector) {

        // Compute the the transform from geographic to raster coordinates. In

        // this computation a pixel is assumed

        // to cover a finite area.

        double ty = -sector.getMaxLatitude().degrees;

        double tx = -sector.getMinLongitude().degrees;

        double sy = -(height / sector.getDeltaLatDegrees());

        double sx = (width / sector.getDeltaLonDegrees());

        java.awt.geom.AffineTransform transform =

            new java.awt.geom.AffineTransform();

        transform.scale(sx, sy);

        transform.translate(tx, ty);

        return transform;

    }

    public DataRaster getSubRaster(AVList params) {

        int width = (Integer) params.getValue(AVKey.WIDTH);

        int height = (Integer) params.getValue(AVKey.HEIGHT);

        Sector sector = (Sector) params.getValue(AVKey.SECTOR);

        return this.getSubRaster(width, height, sector, params);

    }

    public DataRaster getSubRaster(int width, int height, Sector sector,

        AVList params) {

        params.setValue(AVKey.WIDTH, width);

        params.setValue(AVKey.HEIGHT, height);

        params.setValue(AVKey.SECTOR, sector);

        GvSIGLayerDataRaster subRaster =

            new GvSIGLayerDataRaster(mapContext, layer, params);

        return subRaster;

    }

}