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;

import gov.nasa.worldwind.Configuration;

import gov.nasa.worldwind.Factory;

import gov.nasa.worldwind.Model;

import gov.nasa.worldwind.WorldWind;

import gov.nasa.worldwind.avlist.AVKey;

import gov.nasa.worldwind.avlist.AVListImpl;

import gov.nasa.worldwind.awt.WorldWindowGLJPanel;

import gov.nasa.worldwind.globes.Earth;

import gov.nasa.worldwind.globes.EarthFlat;

import gov.nasa.worldwind.globes.ElevationModel;

import gov.nasa.worldwind.layers.CompassLayer;

import gov.nasa.worldwind.layers.Layer;

import gov.nasa.worldwind.layers.LayerList;

import gov.nasa.worldwind.layers.ScalebarLayer;

import gov.nasa.worldwind.layers.SkyColorLayer;

import gov.nasa.worldwind.layers.SkyGradientLayer;

import gov.nasa.worldwind.layers.StarsLayer;

import gov.nasa.worldwind.layers.ViewControlsLayer;

import gov.nasa.worldwind.layers.ViewControlsSelectListener;

import gov.nasa.worldwind.layers.WorldMapLayer;

import gov.nasa.worldwind.terrain.CompoundElevationModel;

import gov.nasa.worldwind.terrain.ZeroElevationModel;

import gov.nasa.worldwind.util.StatusBar;

import gov.nasa.worldwind.view.orbit.BasicOrbitView;

import gov.nasa.worldwind.view.orbit.FlatOrbitView;

import java.awt.BorderLayout;

import java.awt.Graphics;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.util.List;

import javax.swing.JComponent;

import javax.swing.JPanel;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

import org.gvsig.fmap.mapcontext.MapContext;

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

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

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

import org.gvsig.fmap.mapcontext.layers.operations.LayersVisitor;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.observer.BaseNotification;

import org.gvsig.tools.observer.Notification;

import org.gvsig.tools.observer.ObservableHelper;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.view3d.lib.api.View3DLocator;

import org.gvsig.view3d.lib.api.View3DManager;

import org.gvsig.view3d.lib.api.exception.FactoryNotRegisteredException;

import org.gvsig.view3d.lib.api.exception.LoadException;

import org.gvsig.view3d.lib.api.loader.Loader;

import org.gvsig.view3d.lib.api.loader.LoaderFactory;

import org.gvsig.view3d.lib.api.loader.LoaderParameters;

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

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

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

import org.gvsig.view3d.swing.api.View3DSwingManager.TYPE;

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

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

/**

 * Default implementation of {@link MapControl3D}.

 *

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

 */

public class DefaultMapControl3D extends JPanel implements MapControl3D {

    private static final long serialVersionUID = 2024899922367896097L;

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

    private DefaultSynchronizer synchronizer;

    private ObservableHelper observableHelper;

    private MapContext mapContext;

    private MapControlProperties3D properties;

    private ExtendedPropertiesSupport viewProperties;

    private WorldWindowGLJPanel wwd;

    private PropertyChangeListener verticalExaggerationPropertyListener;

    private PropertyChangeListener propertiesChangeListener;

    private StatusBar statusBar;

    private TYPE type;

    /**

     * Default constructor of {@link DefaultMapControl3D}. Initializes local

     * fileds, sets configuration depends on {@link TYPE} and adds

     * <code>MapContext</code> layers.

     *

     * @param theMapContext

     *            associated <code>MapContext</code>

     * @param type

     *            Type of this {@link DefaultMapControl3D}. See {@link TYPE}.

     * @param viewProperties

     *            View properties to register this <code>MapControl3D</code>

     */

    public DefaultMapControl3D(MapContext theMapContext, TYPE type,

        ExtendedPropertiesSupport viewProperties) {

        super(new BorderLayout());

        this.mapContext = theMapContext;

        this.type = type;

        this.observableHelper = new ObservableHelper();

        this.viewProperties = viewProperties;

        View3DSwingManager swingManager = View3DSwingLocator.getManager();

        this.properties = swingManager.getMapControl3DProperties(viewProperties);

        // Set pre configurations before instance WWD component

        preConfiguration();

        // Instance WWD component

        getWwd();

        // Set post configurations after instance WWD component

        postConfiguration();

        super.add(getWwd(), BorderLayout.CENTER);

        super.add(getStatusBar(), BorderLayout.SOUTH);

        this.synchronizer = new DefaultSynchronizer(this, this.mapContext, getWwd());

        try {

            addGvSIGLayers(mapContext.getLayers());

        } catch (BaseException e) {

            LOG.info("Can't add MapControl layers", e);

        }

    }

