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

import gov.nasa.worldwind.data.BufferedImageRaster;

import gov.nasa.worldwind.data.DataRaster;

import gov.nasa.worldwind.geom.Sector;

import gov.nasa.worldwind.util.BufferWrapper;

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 java.nio.ByteBuffer;

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.dataset.Buffer;

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

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

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

    /**

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

        if (properties.getElevation() == true) {

            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;

        }

        FLyrRaster rasterLayer = (FLyrRaster) this.layer;

        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;

        }

        LOG.debug("Request zone: x = {} y= {} width = {} height = {}",

            new Object[] { clipRect.x, clipRect.y, clipRect.width,

                clipRect.height });

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

        query.setSupersamplingOption(false);

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

        query.setReadOnly(true);

        query.setAreaOfInterest(clipRect);

        Buffer buffer = null;

        try {

            buffer = rasterLayer.getDataStore().query(query);

        } catch (ProcessInterruptedException e) {

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

                rasterLayer.getDataStore().getName(), e);

            return;

        } catch (QueryException e) {

            LOG.error("Query exception, can apply {} to {}", new Object[] {

                query.toString(), rasterLayer.getDataStore().getName() }, e);

            return;

        }

        // Create buffer depending on data type

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

        int bytesNumber = getBytesNumber(dataType);

        ByteBuffer byteBuffer =

            ByteBuffer.allocate(buffer.getWidth() * buffer.getHeight()

                * bytesNumber);

        LOG.debug("Start iterator buffer");

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < buffer.getHeight(); i++) {

            for (int j = 0; j < buffer.getWidth(); j++) {

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

                    byte elemByte = buffer.getElemByte(i, j, 0);

                    byteBuffer.put(elemByte);

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

                    short elemShort = buffer.getElemShort(i, j, 0);

                    byteBuffer.putShort(elemShort);

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

                    int elemInteger = buffer.getElemInt(i, j, 0);

                    byteBuffer.putInt(elemInteger);

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

                    float elemFloat = buffer.getElemFloat(i, j, 0);

                    byteBuffer.putFloat(elemFloat);

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

                    double elemDouble = buffer.getElemDouble(i, j, 0);

                    byteBuffer.putDouble(elemDouble);

                }

            }

        }

        LOG.debug("Finish iterator buffer. Time {}", System.currentTimeMillis()

            - startTime);

        byteBuffer.position(0);

        BufferWrapper wrap = BufferWrapper.wrap(byteBuffer, this.copy());

        BufferWrapperRaster bufferWrapper =

            new BufferWrapperRaster(buffer.getWidth(), buffer.getHeight(),

                overlap, wrap, this.copy());

        bufferWrapper.drawOnTo(canvas);

    }

    private void drawVectElevationOnTo(DataRaster canvas) {

        // TODO Auto-generated method stub

    }

    private int getBytesNumber(String dataType) {

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

            return 1;

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

            return 2;

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

            || AVKey.FLOAT32.equals(dataType)) {

            return 4;

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

            return 8;

        }

        return 1;

    }

    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;

    }

}