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

import java.awt.geom.Point2D;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

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

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

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

import org.gvsig.view3d.lib.impl.layers.properties.DefaultElevationLayerProperties3D;

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

import org.gvsig.view3d.swing.api.exceptions.ConversionLayerException;

import org.gvsig.view3d.swing.api.properties.NwwRasterLoaderFactory;

import org.gvsig.view3d.swing.impl.DefaultMapControl3D;

import org.gvsig.view3d.swing.impl.layers.loaders.ElevationLayerLoaderFactory;

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

import gov.nasa.worldwind.layers.Layer;

import gov.nasa.worldwind.terrain.BasicElevationModel;

import gov.nasa.worldwind.util.WWMath;

/**

 * Default implementation of {@link LayerConverter}.

 *

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

 */

public class DefaultLayerConverter implements LayerConverter {

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

    private final int DEFAULT_RASTERIZED_LEVEL_ZERO = 20;

    private final int DEFAULT_TILE_WIDTH = 512;

    private final int DEFAULT_TILE_HEIGHT = 512;

    private View3DManager manager = View3DLocator.getManager();

    public Layer convertToLayer(MapControl3D mapControl, FLayer layer) throws ConversionLayerException {

        IProjection projectionLayer = layer.getProjection();

        if(projectionLayer == null){

            projectionLayer = mapControl.getMapContext().getProjection();

        }

        if (layer.getCoordTrans() != null) {

            // Create new layer and configure it to be drawn projected on the fly

            try {

                layer = createNewProjectedOnTheFlyLayer(layer, projectionLayer);

            } catch (LoadLayerException e) {

                throw new ConversionLayerException("Can not create layer and set"

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

            }

        }

        //De aqu? hasta el final de m?todo lo que ten?a Andrea

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

        NwwLoaderFactory loadingFactory = manager.getLayerLoadingFactory(layer);

        if (loadingFactory instanceof NwwRasterLoaderFactory) {

            NwwRasterLoaderFactory rasterLoaderFactory = (NwwRasterLoaderFactory) loadingFactory;

            rasterLoaderFactory.setMapControl(mapControl);

        }

        Layer nwwLayer = loadingFactory.loadLayer(layerProperties);

        return nwwLayer;

    }

    public ElevationModel convertToElevationModel(MapControl3D mapControl, FLayer layer) {

        //FIXME:

        // Este m?todo lo ha tenido que refactorizar Andrea

        // ver qu? ha hecho y si se puede dejar as?

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

        NwwLoaderFactory loadingFactory = manager.getLayerLoadingFactory(layer);

        if (loadingFactory instanceof NwwRasterLoaderFactory) {

            NwwRasterLoaderFactory rasterLoaderFactory = (NwwRasterLoaderFactory) loadingFactory;

            rasterLoaderFactory.setMapControl(mapControl);

        }

        if (loadingFactory instanceof ElevationLayerLoaderFactory) {

            BasicElevationModel elevModel =

                ((ElevationLayerLoaderFactory) loadingFactory).loadElevationModel(layerProperties);

            return elevModel;

        }

        return null;

    }

    private FLayer createNewProjectedOnTheFlyLayer(FLayer layer, IProjection projectionLayer)

        throws LoadLayerException {

        LayerProperties3D oldLayerProperties =

            View3DLocator.getManager().getLayerProperties(layer, null);

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

            }

        }

        View3DLocator.getManager().setLayerProperties(newLayer, oldLayerProperties);

        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 void createRasterTiledImageLayerParams(FLayer layer, AVList params,

        RasterLayerProperties3D layerProperties) {

        if (params == null) {

            params = new AVListImpl();

        }

        setBasicParameters(layer, params);

        setSectorParameters(layer, params);

        // Set resolution of layer

        params.setValue(AVKey.WIDTH, Integer.MAX_VALUE);

        params.setValue(AVKey.HEIGHT, Integer.MAX_VALUE);

        params.setValue(AVKey.IMAGE_FORMAT, "image/png");

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

        params.setValue(AVKey.TEXTURE_FORMAT, "image/dds");

        params.setValue(AVKey.FORMAT_SUFFIX, ".png");

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

        params.setValue(AVKey.NETWORK_RETRIEVAL_ENABLED, false);

        params.setValue(AVKey.USE_MIP_MAPS, true);

        params.setValue(AVKey.USE_TRANSPARENT_TEXTURES, true);

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

        setTileParameters(layer, sector, params, layerProperties);

        setDetailLevelParameters(layer, sector, params, layerProperties);

    }

