Application: gvSIG desktop » gvSIG 3D

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

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

 *

 */

package org.gvsig.gvsig3d.app.extension;

import java.awt.Color;

import java.util.prefs.Preferences;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.project.ProjectPreferences;

import org.gvsig.app.project.documents.DocumentManager;

import org.gvsig.app.project.documents.view.BaseViewDocument;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.gvsig3d.Gvsig3DException;

import org.gvsig.gvsig3d.Gvsig3DLocator;

import org.gvsig.gvsig3d.map3d.MapContext3D;

import org.gvsig.osgvp.exceptions.node.NodeException;

import org.gvsig.osgvp.terrain.Extent;

import org.gvsig.osgvp.terrain.JavaDataDriver;

import org.gvsig.osgvp.terrain.LayerManager;

import org.gvsig.osgvp.terrain.Terrain;

import org.gvsig.osgvp.terrain.TerrainViewer;

import org.gvsig.osgvp.viewer.Camera;

import org.gvsig.osgvp.viewer.CanvasViewer;

import org.gvsig.osgvp.viewer.IViewerContainer;

import org.gvsig.osgvp.viewer.ViewerFactory;

import org.gvsig.osgvp.viewer.ViewerStateListener;

import org.gvsig.tools.locator.LocatorException;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * @author gvSIG Team

 * @version $Id$

 * 

 */

public class DefaultView3DDocument extends BaseViewDocument {

        private static final long serialVersionUID = 676711512482344764L;

        public static final String PERSISTENCE_DEFINITION_NAME = "DefaultView3DDocument";

        private IViewerContainer _canvas3d = null;

        private TerrainViewer _terrainViewer = null;

        private Terrain _terrain = null;

        // private ProjectCamera _projectCamera = null;

        private JavaDataDriver _terrainDataManager = null;

        private LayerManager _terrainLayerManager = null;

        private int _terrainType = Terrain.CoordinateSystemType.PROJECTED; // spheric

        // or

        // plane

        private Color _backgroundColor;

        private float _verticalExaggeration = 1;

        private DefaultView3DPanel _view = null;

        private static Preferences _prefs = Preferences.userRoot().node(

                        "gvsig.configuration.3D");

        private boolean _prespectiveMode = true;

        private static Logger _logger = LoggerFactory

                        .getLogger(DefaultView3DDocument.class.getName());

        public DefaultView3DDocument() {

                this(null);

        }

        public DefaultView3DDocument(DocumentManager factory) {

                super(factory);

                ProjectPreferences preferences = (ProjectPreferences) ApplicationLocator

                                .getManager().getPreferences("project");

        }

        public void saveToState(PersistentState state) throws PersistenceException {

                super.saveToState(state);

        }

        public void loadFromState(PersistentState state)

                        throws PersistenceException {

                super.loadFromState(state);

        }

        public String exportDocumentAsText() {

                // FIXME: jjdc PersistentManager getStateAsText o similar

                // PersistenceManager manager = ToolsLocator.getPersistenceManager();

                // PersistentState state = manager.getState(this);

                // return manager.getStateAsText(state);

                return null;

        }

        public void setStateFromText(String text) {

                // FIXME: jjdc PersistentManager getStateFromText o similar

                // PersistenceManager manager = ToolsLocator.getPersistenceManager();

                // PersistentState state = manager.getStateFromText(text);

                // this.loadFromState(state);

        }

        public int getTerrainType() {

                return _terrainType;

        }

        public void setTerrainType(int type) {

                _terrainType = type;

        }

        public float getVerticalExaggeration() {

                return _verticalExaggeration;

        }

        public void setVerticalExaggeration(float exaggeration) {

                _verticalExaggeration = exaggeration;

        }

        public Color getBackGroundColor() {

                return _backgroundColor;

        }

        public void setBackGroundColor(Color backGroundColor) {

                _backgroundColor = backGroundColor;

                if ((_backgroundColor != null) && (_terrainViewer != null)) {

                        float r, g, b, a;

                        r = ((float) _backgroundColor.getRed()) / 255.0f;

                        g = ((float) _backgroundColor.getGreen()) / 255.0f;

                        b = ((float) _backgroundColor.getBlue()) / 255.0f;

                        a = ((float) _backgroundColor.getAlpha()) / 255.0f;

                        _terrainViewer.setClearColor(r, g, b, a);

                }

        }

        public Terrain getTerrain() {

                return _terrain;

        }

        public void setTerrain(Terrain terrain) {

                _terrain = terrain;

        }

        public IViewerContainer getCanvas3d() {

                return _canvas3d;

        }

        public void setCanvas3d(CanvasViewer canvas3d) {

                _canvas3d = canvas3d;

        }

        // private void setVerticalEx(float exa) {

        //

        // SingleLayerIterator lyrIterator = new SingleLayerIterator(

        // (FLayers3D) getMapContext().getLayers());

