Application: gvSIG desktop » gvSIG 3D

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2017 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.lib.impl.loader.rasterelevation;

import gov.nasa.worldwind.avlist.AVKey;

import gov.nasa.worldwind.avlist.AVList;

import gov.nasa.worldwind.avlist.AVListImpl;

import gov.nasa.worldwind.geom.Angle;

import gov.nasa.worldwind.geom.LatLon;

import gov.nasa.worldwind.geom.Sector;

import gov.nasa.worldwind.layers.TiledImageLayer;

import gov.nasa.worldwind.util.WWMath;

import java.awt.geom.Point2D;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.DataStoreParameters;

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

import org.gvsig.fmap.dal.coverage.grid.render.VisualPropertyListener;

import org.gvsig.fmap.dal.coverage.store.props.Statistics;

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

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

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.exceptions.LoadLayerException;

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

import org.gvsig.fmap.mapcontext.layers.operations.SingleLayer;

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

import org.gvsig.fmap.mapcontext.rendering.legend.IVectorLegend;

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

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

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

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

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

import org.gvsig.view3d.lib.api.exception.LoadException;

import org.gvsig.view3d.lib.api.loader.Loader;

import org.gvsig.view3d.lib.api.loader.LoaderParameters;

import org.gvsig.view3d.lib.impl.DefaultElevationModel;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.w3c.dom.Document;

/**

 * 

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

 *

 */

public class DefaultRasterElevationLoader implements Loader {

    private static final Logger LOG = LoggerFactory.getLogger(DefaultRasterElevationLoader.class);

    @Override

    public Object load(LoaderParameters parameters) throws LoadException {

        if (!(parameters instanceof DefaultRasterElevationLoaderParameters)) {

            throw new IllegalArgumentException(

                "Illegal parameters, it must be an instance of RasterElevationLoaderParameters");

        }

        DefaultRasterElevationLoaderParameters rasterElevationParameters =

            (DefaultRasterElevationLoaderParameters) parameters;

        FLayer layer = (FLayer) rasterElevationParameters.getLayer();

        IProjection projectionLayer = layer.getProjection();

        if (!projectionLayer.equals(CRSFactory.getCRS("ESPG:4326"))) {

            try {

                layer = createNewProjectedOnTheFlyLayer(layer, projectionLayer);

            } catch (LoadLayerException e) {

                // throw new

                // ConversionLayerException("Can not create layer and set"

                // + " project on the fly configuration", e);

            }

        }

        AVList params = new AVListImpl();

        // Add Layer and MapContext to parameters.

        params.setValue(View3DManager.GVSIG_LAYER, layer);

        params.setValue(AVKey.DATASET_NAME, layer.getName());

        params.setValue(AVKey.DATA_CACHE_NAME, getUniqueCacheId(layer));

        params.setValue(AVKey.DISPLAY_NAME, layer.getName());

        params.setValue(AVKey.SERVICE_NAME, "Offline");

        Sector sector = null;

        try {

            sector = getSector(layer);

        } catch (DataException e) {

            LOG.error("Can't create sector from {} layer", new Object[] { layer }, e);

            throw new LoadException(layer.getName(), e);

        }

        params.setValue(AVKey.SECTOR, sector);

        if (layer instanceof FLyrRaster) {

            FLyrRaster rasterLayer = (FLyrRaster) layer;

            int[] dataType = rasterLayer.getDataStore().getDataType();

            switch (dataType[0]) {

            case Buffer.TYPE_BYTE:

                params.setValue(AVKey.DATA_TYPE, AVKey.INT8);

                break;

            case Buffer.TYPE_SHORT:

            case Buffer.TYPE_USHORT:

                params.setValue(AVKey.DATA_TYPE, AVKey.INT16);

                break;

            case Buffer.TYPE_INT:

                params.setValue(AVKey.DATA_TYPE, AVKey.INT32);

                break;

            case Buffer.TYPE_FLOAT:

                params.setValue(AVKey.DATA_TYPE, AVKey.FLOAT32);

                break;

            case Buffer.TYPE_DOUBLE:

                params.setValue(AVKey.DATA_TYPE, AVKey.FLOAT64);

                break;

            case Buffer.TYPE_UNDEFINED:

            default:

                // throw new UnsupportedDataTypeException(String.format(

                // "Unsupported buffer data type %1s", dataType[0]));

            }

            params.setValue(AVKey.WIDTH, (int) rasterLayer.getDataStore().getWidth());

            params.setValue(AVKey.HEIGHT, (int) rasterLayer.getDataStore().getHeight());

            Statistics statistics = rasterLayer.getDataStore().getStatistics();

            params.setValue(AVKey.ELEVATION_MIN, statistics.getMin()[0]);

            params.setValue(AVKey.ELEVATION_MAX, statistics.getMax()[0]);

        }

        params.setValue(AVKey.PIXEL_FORMAT, AVKey.ELEVATION);

        params.setValue(AVKey.IMAGE_FORMAT, "application/bil32");

        params.setValue(AVKey.MISSING_DATA_SIGNAL, rasterElevationParameters.getNoData());

        params.setValue(AVKey.ELEVATION_UNIT, rasterElevationParameters.getElevationUnits());

        params.setValue(AVKey.BYTE_ORDER, AVKey.LITTLE_ENDIAN);

        params.setValue(AVKey.AVAILABLE_IMAGE_FORMATS,

            new String[] { params.getValue(AVKey.IMAGE_FORMAT).toString() });

        params.setValue(AVKey.TILE_ORIGIN,

            new LatLon(sector.getMinLatitude(), sector.getMinLongitude()));

        // If tile sizes are 0, set default values

        params.setValue(AVKey.TILE_WIDTH, rasterElevationParameters.getTileSize());

        params.setValue(AVKey.TILE_HEIGHT, rasterElevationParameters.getTileSize());

        int numLevels;

        // If detail levels are 0, compute best level of detail number

        if (rasterElevationParameters.getMinLevel() == 0

            && rasterElevationParameters.getMaxLevel() == 0) {

            LatLon rasterTileDelta = this.computeRasterTileDelta(params);

            LatLon desiredLevelZeroDelta = this.computeDesiredTileDelta(sector);

            numLevels = computeNumLevels(desiredLevelZeroDelta, rasterTileDelta);

        } else {

            numLevels =

                rasterElevationParameters.getMaxLevel() - rasterElevationParameters.getMinLevel();

            params.setValue(AVKey.NUM_EMPTY_LEVELS, rasterElevationParameters.getMinLevel());

        }

        params.setValue(AVKey.NUM_LEVELS, numLevels);

        LatLon rasterTileDelta = this.computeRasterTileDelta(params);

        double scale = Math.pow(2d, numLevels - 1);

        LatLon levelZeroTileDelta =

            LatLon.fromDegrees(

                scale * rasterElevationParameters.getLevelZeroResolution()

                    * rasterTileDelta.getLatitude().degrees,

                scale * rasterElevationParameters.getLevelZeroResolution()

                    * rasterTileDelta.getLongitude().degrees);

        params.setValue(AVKey.LEVEL_ZERO_TILE_DELTA, levelZeroTileDelta);

        // Create configuration document from parameters.

        Document doc = TiledImageLayer.createTiledImageLayerConfigDocument(params);

        // Copy parameters to avoid problems

        AVList paramsLayer = params.copy();

        DefaultElevationModel elevationModel =

            new DefaultElevationModel(doc.getDocumentElement(), paramsLayer);

        return elevationModel;

    }

