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

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

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

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

/**

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

 *

 */

public class DefaultLayerConverter implements LayerConverter {

    private static final Logger LOG = LoggerFactory

        .getLogger(DefaultLayerConverter.class);

    public Layer convertToLayer(MapContext mapContext, FLayer layer)

        throws DataException {

        AVList params = new AVListImpl();

        // Add Layer and MapContext to parameters.

        params.setValue(DefaultMapControl3D.GVSIG_MAPCONTEXT, mapContext);

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

        RasterTiledImageLayer rasterLayer =

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

        return rasterLayer;

    }

    public ElevationModel convertToElevationModel(MapContext mapContext,

        FLayer layer) {

        // TODO Auto-generated method stub

        return null;

    }

    private String getUniqueCacheId(String name) {

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

            digest.update(name.getBytes());

            byte messageDigest[] = digest.digest();

            // Create Hex String

            StringBuilder hexString = new StringBuilder();

            hexString.append(name);

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

            return name;

        }

    }

    private void createRasterTiledImageLayerParams(FLayer layer, AVList params) {

        // TODO Get 3D propeties of layer with View3DManager.getProperties3D(layer)

        // and fill parameters with properties

        if (params == null) {

            params = new AVListImpl();

        }

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

        params.setValue(AVKey.DATA_CACHE_NAME,

            getUniqueCacheId(layer.getName()));

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

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

        MapContext mapContext =

            (MapContext) params.getValue(DefaultMapControl3D.GVSIG_MAPCONTEXT);

        Sector sector = null;

        try {

            sector = getSector(layer, mapContext.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

        // TODO Make configurable by user

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

        params.setValue(AVKey.TILE_WIDTH, 512);

        params.setValue(AVKey.TILE_HEIGHT, 512);

        LatLon rasterTileDelta = this.computeRasterTileDelta(params);

        LatLon desiredLevelZeroDelta = this.computeDesiredTileDelta(sector);

        int numLevels = computeNumLevels(desiredLevelZeroDelta, rasterTileDelta);

        params.setValue(AVKey.NUM_LEVELS, numLevels);

        if(layer instanceof FLyrVect){

            // Only rasterized vectorial layers TODO Make configurable

            params.setValue(AVKey.LEVEL_ZERO_TILE_DELTA, new

                 LatLon(Angle.fromDegrees(20), Angle.fromDegrees(20)));

        } else {

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

            LatLon levelZeroTileDelta = LatLon.fromDegrees(

                scale * rasterTileDelta.getLatitude().degrees,

                scale * rasterTileDelta.getLongitude().degrees);

            params.setValue(AVKey.LEVEL_ZERO_TILE_DELTA, levelZeroTileDelta);

        }

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

    }

}