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.ByteBufferRaster;

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.geom.Rectangle2D;

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.RasterLocator;

import org.gvsig.fmap.dal.coverage.RasterManager;

import org.gvsig.fmap.dal.coverage.dataset.Buffer;

import org.gvsig.fmap.dal.coverage.datastruct.DataStructFactory;

import org.gvsig.fmap.dal.coverage.datastruct.Extent;

import org.gvsig.fmap.dal.coverage.exception.ProcessInterruptedException;

import org.gvsig.fmap.dal.coverage.exception.QueryException;

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

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

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.fmap.mapcontext.rendering.legend.styling.ILabelable;

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

import org.gvsig.view3d.lib.api.View3DLocator;

import org.gvsig.view3d.lib.api.View3DManager;

import org.gvsig.view3d.lib.api.properties.ElevationLayerProperties3D;

import org.gvsig.view3d.lib.api.properties.LayerProperties3D;

import org.gvsig.view3d.swing.api.MapControl3D;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Default implementation of {@link DataRaster}.

 * 

 * @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 MapControl3D mapControl3D;

    private FLayer layer;

    private Extent canvasExtent;

    private Extent overlapExtent;

    /**

     * Default constructor of <code>GvSIGLayerDataRaster</code>

     * 

     * @param mapControl3D

     *            context where {@link FLayer} is loaded.

     * @param theLayer

     *            source to get raster information

     * @param params

     *            parameters of <code>GvSIGLayerDataRaster</code>

     */

    public GvSIGLayerDataRaster(MapControl3D mapControl3D, FLayer theLayer,

        AVList params) {

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

            throw new IllegalArgumentException();

        }

        this.layer = theLayer;

        this.mapControl3D = mapControl3D;

        this.setValues(params.copy());

    }

    public void dispose() {

    }

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

        View3DManager manager = View3DLocator.getManager();

        LayerProperties3D properties = manager.getLayerProperties(layer, null);

        if (properties instanceof ElevationLayerProperties3D) {

            if (this.layer instanceof FLyrRaster) {

                this.drawRasterElevationOnTo(canvas);

            } else if (this.layer instanceof FLyrVect) {

                this.drawVectElevationOnTo(canvas);

            }

        } else {

            this.drawImageOnTo(canvas);

        }

    }

    private void drawRasterElevationOnTo(DataRaster canvas) {

        if (canvas == null) {

            throw new IllegalArgumentException();

        }

        if (!(this.layer instanceof FLyrRaster)

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

            return;

        }

        Extent canvasExtent = getExtent(canvas.getSector());

        // Create query. Configure to get the zone request by canvas scaled to

        // tile size.

        RasterQuery query = RasterLocator.getManager().createQuery();

        query.setSupersamplingOption(false);

        query.setDrawableBands(new int[] { 0 });

        query.setReadOnly(true);

        query.storeLastBuffer(true);

        query.setAreaOfInterest(canvasExtent, canvas.getWidth(),

            canvas.getHeight());

        Buffer adjustedBuffer = null;

        FLyrRaster rasterLayer = (FLyrRaster) this.layer;

        RasterDataStore dataStore = rasterLayer.getDataStore();

        try {

            // For best performance, checks if canvas extent is the same than

            // last request. If it is the same, it will get last buffer

            // stored. Otherwise, it will do created query.

            if (canvasExtent.equals(this.canvasExtent)

                && dataStore.getLastBuffer() != null) {

                adjustedBuffer = dataStore.getLastBuffer();

            } else {

                adjustedBuffer = dataStore.query(query);

            }

        } catch (ProcessInterruptedException e) {

            LOG.error("Process interrupted while {} was executing a query",

                dataStore.getName(), e);

            return;

        } catch (QueryException e) {

            LOG.error("Query exception, can apply {} to {}",

                new Object[] { query.toString(), dataStore.getName() }, e);

            return;

        }

        // For performance reasons, stores canvas extent to avoid calculate it

        // in each iteration

        setCanvasEnxent(canvas.getSector());

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

        setOverlapExtent(overlap);

        String dataType = this.getStringValue(AVKey.DATA_TYPE);

        for (int y = 0; y < canvas.getHeight(); y++) {

            for (int x = 0; x < canvas.getWidth(); x++) {

                Point2D rasterPoint =

                    getRasterPoint(x, y, canvas, adjustedBuffer);

                // If raster point is not null, get value of buffer and write it

                // to canvas

                if (rasterPoint != null) {

                    if (AVKey.INT8.equals(dataType)) {

                        byte byteValue =

                            adjustedBuffer.getElemByte((int) rasterPoint.getY(),

                                (int) rasterPoint.getX(), 0);

                        setNumberToDataRaster((ByteBufferRaster) canvas, y, x,

                            byteValue);

                    } else if (AVKey.INT16.equals(dataType)) {

                        short shortValue = adjustedBuffer.getElemShort(

                            (int) rasterPoint.getY(), (int) rasterPoint.getX(),

                            0);

                        setNumberToDataRaster((ByteBufferRaster) canvas, y, x,

                            shortValue);

                    } else if (AVKey.INT32.equals(dataType)) {

                        int intValue =

                            adjustedBuffer.getElemInt((int) rasterPoint.getY(),

                                (int) rasterPoint.getX(), 0);

                        setNumberToDataRaster((ByteBufferRaster) canvas, y, x,

                            intValue);

                    } else if (AVKey.FLOAT32.equals(dataType)) {

                        float floatValue = adjustedBuffer.getElemFloat(

                            (int) rasterPoint.getY(), (int) rasterPoint.getX(),

                            0);

                        setNumberToDataRaster((ByteBufferRaster) canvas, y, x,

                            floatValue);

                    } else if (AVKey.FLOAT64.equals(dataType)) {

                        double doubleValue = adjustedBuffer.getElemDouble(

                            (int) rasterPoint.getY(), (int) rasterPoint.getX(),

                            0);

                        setNumberToDataRaster((ByteBufferRaster) canvas, y, x,

                            doubleValue);

                    }

                } else {

                    // Invalid point, write NoData value

                    Number noData =

                        (Number) this.getValue(AVKey.MISSING_DATA_SIGNAL);

                    if (AVKey.INT8.equals(dataType)) {

                        setNumberToDataRaster((ByteBufferRaster) canvas, y, x,

                            noData.byteValue());

                    } else if (AVKey.INT16.equals(dataType)) {

                        setNumberToDataRaster((ByteBufferRaster) canvas, y, x,

                            noData.shortValue());

                    } else if (AVKey.INT32.equals(dataType)) {

                        setNumberToDataRaster((ByteBufferRaster) canvas, y, x,

                            noData.intValue());

                    } else if (AVKey.FLOAT32.equals(dataType)) {

                        setNumberToDataRaster((ByteBufferRaster) canvas, y, x,

                            noData.floatValue());

                    } else if (AVKey.FLOAT64.equals(dataType)) {

                        setNumberToDataRaster((ByteBufferRaster) canvas, y, x,

                            noData.doubleValue());

                    }

                }

            }

        }

    }

    private Point2D getRasterPoint(int x, int y, DataRaster canvas,

        Buffer adjustedBuffer) {

        // Gets coordiantes of pixel raster

        Point2D worldPoint =

            canvasExtent.rasterToWorld(new Point2D.Double(x, y),

                getCellSize(canvas.getSector(), canvas.getWidth()));

        if (layer instanceof FLyrRaster) {

            // Gets pixel of adjusted buffer

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

            Point2D rasterPoint = overlapExtent.worldToRaster(worldPoint,

                getCellSize(overlap, adjustedBuffer.getWidth()));

            if (isPointOfBuffer(rasterPoint, adjustedBuffer)) {

                return rasterPoint;

            }

        }

        return null;

    }

    private void setCanvasEnxent(Sector canvasSector) {

        this.canvasExtent = getExtent(canvasSector);

    }

    private void setOverlapExtent(Sector overlap) {

        this.overlapExtent = getExtent(overlap);

    }

    private Extent getExtent(Sector sector) {

        Rectangle2D rectangleDegrees = sector.toRectangleDegrees();

        RasterManager rasterManager = RasterLocator.getManager();

        DataStructFactory dataStructFactory =

            rasterManager.getDataStructFactory();

        return dataStructFactory.createExtent(rectangleDegrees);

    }

    private double getCellSize(Sector sector, int width) {

        Rectangle2D rectangleDegrees = sector.toRectangleDegrees();

        return rectangleDegrees.getWidth() / width;

    }

    private boolean isPointOfBuffer(Point2D rasterPoint, Buffer buffer) {

        if (layer instanceof FLyrRaster) {

            double x = rasterPoint.getX();

            double y = rasterPoint.getY();

            return x > -1 && y > -1 && x < buffer.getWidth()

                && y < buffer.getHeight() ? true : false;

        }

        return false;

    }

    private void setNumberToDataRaster(ByteBufferRaster byteBuferRaster,

        int line, int col, Number value) {

        byteBuferRaster.setDoubleAtPosition(line, col, value.doubleValue());

    }

    private void drawVectElevationOnTo(DataRaster canvas) {

        // TODO Auto-generated method stub

    }

    private void drawImageOnTo(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(mapControl3D.getMapContext().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 =

                mapControl3D.getMapContext().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.getName());

        }

        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,

                mapControl3D.getCancellable(), getScale(viewPort));

            if (layer instanceof FLyrVect && layer instanceof ILabelable) {

                ILabelable labelable = (ILabelable) layer;

                if (labelable.isLabeled()

                    && labelable.getLabelingStrategy() != null

                    && labelable.getLabelingStrategy()

                        .shouldDrawLabels(getScale(viewPort))) {

                    labelable.drawLabels(image,

                        (Graphics2D) image.getGraphics(), viewPort,

                        mapControl3D.getCancellable(), getScale(viewPort),

                        mapControl3D.getMapContext().getViewPort().getDPI());

                }

            }

        } catch (ReadException e) {

            LOG.warn("Can't draw required zone of layer {}, can't read legend",

                layer.getName());

            return;

        } finally {

            if (mapControl3D.getCancellable().isCanceled()) {

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

        double dpi = viewPort.getDPI();

        IProjection proj = viewPort.getProjection();

        if (viewPort.getImageSize() == null) {

            return -1;

        }

        if (viewPort.getAdjustedEnvelope() == null) {

            return 0;

        }

        double[] trans2Meter = MapContext.getDistanceTrans2Meter();

        int mUnits = viewPort.getMapUnits();

        if (proj == null) {

            double w = ((viewPort.getImageSize().width / dpi) * 0.0254);

            return (long) (viewPort.getAdjustedEnvelope().getLength(0) / w

                * trans2Meter[mUnits]);

        }

        return Math.round(proj.getScale(

            viewPort.getAdjustedEnvelope().getMinimum(0) * trans2Meter[mUnits],

            viewPort.getAdjustedEnvelope().getMaximum(0) * trans2Meter[mUnits],

            viewPort.getImageSize().width, dpi));

    }

    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(mapControl3D, layer, params);

        return subRaster;

    }

}