Application: gvSIG desktop » gvSIG 3D

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright © 2007-2016 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.loaders;

import java.awt.geom.Point2D;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.w3c.dom.Document;

import org.gvsig.fmap.crs.CRSFactory;

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

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

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.view3d.lib.api.properties.E3DLayerLoadingModes;

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

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

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

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

import org.gvsig.view3d.swing.impl.layers.raster.DefaultTiledImageLayer;

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

import gov.nasa.worldwind.layers.TiledImageLayer;

import gov.nasa.worldwind.util.WWMath;

/**

 * Abstract Loader factory for vector layers.

 *

 * @author Andrea Antonello (www.hydrologis.com)

 *

 */

public abstract class AbstractRasterizedLayerLoaderFactory {

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

    private final int DEFAULT_RASTERIZED_LEVEL_ZERO = 20;

    private final int DEFAULT_TILE_WIDTH = 512;

    private final int DEFAULT_TILE_HEIGHT = 512;

    protected MapControl3D mapControl3D;

    public void setMapControl(MapControl3D mapControl3D) {

        this.mapControl3D = mapControl3D;

    }

    public Layer loadLayer(LayerProperties3D properties) {

        FLayer layer = properties.getLayer();

        AVList params = new AVListImpl();

        params.setValue(DefaultMapControl3D.GVSIG_MAPCONTROL3D, mapControl3D);

        params.setValue(E3DLayerLoadingModes.GVSIG_LAYER, layer);

        createRasterTiledImageLayerParams(layer, params, (RasterLayerProperties3D) properties);

        // Create configuration document from parameters.

        Document doc = TiledImageLayer.createTiledImageLayerConfigDocument(params);

        // Copy parameters to avoid problems

        AVList paramsLayer = params.copy();

        DefaultTiledImageLayer rasterLayer = new DefaultTiledImageLayer(doc.getDocumentElement(), paramsLayer);

        return rasterLayer;

    }

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

    }

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

        }

    }

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

    }

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

    }

    protected 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 = null;

        IProjection epsg4326 = CRSFactory.getCRS("EPSG:4326");

        if(!layer.getProjection().equals(epsg4326)) {

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

                ct = layer.getCoordTrans().getPDest().getCT(epsg4326);

            } else {

                ct = projection.getCT(epsg4326);

            }

        }

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

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

    }

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

        }

    }

}