    private void preConfiguration() {

        // WWD Mode

        if (type == TYPE.SPHERE) {

            setSpherePanelConfiguration();

        } else if (type == TYPE.FLAT) {

            setFlatPanelConfiguration();

        }

        // Enable or disable anaglyph mode

        setAnaglyphMode(this.properties.getAnaglyphMode());

    }

    private void postConfiguration() {

        setGeneral3DProperties();

        this.properties.addPropertyChangeListener(getPropertiesChangeListener());

        setMapControl3DProperties();

        getWwd().getSceneController().addPropertyChangeListener(

            getVerticalExaggerationPropertyListener());

        getWwd().getView().getViewInputHandler().setStopOnFocusLost(false);

    }

    private PropertyChangeListener getPropertiesChangeListener() {

        if (this.propertiesChangeListener == null) {

            this.propertiesChangeListener = new PropertyChangeListener() {

                public void propertyChange(PropertyChangeEvent evt) {

                    String propertyName = evt.getPropertyName();

                    if (MapControlProperties3D.SPHERE_VERTICAL_EXAGGERATION_PROPERTY_NAME

                        .equals(propertyName) && getType() == TYPE.SPHERE) {

                        setVerticalExaggeration((Double) evt.getNewValue());

                    } else if (MapControlProperties3D.FLAT_VERTICAL_EXAGGERATION_PROPERTY_NAME

                        .equals(propertyName) && getType() == TYPE.FLAT) {

                        setVerticalExaggeration((Double) evt.getNewValue());

                    } else if (MapControlProperties3D.BLUE_MARBEL_VISIBILITY_PROPERTY_NAME

                        .equals(propertyName)) {

                        boolean visibility = (Boolean) evt.getNewValue();

                        setBlueMarbelLayerVisibility(visibility);

                    } else if (MapControlProperties3D.NASA_LANDSAT_VISIBILITY_PROPERTY_NAME

                        .equals(propertyName)) {

                        boolean visibility = (Boolean) evt.getNewValue();

                        setNasaLandsatLayerVisibility(visibility);

                    } else if (MapControlProperties3D.DEFAULT_ELEVATION_VISIBILITY_PROPERTY_NAME

                        .equals(propertyName)) {

                        boolean visibility = (Boolean) evt.getNewValue();

                        setDefaultElevationVisibility(visibility);

                    }

                }

            };

        }

        return this.propertiesChangeListener;

    }

    private PropertyChangeListener getVerticalExaggerationPropertyListener() {

        if (this.verticalExaggerationPropertyListener == null) {

            this.verticalExaggerationPropertyListener = new PropertyChangeListener() {

                public void propertyChange(PropertyChangeEvent evt) {

                    String propertyName = evt.getPropertyName();

                    if (propertyName.equals(AVKey.VERTICAL_EXAGGERATION)) {

                        Double value = (Double) evt.getNewValue();

                        if (getType() == TYPE.SPHERE) {

                            getProperties().setSphereVerticalExaggeration(value);

                        } else if (getType() == TYPE.FLAT) {

                            getProperties().setFlatVerticalExaggeration(value);

                        }

                    }

                }

            };

        }

        return this.verticalExaggerationPropertyListener;

    }

    private void setAnaglyphMode(boolean flag) {

        if (flag) {

            System.setProperty("gov.nasa.worldwind.stereo.mode", "redblue");

        } else {

            System.setProperty("gov.nasa.worldwind.stereo.mode", "");

        }

    }

    private void setGeneral3DProperties() {

        View3DSwingManager swingManager = View3DSwingLocator.getManager();

        GeneralProperties3D general3DProperties = swingManager.getGeneral3DProperties();

        this.setAtmosphereVisibility(general3DProperties.getAtmosphereVisibility());

        this.setMiniMapVisibility(general3DProperties.getMinimapVisibility());

        this.setNorthIndicatorVisibility(general3DProperties.getNorthIndicatorVisibility());

        this.setStarsBackgroundVisibility(general3DProperties.getStarsBackgroundVisibility());

        this.setScaleVisibility(general3DProperties.getScaleVisibility());

    }

    protected void addGvSIGLayer(FLayer layer) throws LoadException {

        LayerList layers = getWwd().getModel().getLayers();

        addGvSIGLayer(layer, layers.size());

    }