    private FLayer createNewProjectedOnTheFlyLayer(FLayer layer, IProjection projectionLayer)

        throws LoadLayerException {

        FLayer newLayer = null;

        DataStoreParameters parameters = null;

        if (layer instanceof FLyrVect) {

            FLyrVect layerVect = (FLyrVect) layer;

            parameters = layerVect.getFeatureStore().getParameters();

        } else if (layer instanceof FLyrRaster) {

            FLyrRaster layerRaster = (FLyrRaster) layer;

            parameters = layerRaster.getDataStore().getParameters();

        }

        newLayer =

            MapContextLocator.getMapContextManager().createLayer(layer.getName(), parameters);

        newLayer.setCoordTrans(projectionLayer.getCT(CRSFactory.getCRS("EPSG:4326")));

        // Set the same legend/render to new layer

        if (newLayer instanceof FLyrVect) {

            ((FLyrVect) newLayer).setLegend((IVectorLegend) ((FLyrVect) layer).getLegend());

        } else if (newLayer instanceof FLyrRaster) {

            // Set layer initialized and opened to avoid render configurations

            // changes

            FLyrRaster rasterLayer = (FLyrRaster) newLayer;

            rasterLayer.setLayerInitialized(true);

            if (rasterLayer instanceof ILayerState) {

                try {

                    ((ILayerState) rasterLayer).enableOpen();

                } catch (NotAvailableStateException e) {

                    throw new LoadLayerException(rasterLayer.getName(), e);

                }

            }

            rasterLayer.getDataStore().setRender(((FLyrRaster) layer).getRender());

            // Add layer to listen visual property changes. This is necessary

            // because we are initializing layer manually to avoid render

            // filters changes.

            if (rasterLayer instanceof VisualPropertyListener) {

                rasterLayer.getRender().addVisualPropertyListener(

                    (VisualPropertyListener) rasterLayer);

            }

        }

        View3DManager manager = View3DLocator.getManager();

        LoaderParameters loaderParameters = manager.getLoaderParameters(layer);

        manager.setLoaderParameters(newLayer, loaderParameters);

        return newLayer;

    }