    private void createElevationModelParams(FLayer layer, AVList params) {

        if (params == null) {

            params = new AVListImpl();

        }

        setBasicParameters(layer, params);

        setSectorParameters(layer, params);

        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:

                return;

            }

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

        } else {

            // TODO Vectorial elevation

        }

        View3DManager manager = View3DLocator.getManager();

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

        ElevationLayerProperties3D elevLayerProperties;

        if (!(layerProperties instanceof ElevationLayerProperties3D)) {

            elevLayerProperties = new DefaultElevationLayerProperties3D();

        } else {

            elevLayerProperties = (ElevationLayerProperties3D) layerProperties;

        }

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

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

        params.setValue(AVKey.MISSING_DATA_SIGNAL, elevLayerProperties.getNoDataValue());

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

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

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

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

        setTileParameters(layer, sector, params, elevLayerProperties);

        setDetailLevelParameters(layer, sector, params, elevLayerProperties);

    }

    private void setDetailLevelParameters(FLayer layer, Sector sector, AVList params,

        RasterLayerProperties3D layerProperties) {

        int numLevels;

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

        if (layerProperties.getMinLevel() == 0 && layerProperties.getMaxLevel() == 0) {

            LatLon rasterTileDelta = this.computeRasterTileDelta(params);

            LatLon desiredLevelZeroDelta = this.computeDesiredTileDelta(sector);

            numLevels = computeNumLevels(desiredLevelZeroDelta, rasterTileDelta);

        } else {

            numLevels = layerProperties.getMaxLevel() - layerProperties.getMinLevel();

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

        }

        params.setValue(AVKey.NUM_LEVELS, numLevels);

        if (layer instanceof FLyrVect) {

            // Only rasterized vectorial layers

            double degrees = DEFAULT_RASTERIZED_LEVEL_ZERO * layerProperties.getLevelZeroResolutionMultiplier();

            params.setValue(AVKey.LEVEL_ZERO_TILE_DELTA,

                new LatLon(Angle.fromDegrees(degrees), Angle.fromDegrees(degrees)));

        } else {

            LatLon rasterTileDelta = this.computeRasterTileDelta(params);

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

            LatLon levelZeroTileDelta = LatLon.fromDegrees(

                scale * layerProperties.getLevelZeroResolutionMultiplier() * rasterTileDelta.getLatitude().degrees,

                scale * layerProperties.getLevelZeroResolutionMultiplier() * rasterTileDelta.getLongitude().degrees);

            params.setValue(AVKey.LEVEL_ZERO_TILE_DELTA, levelZeroTileDelta);

        }

    }

    private void setSectorParameters(FLayer layer, AVList params) {

        MapControl3D mapControl3D = (MapControl3D) params.getValue(DefaultMapControl3D.GVSIG_MAPCONTROL3D);

        Sector sector = null;

        IProjection projection = mapControl3D.getMapContext().getProjection();

        try {

            sector = getSector(layer, projection);

        } catch (DataException e) {

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

            return;

        }

        params.setValue(AVKey.SECTOR, sector);

    }

    private void setTileParameters(FLayer layer, Sector sector, AVList params,

        RasterLayerProperties3D layerProperties) {

        params.setValue(AVKey.TILE_ORIGIN, new LatLon(sector.getMinLatitude(), sector.getMinLongitude()));

        // If tile sizes are 0, set defautlt values

        params.setValue(AVKey.TILE_WIDTH,

            layerProperties.getTileWidth() == 0 ? DEFAULT_TILE_WIDTH : layerProperties.getTileWidth());

        params.setValue(AVKey.TILE_HEIGHT,

            layerProperties.getTileHeight() == 0 ? DEFAULT_TILE_HEIGHT : layerProperties.getTileHeight());

    }

    private void setBasicParameters(FLayer layer, AVList params) {

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

    }

    private Sector getSector(FLayer layer, IProjection projection) throws DataException {

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

        Point2D p1 = null;

        Point2D p2 = null;

        Envelope envelope = layer.getFullEnvelope();

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

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

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

    }

//    private Point2D convert(ICoordTrans ct, Point2D point) {

//        if (ct == null) {

//            return point;

//        }

//

//        return ct.convert(point, null);

//    }

}