    protected void addGvSIGLayer(FLayer layer, int index) throws LoadException {

        View3DManager manager = View3DLocator.getManager();

        LoaderParameters loaderParameters = manager.getLoaderParameters(layer);

        if (loaderParameters == null) {

            // Default loader

            List<LoaderFactory> loaderFactories = manager.getLoaderFactories();

            if(loaderFactories.isEmpty()) {

                return;

            }

            loaderParameters = loaderFactories.get(0).createParameters(layer);

        }

        LoaderFactory loaderFactory = null;

        try {

            loaderFactory = manager.getLoaderFactory(loaderParameters.getName());

        } catch (FactoryNotRegisteredException e) {

            LOG.error("{} loader factory is not registered", loaderParameters.getName());

            return;

        }

        Loader loader = loaderFactory.createLoader();

        Object object = null;

        object = loader.load(loaderParameters);

        if (object instanceof Layer) {

            Layer wwLayer = (Layer) object;

            wwLayer.setEnabled(layer.isVisible());

            this.synchronizer.registerLayer(layer, wwLayer);

            getWwd().getModel().getLayers().add(index, wwLayer);

        } else if (object instanceof ElevationModel) {

            ElevationModel elevationModel = (ElevationModel) object;

            this.synchronizer.registerLayer(layer, elevationModel);

            CompoundElevationModel cem =

                (CompoundElevationModel) getWwd().getModel().getGlobe().getElevationModel();

            cem.addElevationModel(elevationModel);

        }

    }

    private void addGvSIGLayers(FLayers layers) throws BaseException {

        if (layers == null) {

            return;

        }

        layers.accept(new LayersVisitor() {

            public void visit(Object obj) throws VisitCanceledException, BaseException {

                throw new UnsupportedOperationException();

            }

            public void visit(FLayer layer) throws BaseException {

                if (layer.isAvailable()) {

                    addGvSIGLayer(layer);

                }

            }

        });

        getWwd().redraw();

    }

    private void setBlueMarbelLayerVisibility(boolean visibility) {

        if (visibility == getBlueMarbleLayerVisibility()) {

            return;

        }

        setWWLayerVisibility("Blue Marble May 2004", visibility);

        getProperties().setBlueMarbleLayerVisibility(visibility);

    }

    private boolean getBlueMarbleLayerVisibility() {

        return isWWLayerVisible("Blue Marble May 2004");

    }

    protected void setDefaultElevationVisibility(boolean visibility) {

        ElevationModel elevationModel = getWwd().getModel().getGlobe().getElevationModel();

        CompoundElevationModel compoundElevationModel = (CompoundElevationModel) elevationModel;

        List<ElevationModel> elevationModels = compoundElevationModel.getElevationModels();

        if (visibility == getDefaultElevationModelVisiblility()) {

            return;

        }

        if (visibility) {

            for (ElevationModel eModel : elevationModels) {

                if (eModel instanceof ZeroElevationModel) {

                    compoundElevationModel.removeElevationModel(eModel);

                    compoundElevationModel.addElevationModel(0, getDefaultElevationModel());

                    return;

                }

            }

        } else {

            for (ElevationModel eModel : elevationModels) {

                if (eModel.getName().equals("USA 10m, World 30m, Ocean 900m")) {

                    compoundElevationModel.removeElevationModel(eModel);

                    compoundElevationModel.addElevationModel(0, new ZeroElevationModel());

                    return;

                }

            }

        }

        getProperties().setDefaultElevationVisibility(visibility);

    }

    private boolean getDefaultElevationModelVisiblility() {

        ElevationModel elevationModel = getWwd().getModel().getGlobe().getElevationModel();

        CompoundElevationModel compoundElevationModel = (CompoundElevationModel) elevationModel;

        List<ElevationModel> elevationModels = compoundElevationModel.getElevationModels();

        for (ElevationModel eModel : elevationModels) {

            if (eModel.getName().equals("USA 10m, World 30m, Ocean 900m")) {

                return true;

            }

        }

        return false;

    }

    private ElevationModel getDefaultElevationModel() {

        Factory elevationFactory =

            (Factory) WorldWind.createConfigurationComponent(AVKey.ELEVATION_MODEL_FACTORY);

        String defaultModelFile =

            Configuration.getStringValue(AVKey.EARTH_ELEVATION_MODEL_CONFIG_FILE);

        CompoundElevationModel elevationModel =

            (CompoundElevationModel) elevationFactory.createFromConfigSource(defaultModelFile,

                new AVListImpl());

        return elevationModel.getElevationModels().get(0);

    }

    private void setNasaLandsatLayerVisibility(boolean visibility) {

        if (visibility == getNasaLandsatLayerVisibility()) {

            return;

        }

        setWWLayerVisibility("i-cubed Landsat", visibility);

        getProperties().setNasaLandsatVisibility(visibility);

    }

    private boolean getNasaLandsatLayerVisibility() {

        return isWWLayerVisible("i-cubed Landsat");

    }