    private String getUniqueCacheId(FLayer layer) {

        // TODO This is not valid. We have to take in account more properties

        // to get unique cache id

        try {

            // Create MD5 Hash

            MessageDigest digest = java.security.MessageDigest.getInstance("MD5");

            String name = layer.getName();

            long drawVersion = layer.getDrawVersion();

            String dataStoreFullName = null;

            if (layer instanceof SingleLayer) {

                dataStoreFullName = ((SingleLayer) layer).getDataStore().getFullName();

            }

            int hashCode = layer.hashCode();

            StringBuilder stb = new StringBuilder();

            stb.append(name);

            stb.append("$");

            stb.append(drawVersion);

            stb.append("$");

            stb.append(hashCode);

            stb.append("$");

            if (dataStoreFullName != null) {

                stb.append(dataStoreFullName);

                stb.append("$");

            }

            String id = stb.toString();

            digest.update(id.getBytes());

            byte messageDigest[] = digest.digest();

            // Create Hex String

            StringBuilder hexString = new StringBuilder();

            hexString.append(layer.getName());

            hexString.append("-");

            for (int i = 0; i < messageDigest.length; i++)

                hexString.append(Integer.toHexString(0xFF & messageDigest[i]));

            return hexString.toString();

        } catch (NoSuchAlgorithmException e) {

            LOG.warn("MD5 algorith is not available", e);

            String name = layer.getName();

            long drawVersion = layer.getDrawVersion();

            String dataStoreFullName = null;

            if (layer instanceof SingleLayer) {

                dataStoreFullName = ((SingleLayer) layer).getDataStore().getFullName();

            }

            int hashCode = layer.hashCode();

            StringBuilder stb = new StringBuilder();

            stb.append(name);

            stb.append("$");

            stb.append(drawVersion);

            stb.append("$");

            stb.append(hashCode);

            stb.append("$");

            if (dataStoreFullName != null) {

                stb.append(dataStoreFullName);

                stb.append("$");

            }

            return stb.toString();

        }

    }

    private Sector getSector(FLayer layer) throws DataException {

        Point2D p1 = null;

        Point2D p2 = null;

        Envelope envelope = layer.getFullEnvelope();

        p1 = new Point2D.Double(envelope.getMinimum(0), envelope.getMinimum(1));

        p2 = new Point2D.Double(envelope.getMaximum(0), envelope.getMaximum(1));

        double minLatitude =

            Double.isInfinite(p1.getY()) || p1.getY() < Angle.NEG90.degrees ? Angle.NEG90.degrees

                : p1.getY();

        double maxLatitude =

            Double.isInfinite(p2.getY()) || p2.getY() > Angle.POS90.degrees ? Angle.POS90.degrees

                : p2.getY();

        double minLongitude =

            Double.isInfinite(p1.getX()) || p1.getX() < Angle.NEG180.degrees ? Angle.NEG180.degrees

                : p1.getX();

        double maxLongitude =

            Double.isInfinite(p2.getX()) || p2.getX() > Angle.POS180.degrees ? Angle.POS180.degrees

                : p2.getX();

        Sector sector =

            new Sector(Sector.fromDegrees(minLatitude, maxLatitude, minLongitude, maxLongitude));

        return sector;

    }

    private int computeNumLevels(LatLon levelZeroDelta, LatLon lastLevelDelta) {

        // Compute the number of levels needed to achieve the given last level

        // tile delta, starting from the given

        // level zero tile delta.

        double numLatLevels =

            WWMath.logBase2(levelZeroDelta.getLatitude().getDegrees())

                - WWMath.logBase2(lastLevelDelta.getLatitude().getDegrees());

        double numLonLevels =

            WWMath.logBase2(levelZeroDelta.getLongitude().getDegrees())

                - WWMath.logBase2(lastLevelDelta.getLongitude().getDegrees());

        // Compute the maximum number of levels needed, but limit the number of

        // levels to positive integers greater

        // than or equal to one.

        int numLevels = (int) Math.ceil(Math.max(numLatLevels, numLonLevels));

        if (numLevels < 1)

            numLevels = 1;

        return numLevels;

    }

    private LatLon computeRasterTileDelta(AVList parameters) {

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

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

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

        int tileWidth = (Integer) parameters.getValue(AVKey.TILE_WIDTH);

        int tileHeight = (Integer) parameters.getValue(AVKey.TILE_HEIGHT);

        LatLon pixelSize = this.computeRasterPixelSize(sector, width, height);

        // Compute the tile size in latitude and longitude, given a raster's

        // sector and dimension, and the tile

        // dimensions. In this computation a pixel is assumed to cover a finite

        // area.

        double latDelta = tileHeight * pixelSize.getLatitude().degrees;

        double lonDelta = tileWidth * pixelSize.getLongitude().degrees;

        return LatLon.fromDegrees(latDelta, lonDelta);

    }

    private LatLon computeRasterPixelSize(Sector sector, int width, int height) {

        // Compute the raster's pixel dimension in latitude and longitude. In

        // this computation a pixel is assumed to

        // cover a finite area.

        return LatLon.fromDegrees(sector.getDeltaLatDegrees() / height, sector.getDeltaLonDegrees()

            / width);

    }

    private LatLon computeDesiredTileDelta(Sector sector) {

        return LatLon.fromDegrees(sector.getDeltaLatDegrees(), sector.getDeltaLonDegrees());

    }

}