        // while (lyrIterator.hasNext()) {

        // FLayer lyr = lyrIterator.next();

        //

        // Layer3DProps props = Layer3DProps.getLayer3DProps(lyr);

        // int type = props.getType();

        // if (exa != props.getVerticalEx()) {

        // if (type == Layer3DProps.layer3DElevation) {

        // props.setVerticalEx(exa);

        // HeightfieldLayer layer = (HeightfieldLayer)props.getTerrainLayer();

        // if(layer == null) return;

        // layer.setVerticalExaggeration(exa);

        // _view.getTerrain().getLayerManager().updateLayers();

        // } else if (type == Layer3DProps.layer3DVector) {

        // props.setVerticalEx(exa);

        // }

        // }

        //

        // }

        // }

        public boolean isPrespectiveModeActive() {

                return _prespectiveMode;

        }

        /**

         * Active the prespective mode. If we disable the prespective mode, the

         * ortho mode will be active

         * 

         * @param prespectiveMode

         *            enable/disable

         */

        public void setActivePrespectiveMode(boolean prespectiveMode) {

                _prespectiveMode = prespectiveMode;

        }

        private void configureProjectionViewMode() {

                if (_prespectiveMode) {

                        System.out.println("Setting up prespective projection");

                        // this.m_canvas3d.getOSGViewer().setProjectionMatrixAsPerspective(

                        // arg0, arg1, arg2, arg3);

                } else {

                        System.out.println("Setting up prespective projection");

                        this._canvas3d.getOSGViewer().setProjectionMatrixAsOrtho(-10, 10,

                                        -10, 10, 1, 1000);

                }

        }

        public DefaultView3DPanel getView() {

                return _view;

        }

        public void setView(DefaultView3DPanel view) {

                _view = view;

        }

        public IViewerContainer getOrCreateCanvas3D() {

                if (_canvas3d == null) {

                        try {

                                _terrainViewer = new TerrainViewer();

                        } catch (NodeException e1) {

                        }

                        // System.out.println("TerrainViewer is: " + _terrainViewer);

                        _canvas3d = ViewerFactory.getInstance().createViewer(

                                        ViewerFactory.VIEWER_TYPE.CANVAS_VIEWER, _terrainViewer);

                        if (_canvas3d == null)

                                System.out.println("ERROR; CANVAS NULL");

                        ViewerFactory.getInstance().startAnimator();

                        try {

                                _terrain = new Terrain();

                                _terrainDataManager = new JavaDataDriver();

                                _canvas3d.getOSGViewer()

                                                .addUpdateOperation(_terrainDataManager);

                                _terrainLayerManager = new LayerManager();

                                _terrain.setLayerManager(_terrainLayerManager);

                                _terrainViewer.addTerrain(_terrain);

                                _canvas3d.addKeyListener(new ViewerStateListener(_canvas3d

                                                .getOSGViewer()));

                                if (_canvas3d.getOSGViewer().getCameraManipulator() != null)

                                        _canvas3d.getOSGViewer().getCameraManipulator()

                                                        .computeHomePosition();

                                Camera cam;

                                cam = new Camera();

                                if (_terrainType == Terrain.CoordinateSystemType.PROJECTED) {

                                        Extent extent = _terrain.getExtent();

                                        double width = extent.xMax() - extent.xMin();

                                        double length = extent.yMax() - extent.yMin();

                                        double height = Math.sqrt(width * width + length * length) * 10f;

                                        cam.setViewByLookAt((float) (extent.xMax() / 2.0),

                                                        (float) (extent.yMax() / 2.0), (float) height,

                                                        (float) (extent.xMax() / 2.0),

                                                        (float) (extent.yMax() / 2.0), 0f, 0f, 1f, 0f);

                                        cam.setViewByLookAt(0, 0, 5000000 * 4.6, 0, 0, 0, 0, 1, 0);

                                        _terrainViewer.getTerrainCameraManipulator()

                                                        .setMinimumDistance(10);

                                        _terrainViewer.getTerrainCameraManipulator()

                                                        .setMaximumDistance(5000000 * 10);

                                } else {

                                        cam.setViewByLookAt(_terrain.getRadiusEquatorial() * 8.0,

                                                        0, 0, 0, 0, 0, 0, 0, 1);

                                        _terrainViewer.getTerrainCameraManipulator()

                                                        .setMinimumDistance(100);

                                        _terrainViewer

                                                        .getTerrainCameraManipulator()

                                                        .setMaximumDistance(

                                                                        (float) (_terrain.getRadiusEquatorial() * 10.0));

                                }

                                _terrainViewer.setCamera(cam);

                        } catch (NodeException e) {

                        }

                }

                return _canvas3d;

        }

        public JavaDataDriver getTerrainDataManager() {

                return _terrainDataManager;

        }

        public LayerManager getTerrainLayerManager() {

                return _terrainLayerManager;

        }

}