    @SuppressWarnings("rawtypes")

    private void setWWLayerVisibility(Class layerClazz, boolean visiblity) {

        List<Layer> layersByClass = getWwd().getModel().getLayers().getLayersByClass(layerClazz);

        for (Layer layer : layersByClass) {

            layer.setEnabled(visiblity);

        }

    }

    private void setWWLayerVisibility(String layerName, boolean visibilty) {

        Layer layer = getWwd().getModel().getLayers().getLayerByName(layerName);

        if (layer != null) {

            layer.setEnabled(visibilty);

        }

    }

    private void addNavigation() {

        ViewControlsLayer controlsLayer = new ViewControlsLayer();

        Model model = getWwd().getModel();

        model.getLayers().add(controlsLayer);

        getWwd().addSelectListener(new ViewControlsSelectListener(wwd, controlsLayer));

    }

    public JComponent asJComponent() {

        return this;

    }

    public void dispose() {

        Thread disposeThread = new Thread(new Runnable() {

            public void run() {

                Notification beforeDisposeNotification =

                    new BaseNotification(MapControl3D.BEFORE_DISPOSE_MAPCONTEX3D_NOTIFICATION, null);

                observableHelper.notifyObservers(DefaultMapControl3D.this,

                    beforeDisposeNotification);

                if (beforeDisposeNotification.isCanceled()) {

                    LOG.warn("Dispose action canceled by some observer");

                    return;

                }

                if (WorldWind.getRetrievalService().hasActiveTasks()) {

                    WorldWind.getRetrievalService().shutdown(true);

                }

                if (WorldWind.getRemoteRetrievalService().hasActiveTasks()) {

                    WorldWind.getRemoteRetrievalService().shutdown(true);

                }

                // Remove change properties listener

                getWwd().getSceneController().removePropertyChangeListener(

                    getVerticalExaggerationPropertyListener());

                properties.removePropertyChangeListener(getPropertiesChangeListener());

                // Dispose WWD component

                disposeWwd();

                // Remove properties from view

                if (getType() == TYPE.SPHERE) {

                    viewProperties.getExtendedProperties().remove("sphereMapControl3D");

                } else if (getType() == TYPE.FLAT) {

                    viewProperties.getExtendedProperties().remove("flatMapControl3D");

                }

                synchronizer.dispose();

                synchronizer = null;

                properties = null;

                mapContext = null;

                Notification afterDisposeNotification =

                    new BaseNotification(MapControl3D.AFTER_DISPOSE_MAPCONTEX3D_NOTIFICATION, null);

                observableHelper

                    .notifyObservers(DefaultMapControl3D.this, afterDisposeNotification);

            }

        }, "Dispose World Wind thread");

        disposeThread.start();

    }

    public MapContext getMapContext() {

        return this.mapContext;

    }

    private StatusBar getStatusBar() {

        if (statusBar == null) {

            statusBar = new StatusBar();

            this.add(statusBar, BorderLayout.PAGE_END);

            statusBar.setEventSource(wwd);

        }

        return statusBar;

    }

    public TYPE getType() {

        return this.type;

    }

    public double getVerticalExaggeration() {

        return getWwd().getSceneController().getVerticalExaggeration();

    }

    public WorldWindowGLJPanel getWwd() {

        if (this.wwd == null) {

            intializeWWPanel();

        }

        return this.wwd;

    }

    private void disposeWwd() {

        if (getWwd() != null) {

            this.wwd = null;

        }

    }

    public void setAtmosphereVisibility(boolean visibility) {

        if (getType() == TYPE.SPHERE) {

            setWWLayerVisibility(SkyGradientLayer.class, visibility);

        } else if (getType() == TYPE.FLAT) {

            setWWLayerVisibility(SkyColorLayer.class, visibility);

        }

    }

    public void setMiniMapVisibility(boolean visiblity) {

        setWWLayerVisibility(WorldMapLayer.class, visiblity);

    }

    public void setNorthIndicatorVisibility(boolean visibility) {

        setWWLayerVisibility(CompassLayer.class, visibility);

    }

    public void setScaleVisibility(boolean visibility) {

        setWWLayerVisibility(ScalebarLayer.class, visibility);

    }

    public void setStarsBackgroundVisibility(boolean visibility) {

        setWWLayerVisibility(StarsLayer.class, visibility);

    }

    private void intializeWWPanel() {

        wwd = new WorldWindowGLJPanel();

        // Create the default model as described in the current worldwind

        // properties.

        Model m = (Model) WorldWind.createConfigurationComponent(AVKey.MODEL_CLASS_NAME);

        getWwd().setModel(m);

        // Add view control layer

        addNavigation();

    }

