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.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.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.coverage.store.RasterDataStore;

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.fmap.mapcontext.layers.vectorial.FLyrVect;

import org.gvsig.raster.fmap.layers.FLyrRaster;

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 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() {

    }

    public int getWidth() {

        if (this.getValue(AVKey.WIDTH) == null) {

            if (layer instanceof FLyrRaster) {

                FLyrRaster rasterLayer = (FLyrRaster) layer;

                RasterDataStore dataStore = rasterLayer.getDataStore();

                return (int) dataStore.getWidth();

            }

            if (layer instanceof FLyrVect) {

                // TODO

            }

        }

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

    }

    public int getHeight() {

        if (this.getValue(AVKey.HEIGHT) == null) {

            if (layer instanceof FLyrRaster) {

                FLyrRaster rasterLayer = (FLyrRaster) layer;

                RasterDataStore dataStore = rasterLayer.getDataStore();

                return (int) dataStore.getHeight();

            }

            if (layer instanceof FLyrVect) {

                // TODO

            }

        }

        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();

        }

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

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

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

            return;

        }

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

        GeometryManager geoManager = GeometryLocator.getGeometryManager();

        Envelope envelope = null;

        try {

            double[] points = overlap.asDegreesArray();

            IProjection projection = layer.getProjection();

            if (projection == null) {

                projection = mapContext.getProjection();

            }

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

            Point2D p1 =

                ct.convert(new Point2D.Double(points[2], points[0]), null);

            Point2D p2 =

                ct.convert(new Point2D.Double(points[3], points[1]), null);

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

        } catch (CreateEnvelopeException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        viewPort.setEnvelope(envelope);

        viewPort.setImageSize(clipRect.getSize());

        BufferedImage image =

            new BufferedImage((int) clipRect.getWidth(),

                (int) clipRect.getHeight(), BufferedImage.TYPE_INT_ARGB);

        try {

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

                new Cancellable() {

                    public void setCanceled(boolean canceled) {

                        // TODO Auto-generated method stub

                    }

                    public boolean isCanceled() {

                        // TODO Auto-generated method stub

                        return false;

                    }

                }, getScale(viewPort));

        } catch (ReadException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        BufferedImageRaster bufferedImageRaster =

            new BufferedImageRaster(overlap, image);

        bufferedImageRaster.drawOnTo(canvas);

    }

    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;

    }

}