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.data.RasterServer;

import gov.nasa.worldwind.geom.Angle;

import gov.nasa.worldwind.geom.Extent;

import gov.nasa.worldwind.geom.Sector;

import gov.nasa.worldwind.layers.BasicTiledImageLayer;

import gov.nasa.worldwind.layers.TextureTile;

import gov.nasa.worldwind.render.DrawContext;

import gov.nasa.worldwind.retrieve.RetrievalPostProcessor;

import gov.nasa.worldwind.retrieve.Retriever;

import gov.nasa.worldwind.retrieve.RetrieverFactory;

import gov.nasa.worldwind.util.Logging;

import gov.nasa.worldwind.util.WWUtil;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.w3c.dom.Element;

import org.gvsig.fmap.mapcontext.MapContext;

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

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

/**

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

 *

 */

public class RasterTiledImageLayer extends BasicTiledImageLayer {

    private static final Logger LOG = LoggerFactory

        .getLogger(RasterTiledImageLayer.class);

    /**

     * @param params

     */

    public RasterTiledImageLayer(AVList params) {

        super(params);

        this.createRasterServer(params);

    }

    /**

     * @param domElement

     * @param params

     */

    public RasterTiledImageLayer(Element domElement, AVList params) {

        super(domElement, params);

        this.createRasterServer(params != null ? params : (AVList) this

            .getValue(AVKey.CONSTRUCTION_PARAMETERS));

    }

    private void createRasterServer(AVList params) {

        if (params == null) {

            LOG.error("Can not create raster server, parameters is null");

            throw new IllegalArgumentException();

        }

        if (this.getDataFileStore() == null) {

            LOG.error("Can not create raster server, file store is null");

            throw new IllegalArgumentException();

        }

        String datasetName = params.getStringValue(AVKey.DATASET_NAME);

        if (WWUtil.isEmpty(datasetName)) {

            LOG.error(

                "Can not create raster server, missing required parameter: {}",

                AVKey.DATASET_NAME);

            throw new IllegalArgumentException();

        }

        String dataCacheName = params.getStringValue(AVKey.DATA_CACHE_NAME);

        if (WWUtil.isEmpty(dataCacheName)) {

            LOG.error(

                "Can not create raster server, missing required parameter: {}",

                AVKey.DATA_CACHE_NAME);

            throw new IllegalArgumentException();

        }

        MapContext mapContext =

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

        if (mapContext == null) {

            LOG.error(

                "Can not create raster server, missing required parameter: {}",

                DefaultMapControl3D.GVSIG_MAPCONTEXT);

            throw new IllegalArgumentException();

        }

        FLayer layer = (FLayer) params.getValue(DefaultMapControl3D.GVSIG_LAYER);

        if (layer == null) {

            LOG.error(

                "Can not create raster server, missing required parameter: {}",

                "GVSIG_LAYER");

            throw new IllegalArgumentException();

        }

        final AVList rasterServerParams = params.copy();

        rasterServerParams.setValue(AVKey.FILE_STORE, this.getDataFileStore());

        RetrieverFactory retrieverFactory = new RetrieverFactory() {

            final protected RasterServer rasterServer =

                new DefaultRasterServer(rasterServerParams);

            public Retriever createRetriever(AVList tileParams,

                RetrievalPostProcessor postProcessor) {

                DefaultRasterServerRetriever retriever =

                    new DefaultRasterServerRetriever(tileParams,

                        this.rasterServer, postProcessor);

                // copy only values that do not exist in destination AVList

                // from rasterServerParams (source) to retriever (destination)

                String[] keysToCopy =

                    new String[] { AVKey.DATASET_NAME, AVKey.DISPLAY_NAME,

                        AVKey.FILE_STORE, AVKey.IMAGE_FORMAT,

                        AVKey.FORMAT_SUFFIX };

                WWUtil.copyValues(rasterServerParams, retriever, keysToCopy,

                    false);

                return retriever;

            }

        };

        params.setValue(AVKey.RETRIEVER_FACTORY_LOCAL, retrieverFactory);

        this.setValue(AVKey.RETRIEVER_FACTORY_LOCAL, retrieverFactory);

    }

    protected boolean isTileVisible(DrawContext dc, TextureTile tile) {

        if(tile.getSector().isWithinLatLonLimits()){

            return tile.getExtent(dc).intersects(

                dc.getView().getFrustumInModelCoordinates())

                && (dc.getVisibleSector() == null || dc.getVisibleSector()

                .intersects(tile.getSector()));

        } else {

            LOG.warn(

                "Tile sector is out of range Latitude {} {} Longitude {} {}. Trying to adjust sector",

                new Object[] { tile.getSector().getMinLatitude(),

                    tile.getSector().getMaxLatitude(),

                    tile.getSector().getMinLongitude(),

                    tile.getSector().getMaxLongitude() });

            // Try to fix extend. This is necessary to avoid problems getting if

            // some tile is visible or not when the tile has corrupt sector like

            // ~180.0000001 or -90.000000004561

            Extent extend = this.fixExtend(tile, dc);

            return extend.intersects(dc.getView()

                .getFrustumInModelCoordinates())

                && (dc.getVisibleSector() == null || dc.getVisibleSector()

                    .intersects(tile.getSector()));

        }

    }

    private Extent fixExtend(TextureTile tile, DrawContext dc) {

        if (dc == null) {

            String msg = Logging.getMessage("nullValue.DrawContextIsNull");

            Logging.logger().severe(msg);

            throw new IllegalArgumentException(msg);

        }

        if ( tile.getSector().isWithinLatLonLimits()){

            return Sector.computeBoundingBox(dc.getGlobe(),

                dc.getVerticalExaggeration(), tile.getSector());

        } else {

            double[] degreesArray = tile.getSector().asDegreesArray();

            double minLatitude =

                degreesArray[0] < Angle.NEG90.degrees ? Angle.NEG90.degrees

                    : degreesArray[0];

            double maxLatitude =

                degreesArray[1] > Angle.POS90.degrees ? Angle.POS90.degrees

                    : degreesArray[1];

            double minLongitude =

                degreesArray[2] < Angle.NEG180.degrees ? Angle.NEG180.degrees

                    : degreesArray[2];

            double maxLongitude =

                degreesArray[3] > Angle.POS180.degrees ? Angle.POS180.degrees

                    : degreesArray[3];

            Sector adjustedSector =

                new Sector(Angle.fromDegrees(minLatitude),

                    Angle.fromDegrees(maxLatitude),

                    Angle.fromDegrees(minLongitude),

                    Angle.fromDegrees(maxLongitude));

            return Sector.computeBoundingBox(dc.getGlobe(),

                dc.getVerticalExaggeration(), adjustedSector);

        }

    }

}