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

import gov.nasa.worldwind.avlist.AVList;

import gov.nasa.worldwind.avlist.AVListImpl;

import gov.nasa.worldwind.cache.BasicDataFileStore;

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

import gov.nasa.worldwind.util.WWMath;

import java.awt.geom.Point2D;

import java.io.File;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

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.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.gvsig.view3d.swing.impl.DefaultMapControl3D;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.w3c.dom.Document;

/**

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

    public Layer convertToLayer(MapControl3D mapControl, FLayer layer)

        throws DataException {

        AVList params = new AVListImpl();

        // Add Layer and MapContext to parameters.

        params.setValue(DefaultMapControl3D.GVSIG_MAPCONTROL3D, mapControl);

        params.setValue(DefaultMapControl3D.GVSIG_LAYER, layer);

        createRasterTiledImageLayerParams(layer, params);

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

    }

    public ElevationModel convertToElevationModel(MapControl3D mapControl,

        FLayer layer) {

        // TODO Auto-generated method stub

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

        }

    }

    private void createRasterTiledImageLayerParams(FLayer layer, AVList params) {

        if (params == null) {

            params = new AVListImpl();

        }

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

        String cachePath =

            View3DLocator.getManager().getGeneral3DProperties().getCachePath();

        params.setValue(AVKey.FILE_STORE, new BasicDataFileStore(new File(

            cachePath)));

        MapControl3D mapControl3D =

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

        Sector sector = null;

        try {

            sector = getSector(layer, mapControl3D.getMapContext().getProjection());

        } catch (DataException e) {

            LOG.info("Can't create sector from layer and projection", e);

            return;

        }

        params.setValue(AVKey.SECTOR, sector);

        // 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.TILE_ORIGIN, new LatLon(sector.getMinLatitude(),

            sector.getMinLongitude()));

        View3DManager manager = View3DLocator.getManager();

        LayerProperties3D layerProperties = manager.getLayerProperties(layer);

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

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

        }

        params.setValue(AVKey.NUM_LEVELS, numLevels);

        params.setValue(AVKey.NETWORK_RETRIEVAL_ENABLED, false);

        params.setValue(AVKey.USE_MIP_MAPS, true);

        params.setValue(AVKey.USE_TRANSPARENT_TEXTURES, true);

    }

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

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

    }

}