    public void reloadLayers() {

        this.wwd.getModel().getLayers().removeAll();

        Model auxModel = (Model) WorldWind.createConfigurationComponent(AVKey.MODEL_CLASS_NAME);

        this.wwd.getModel().setLayers(auxModel.getLayers());

        setGeneral3DProperties();

        setMapControl3DProperties();

        addNavigation();

        if (this.mapContext != null && this.mapContext.getLayers() != null) {

            try {

                addGvSIGLayers(mapContext.getLayers());

            } catch (BaseException e) {

                LOG.error("Can't add MapContext layers of {}", mapContext.getLayers(), e);

            }

        }

    }

    private void setFlatPanelConfiguration() {

        Configuration.setValue(AVKey.GLOBE_CLASS_NAME, EarthFlat.class.getName());

        Configuration.setValue(AVKey.VIEW_CLASS_NAME, FlatOrbitView.class.getName());

    }

    private void setMapControl3DProperties() {

        double verticalExaggeration = 0;

        if (getType() == TYPE.SPHERE) {

            verticalExaggeration = this.properties.getSphereVerticalExaggeration();

        } else if (getType() == TYPE.FLAT) {

            verticalExaggeration = this.properties.getFlatVerticalExaggeration();

        }

        setVerticalExaggeration(verticalExaggeration);

        boolean visibility = this.properties.getBlueMarbleLayerVisibility();

        setBlueMarbelLayerVisibility(visibility);

        visibility = this.properties.getNasaLandsatLayerVisibility();

        setNasaLandsatLayerVisibility(visibility);

        visibility = this.properties.getDefaultElevationVisibility();

        setDefaultElevationVisibility(visibility);

        boolean anaglyphMode = this.properties.getAnaglyphMode();

        if (anaglyphMode) {

        }

    }

    private void setSpherePanelConfiguration() {

        Configuration.setValue(AVKey.GLOBE_CLASS_NAME, Earth.class.getName());

        Configuration.setValue(AVKey.VIEW_CLASS_NAME, BasicOrbitView.class.getName());

    }

    private void setVerticalExaggeration(double verticalExaggeration) {

        if (getVerticalExaggeration() == verticalExaggeration) {

            return;

        }

        getWwd().getSceneController().setVerticalExaggeration(verticalExaggeration);

        if (getType() == TYPE.SPHERE) {

            getProperties().setSphereVerticalExaggeration(verticalExaggeration);

        } else if (getType() == TYPE.FLAT) {

            getProperties().setFlatVerticalExaggeration(verticalExaggeration);

        }

    }

    public void synchronizeViewPorts() {

        this.synchronizer.synchronizeViewPorts();

    }

    public void addObserver(Observer o) {

        if (observableHelper != null) {

            observableHelper.addObserver(o);

        }

    }

    public void deleteObserver(Observer o) {

        if (observableHelper != null) {

            observableHelper.deleteObserver(o);

        }

    }

    public void deleteObservers() {

        if (observableHelper != null) {

            observableHelper.deleteObservers();

        }

    }

    public boolean getAtmosphereVisibility() {

        return isWWLayerVisible(SkyGradientLayer.class) || isWWLayerVisible(SkyColorLayer.class);

    }

    public boolean getMinimapVisibility() {

        return isWWLayerVisible(WorldMapLayer.class);

    }

    public boolean getNorthIndicatorVisibility() {

        return isWWLayerVisible(CompassLayer.class);

    }

    public boolean getStarBackgroundVisibility() {

        return isWWLayerVisible(StarsLayer.class);

    }

    public boolean getScaleVisibility() {

        return isWWLayerVisible(ScalebarLayer.class);

    }

    @SuppressWarnings("rawtypes")

    private boolean isWWLayerVisible(Class clazz) {

        List<Layer> layersByClass = getWwd().getModel().getLayers().getLayersByClass(clazz);

        for (Layer layer : layersByClass) {

            return layer.isEnabled();

        }

        return false;

    }

    private boolean isWWLayerVisible(String name) {

        Layer layer = getWwd().getModel().getLayers().getLayerByName(name);

        if (layer != null) {

            return layer.isEnabled();

        }

        return false;

    }

    public MapControlProperties3D getProperties() {

        return properties;

    }

    @Override

    public Object getUnderLineComponent() {

        return this.getWwd();

    }

    @Override

    protected void paintComponent(Graphics g) {

        super.paintComponent(g);

        revalidate();

        repaint();

    }

    @Override

    public void setViewPortEnvelope(Envelope envelope) {

        this.synchronizer.setViewPortEnvelope(envelope);

    }

}