Application: gvSIG desktop

package org.gvsig.gvsig3d.map3d;

import java.awt.Dimension;

import java.awt.Graphics2D;

import java.awt.Point;

import java.awt.geom.AffineTransform;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.awt.image.ImagingOpException;

import java.awt.image.RenderedImage;

import java.io.File;

import java.io.IOException;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.Timer;

import java.util.Vector;

import javax.print.attribute.PrintRequestAttributeSet;

import org.apache.log4j.Logger;

import org.cresques.cts.IProjection;

import org.gvsig.cacheservice.TileNum;

import org.gvsig.gvsig3d.cacheservices.FLayerCacheService;

import org.gvsig.gvsig3d.cacheservices.OSGCacheService;

import org.gvsig.gvsig3d.cacheservices.VectorCacheService;

import org.gvsig.gvsig3d.drivers.GvsigDriverOSG;

import org.gvsig.gvsig3d.map3d.layers.FLayers3D;

import org.gvsig.osgvp.core.osg.Image;

import org.gvsig.osgvp.core.osg.Matrix;

import org.gvsig.osgvp.core.osg.Node;

import org.gvsig.osgvp.core.osg.Vec3;

import org.gvsig.osgvp.core.osg.Vec4;

import org.gvsig.osgvp.exceptions.image.ImageConversionException;

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

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

import org.gvsig.osgvp.terrain.DataLoader;

import org.gvsig.osgvp.terrain.Extent;

import org.gvsig.osgvp.terrain.HeightfieldLayer;

import org.gvsig.osgvp.terrain.JavaDataDriver;

import org.gvsig.osgvp.terrain.Layer;

import org.gvsig.osgvp.terrain.LayerManager;

import org.gvsig.osgvp.terrain.RasterLayer;

import org.gvsig.osgvp.terrain.RequestDataEvent;

import org.gvsig.osgvp.terrain.Terrain;

import org.gvsig.osgvp.terrain.TerrainViewer;

import org.gvsig.osgvp.terrain.UpdateDataEvent;

import org.gvsig.osgvp.terrain.VectorLayer;

import org.gvsig.osgvp.terrain.Terrain.CoordinateSystemType;

import org.gvsig.osgvp.viewer.Camera;

import org.gvsig.osgvp.viewer.IViewerContainer;

import org.gvsig.osgvp.viewer.PrintUtilities;

import com.hardcode.driverManager.Driver;

import com.hardcode.gdbms.driver.exceptions.ReadDriverException;

import com.iver.ai2.gvsig3d.map3d.layers.Layer3DProps;

import com.iver.andami.PluginServices;

import com.iver.andami.messages.NotificationManager;

import com.iver.andami.ui.mdiManager.IWindow;

import com.iver.cit.gvsig.exceptions.expansionfile.ExpansionFileReadException;

import com.iver.cit.gvsig.fmap.MapContext;

import com.iver.cit.gvsig.fmap.ViewPort;

import com.iver.cit.gvsig.fmap.layers.FBitSet;

import com.iver.cit.gvsig.fmap.layers.FLayer;

import com.iver.cit.gvsig.fmap.layers.FLayers;

import com.iver.cit.gvsig.fmap.layers.FLyrDefault;

import com.iver.cit.gvsig.fmap.layers.FLyrVect;

import com.iver.cit.gvsig.fmap.layers.FLyrWCS;

import com.iver.cit.gvsig.fmap.layers.GraphicLayer;

import com.iver.cit.gvsig.fmap.layers.LayerEvent;

import com.iver.cit.gvsig.fmap.layers.LayerListener;

import com.iver.cit.gvsig.fmap.layers.LegendChangedEvent;

import com.iver.cit.gvsig.fmap.layers.SelectableDataSource;

import com.iver.cit.gvsig.fmap.layers.SelectionEvent;

import com.iver.cit.gvsig.fmap.layers.SelectionListener;

import com.iver.cit.gvsig.fmap.layers.SelectionSupport;

import com.iver.cit.gvsig.fmap.layers.SingleLayerIterator;

import com.iver.cit.gvsig.fmap.layers.XMLException;

import com.iver.cit.gvsig.fmap.layers.layerOperations.Classifiable;

import com.iver.cit.gvsig.fmap.rendering.LegendListener;

import com.iver.cit.gvsig.project.documents.view.gui.BaseView;

import com.iver.utiles.XMLEntity;

import com.iver.utiles.swing.threads.Cancellable;

public class MapContext3D extends MapContext implements DataLoader,

                LayerListener, LegendListener, SelectionListener {

        // JOSG library objects

        private Terrain _terrain;

        private IViewerContainer _canvas3d;

        private TerrainViewer _terrainViewer;

        private LayerManager _terrainLayerManager;

        private JavaDataDriver _terrainDataManager = null;

        private Hashtable<FLayer, Layer> _terrainFLayerMap = new Hashtable<FLayer, Layer>();

        private Hashtable<String, FLayer> _terrainLayerMap = new Hashtable<String, FLayer>();

        private IProjection _viewProjection;

        private float _verticalExaggeration;

        private boolean _bEmptyView = true;

        private boolean _bListenToLegend = true;

        private boolean _bLoading = false;

        private TerrainViewer _canvasoff = null;

        private boolean _renewCanvasOff = false;

        private static Logger _logger = Logger.getLogger(MapContext3D.class

                        .getName());

        TerrainViewer _printViewer = null;

        Layer _testRasterLayer = null;

        private boolean visibilityChange = false;

        @Override

        public void draw(BufferedImage image, Graphics2D g, Cancellable cancel,

                        double scale) throws ReadDriverException {

                double x = getViewPort().getOffset().getX();

                double y = getViewPort().getOffset().getY();

                double w = image.getWidth();

                double h = image.getHeight();

                if (_canvasoff == null) {

                        try {

                                _canvasoff = new TerrainViewer();

                                _canvasoff.setUpViewerInBackground(0, 0, 512, 512);

                                Terrain planetView3D = ((TerrainViewer) _canvas3d.getOSGViewer()).getTerrain(0);

                                Terrain terrain = new Terrain();

                                terrain.setCoordinateSystemType(planetView3D

                                                .getCoordinateSystemType());

                                terrain.setCoordinateSystemName(planetView3D

                                                .getCoordinateSystemName());

                                terrain.setCoordinateSystemFormat(planetView3D

                                                .getCoordinateSystemFormat());

                                terrain.setExtent(planetView3D.getExtent());

                                terrain.setTerrainName(planetView3D.getTerrainName());

                                terrain.init();

                                terrain.setLayerManager(_terrainLayerManager);

                                _canvasoff

                                                .addTerrain(terrain);

                                _canvasoff.addFeature((((TerrainViewer) _canvas3d

                                                .getOSGViewer()).getFeatures()));

                                Vec4 color = ((TerrainViewer) _canvas3d.getOSGViewer())

                                                .getClearColor();

                                _canvasoff.setClearColor(color.x(), color.y(), color.z(), color

                                                .w());

                                this.setRenewCanvasOff(false);

                        } catch (NodeException e) {

                                // TODO Auto-generated catch block

                                e.printStackTrace();

                        }

                }

                Camera refCam = _canvas3d.getOSGViewer().getCamera();

                Matrix refView = refCam.getViewMatrix();

                Matrix refProy = refCam.getProjectionMatrix();

                Matrix.Perspective pers = refProy.getPerspective();

                Camera viewCam = new Camera();

                viewCam.setProjectionMatrixAsPerspective(pers.fovy, w / h, pers.zNear,

                                pers.zFar);

                viewCam.setViewMatrix(refView);

                _canvasoff.setViewport(0, 0, (int) w, (int) h);

                _canvasoff.setCamera(viewCam);

                _canvasoff.takeScreenshotToMemory();

                _canvasoff.frame();

                Image OSGimage = _canvasoff.getScreenshotImage();

                BufferedImage img = null;

                try {

                        img = OSGimage.getBufferedImage();

                } catch (ImageConversionException e1) {

                        // TODO Auto-generated catch block

                        e1.printStackTrace();

                } catch (IOException e1) {

                        // TODO Auto-generated catch block

                        e1.printStackTrace();

                }

                double scalex = w / img.getWidth(null);

                double scaley = h / img.getHeight(null);

                try {

                        AffineTransform xform = AffineTransform.getScaleInstance(scalex,

                                        scaley);

                        AffineTransform xpos = AffineTransform.getTranslateInstance(x, y);

                        xpos.concatenate(xform);

                        g.drawRenderedImage(img, xpos);

                } catch (ImagingOpException e) {

                        NotificationManager.addError("Dibujando FFramePicture", e);

                }

        }

        public void print(Graphics2D g, double scale, PrintRequestAttributeSet arg2)

                        throws ReadDriverException {

                int x = (int) getViewPort().getOffset().getX();

                int y = (int) getViewPort().getOffset().getY();

                int w = (int) g.getClipBounds().getWidth();

                int h = (int) g.getClipBounds().getHeight();

                System.err.println("x " + x + "; y " + y + "; w " + w + "; h" + h);

                Camera viewerCam = _canvas3d.getOSGViewer().getCamera();

                BufferedImage s = null;

                try {

                        int minw = (int) w / 10;

                        int minh = (int) h / 10;

                        System.out.println("minw" + minw + " minh" + minh);

                        _printViewer = new TerrainViewer();

//                        Terrain planetView3D = ((TerrainViewer) _canvas3d.getOSGViewer()).getTerrain(0);

//                        Terrain terrain = new Terrain();

//                        terrain.setCoordinateSystemType(planetView3D

//                                        .getCoordinateSystemType());

//                        terrain.setCoordinateSystemName(planetView3D

//                                        .getCoordinateSystemName());

//                        terrain.setCoordinateSystemFormat(planetView3D

//                                        .getCoordinateSystemFormat());

//                        terrain.setExtent(planetView3D.getExtent());

//                        terrain.setTerrainName(planetView3D.getTerrainName());

//

//

//                        terrain.init();

//                        terrain.setLayerManager(_terrainLayerManager);

                        _printViewer.addTerrain((((TerrainViewer) _canvas3d.getOSGViewer())

                                        .getTerrain(0)));

                        _printViewer.addFeature((((TerrainViewer) _canvas3d.getOSGViewer())

                                        .getFeatures()));

                        Vec4 color = ((TerrainViewer) _canvas3d.getOSGViewer())

                                        .getClearColor();

                        _printViewer.setClearColor(color.x(), color.y(), color.z(), color

                                        .w());

                        _printViewer.setUpViewerInBackground(0, 0, minw, minh);

                        PrintUtilities util = new PrintUtilities();

                        util.setViewer(_printViewer);

                        s = util.getHighResolutionImage(viewerCam, w, h);

                        RenderedImage render = s;

                } catch (NodeException e1) {

                        // TODO Auto-generated catch block

                        e1.printStackTrace();

                }

                double scalex = w / s.getWidth(null);

                double scaley = h / s.getHeight(null);

                try {

                        AffineTransform xform = AffineTransform.getScaleInstance(scalex,

                                        scaley);

                        AffineTransform xpos = AffineTransform.getTranslateInstance(x, y);

                        xpos.concatenate(xform);

                        g.drawRenderedImage(s, xpos);

                        // g.drawRenderedImage(img, new AffineTransform());

                } catch (ImagingOpException e) {

                        NotificationManager.addError("Dibujando FFramePicture", e);

                }

                _printViewer.releaseGLContext();

                _printViewer.dispose();

                System.gc();

        }

        public MapContext3D(ViewPort vp) {

                super(vp);

        }

        public MapContext3D(FLayers fLayers, ViewPort vp) {

                super(fLayers, vp);

        }

        public void setTerrain(Terrain terrain) {

                if (_terrain == terrain)

                        return;

                _terrain = terrain;

                // add layers to terrain necessary when we are loading

                addCurrentLayers();

        }

        public Terrain getTerrain() {

                return _terrain;

        }

        public void setDataManager(JavaDataDriver manager) {

                _terrainDataManager = manager;

                _terrainDataManager.setDataLoader(this);

        }

        public JavaDataDriver getDataManager() {

                return _terrainDataManager;

        }

        public void setLayerManager(LayerManager manager) {

                _terrainLayerManager = manager;

        }

        public LayerManager getLayerManager() {

                return _terrainLayerManager;

        }

        public void setViewer(IViewerContainer canvas) {

                _canvas3d = canvas;

                _terrainViewer = (TerrainViewer) _canvas3d.getOSGViewer();

        }

        public IProjection getViewProjection() {

                return _viewProjection;

        }

        public void setViewProjection(IProjection projection) {

                _viewProjection = projection;

        }

        public IViewerContainer getCanvas3d() {

                return _canvas3d;

        }

        public float getVerticalExaggeration() {

                return _verticalExaggeration;

        }

        public void setVerticalExaggeration(float verticalExaggeration) {

                _verticalExaggeration = verticalExaggeration;

        }

        public void setLoading(boolean bLoading) {

                _bLoading = bLoading;

        }

        public FLayers getNewGroupLayer(FLayers parent) {

                return new FLayers3D(this, parent, getViewPort());

        }

        /** * LAYER CHANGES called by FLayers3D ** */

        public synchronized void layerMoved(FLayers3D parent, FLayer layer, int oldPos,

                        int newPos) {

                if (layer instanceof FLayers) {

                        FLayers group = (FLayers) layer;

                        if (newPos > oldPos) {

                                for (int iChild = group.getLayersCount() - 1; iChild >= 0; iChild--)

                                        layerMoved((FLayers3D) group, group.getLayer(iChild),

                                                        oldPos, newPos);

                        } else {

                                for (int iChild = 0; iChild < group.getLayersCount(); iChild++)

                                        layerMoved((FLayers3D) group, group.getLayer(iChild),

                                                        oldPos, newPos);

                        }

                        return;

                }

                Layer3DProps props3D = getLayer3DProps(layer);

                int type = props3D.getType();

                // Now reorder in layer manager only for terrain layer types

                if ((type == Layer3DProps.layer3DOSG)

                                || ((type == Layer3DProps.layer3DVector)))

                        return;

                // Obtain the old position in the layer

                Layer terrainLayer = _terrainFLayerMap.get(layer);

                Vector<Integer> terrainOldPos = _terrainLayerManager

                                .getOrder(terrainLayer);

                int terrainNewPos = 0;

                // Compute the new position.

                SingleLayerIterator lyrIterator = new SingleLayerIterator(layers);

                while (lyrIterator.hasNext()) {

                        FLayer auxLayer = lyrIterator.next();

                        if (auxLayer == layer)

                                break;

                        Layer3DProps auxProps3D = getLayer3DProps(auxLayer);

                        if ((auxProps3D.getType() != Layer3DProps.layer3DOSG)

                                        && (auxProps3D.getType() != Layer3DProps.layer3DVector)) {

                                terrainNewPos++;

                        }

                }

                if ((terrainOldPos == null) || (terrainOldPos.size() == 0))

                        return;

                if (terrainOldPos.get(0) != terrainNewPos)

                        _terrainLayerManager.moveLayer(terrainOldPos.get(0), terrainNewPos);

                System.out.println("En el toc antes era el " + oldPos + " y ahora el "

                                + newPos);

                System.out.println("En el terrain antes era el " + terrainOldPos

                                + " y ahora el " + terrainNewPos);

                PrintDebugLayers();

        }

        public void layerAdded(FLayers3D parent, FLayer layer) {

                // to add group layers to 3D, just add recursively child data layers

                if (layer instanceof FLayers) {

                        FLayers group = (FLayers) layer;

                        for (int iChild = 0; iChild < group.getLayersCount(); iChild++) {

                                layerAdded((FLayers3D) group, group.getLayer(iChild));

                        }

                        getLayer3DProps(layer).setHooked(true);

                        return;

                }

                if (layer instanceof Classifiable) {

                        Classifiable legendLyr = (Classifiable) layer;

                        // legendLyr.addLegendListener((LegendListener) this);

                        this.addLayerListener(this);

                }

                layer.addLayerListener((LayerListener) this);

                // listener to manage the selection for the layers

                if (layer.getClass().equals(FLyrVect.class)) {

                        FLyrVect lyr = (FLyrVect) layer;

                        try {

                                SelectableDataSource recordSet = lyr.getRecordset();

                                if (recordSet != null) {

                                        SelectionSupport selectionSupport = recordSet

                                                        .getSelectionSupport();

                                        selectionSupport.addSelectionListener(this);

                                }

                        } catch (ReadDriverException e) {

                                // TODO Auto-generated catch block

                                e.printStackTrace();

                        }

                }

                if (!_bLoading)

                        addLayerToTerrain(layer, true);

                // Only do this the first time to add layer

                if (_bEmptyView && !_bLoading) {

                        if (layers.getLayersCount() > 0) {

                                try {

                                        zoomToExtent(layer.getFullExtent());

                                } catch (ExpansionFileReadException e) {

                                        e.printStackTrace();

                                } catch (ReadDriverException e) {

                                        e.printStackTrace();

                                }

                                _bEmptyView = false;

                        }

                }

                PrintDebugLayers();

        }

        public void layerRemoved(FLayers3D parent, FLayer layer) {

                // to remove group layers to 3D, just remove recursively child data

                // layers

                if (layer instanceof FLayers) {

                        FLayers group = (FLayers) layer;

                        for (int iChild = 0; iChild < group.getLayersCount(); iChild++) {

                                layerRemoved((FLayers3D) group, group.getLayer(iChild));

                        }

                        getLayer3DProps(layer).setHooked(false);

                        return;

                }

                if (layer instanceof Classifiable) {

                        Classifiable legendLyr = (Classifiable) layer;

                        legendLyr.removeLegendListener((LegendListener) this);

                }

                layer.removeLayerListener((LayerListener) this);

                removeLayerToTerrain(layer);

                // All layers are removed

                if (layers.getLayersCount() == 0) {

                        _bEmptyView = true;

                }

                PrintDebugLayers();

        }

        /**

         * DOCUMENT ME!

         *

         * @param e

         *            DOCUMENT ME!

         */

        public void legendChanged(LegendChangedEvent e) {

                if (!_bListenToLegend)

                        return;

                if ((e == null) && (!visibilityChange)) {

                        // find layer whose legend changed

                        FLayer found = null;

                        SingleLayerIterator lyrIterator = new SingleLayerIterator(layers);

                        while (lyrIterator.hasNext()) {

                                FLayer lyr = lyrIterator.next();

                                if (lyr instanceof FLyrVect) {

                                        FLyrVect lyrVect = (FLyrVect) lyr;

                                        long newDrawVersion = lyrVect.getDrawVersion();

                                        Layer3DProps props3D = getLayer3DProps(lyrVect);

                                        if (newDrawVersion != props3D.drawVersion) {

                                                props3D.drawVersion = lyrVect.getDrawVersion();

                                                refreshLayerInTerrain(props3D, true);

                                                _bListenToLegend = false;

                                                props3D.VerifyLegend(_terrain.getTerrainName());

                                                _bListenToLegend = true;

                                        }

                                }

                        }

                        IWindow f = PluginServices.getMDIManager().getActiveWindow();

                        if (f instanceof BaseView) {

                                BaseView view3D = (BaseView) f;

                                view3D.getTOC().refresh();

                        }

                }

                visibilityChange = false;

        }

        public void visibilityChanged(LayerEvent e) {

                FLayer lyr = e.getSource();

                Layer3DProps props3D = getLayer3DProps(lyr);

                if (props3D.getType() == Layer3DProps.layer3DVector) {

                        refreshLayerVectorsVisibility(lyr);

                } else if (props3D.getType() == Layer3DProps.layer3DOSG) {

                        refreshLayer3DOSGVisibility(lyr);

                } else {

                        refreshLayerVisibility(lyr);

                }

                visibilityChange = true;

        }

        private void refreshLayer3DOSGVisibility(FLayer lyr) {

                if (_terrain == null || _viewProjection == null)

                        return;

                Layer3DProps props3D = getLayer3DProps(lyr);

                OSGCacheService cacheService = (OSGCacheService) props3D

                                .getCacheService();

                if (cacheService != null) {

                        // use VectorCacheService to add features to terrain

                        cacheService.refreshFeaturesToTerrain(lyr.isVisible());

                }

        }

        private void refreshLayerVisibility(FLayer layer) {

                Layer terrainLayer = _terrainFLayerMap.get(layer);

                terrainLayer.setEnabled(layer.isVisible());

                _terrainLayerManager.updateLayers();

        }

        private void refreshLayerVectorsVisibility(FLayer lyr) {

                if (_terrain == null || _viewProjection == null)

                        return;

                Layer3DProps props3D = getLayer3DProps(lyr);

                VectorCacheService cacheService = (VectorCacheService) props3D

                                .getCacheService();

                if (cacheService != null) {

                        // use VectorCacheService to add features to terrain

                        cacheService.refreshFeaturesToTerrain(lyr.isVisible());

                        props3D.drawVersion = lyr.getDrawVersion();

                }

        }

        public void activationChanged(LayerEvent e) {

                // TODO Implement this method

        }

        public void nameChanged(LayerEvent e) {

                // TODO Implement this method

        }

        public void editionChanged(LayerEvent e) {

                // TODO Implement this method

        }

        public void refreshLayerInTerrain(Layer3DProps props, boolean bRemoveCache) {

                if (props == null)

                        return;

                if (_terrain == null)

                        return; // view not opened yet

                // clear cache

                if (bRemoveCache) {

                        String layerCacheDir = Layer3DProps.m_cacheDir + "/"

                                        + _terrain.getTerrainName() + "/" + props.getCacheName();

                        removeCache(layerCacheDir);

                }

                // refresh layer in terrain

                int type = props.getType();

                if ((type == Layer3DProps.layer3DImage)||(type == Layer3DProps.layer3DElevation)||

                                (type == Layer3DProps.layer3DVectorMR)) {

                        _terrainLayerManager.invalidateLayer(props.getTerrainLayer());

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

                        invalidateVectorLayer(props);

                }

        }

        private void invalidateVectorLayer(Layer3DProps props) {

                // TODO Auto-generated method stub

                if (_terrain == null || _viewProjection == null)

                        return;

                VectorCacheService cacheService = (VectorCacheService) props

                                .getCacheService();

                if (cacheService != null) {

                        // use VectorCacheService to add features to terrain

                        cacheService.refreshFeaturesToTerrain();

                }

        }

        private boolean removeCache(String folder) {

                File dir = new File(folder);

                if (dir.isDirectory()) {

                        String[] children = dir.list();

                        for (int i = 0; i < children.length; i++) {

                                boolean success = removeCache(folder + "/" + children[i]);

                                // Do not interrupt if it can't delete one file

                                // if (!success) {

                                // return false;

                                // }

                        }

                }

                // The directory is now empty so delete it

                return dir.delete();

        }

        protected Layer3DProps getLayer3DProps(FLayer layer) {

                Layer3DProps props3D = Layer3DProps.getLayer3DProps(layer);

                // Create instance of props for osg layers.

                if (props3D == null) {

                        props3D = new Layer3DProps();

                        if (layer instanceof FLyrVect) {

                                FLyrVect nLayer = (FLyrVect) layer;

                                Driver driver;

                                try {

                                        driver = nLayer.getRecordset().getDriver();

                                        if (driver instanceof GvsigDriverOSG) {

                                                props3D.setChooseType(false);

                                                props3D.setType(Layer3DProps.layer3DOSG);

                                        }

                                } catch (ReadDriverException e) {

                                        // TODO Auto-generated catch block

                                        e.printStackTrace();

                                }

                        }

                        // Set the properties

                        props3D.setLayer(layer);

                        props3D.initCacheName(_terrain.getCoordinateSystemType(),

                                        _viewProjection, Terrain.CoordinateSystemType.GEOCENTRIC);

                        FLyrDefault baseLayer = (FLyrDefault) layer;

                        baseLayer.setProperty("3DLayerExtension", props3D);

                        props3D.setVerticalEx(getVerticalExaggeration());

                } else {

                        if (_bLoading)

                                props3D.setChooseType(false);

                        props3D.setLayer(layer);

                }

                return props3D;

        }

        public void addCurrentLayers() {

                SingleLayerIterator lyrIterator = new SingleLayerIterator(layers);

                while (lyrIterator.hasNext()) {

                        FLayer layer = lyrIterator.next();

                        Layer3DProps props = getLayer3DProps(layer);

                        // props.setTerrainOrder(props.getTocOrder());

                        addLayerToTerrain(layer, false);

                }

        }

        public synchronized void addLayerToTerrain(FLayer layer, boolean bVerifyLegend) {

                Layer3DProps props3D = getLayer3DProps(layer);

                if (props3D.getType() == Layer3DProps.layer3DVector) {

                        CreateVectors(layer, props3D); // special case for now without

                        // disk cache

                } else if (props3D.getType() == Layer3DProps.layer3DOSG) {

                        CreateOSGLayer(layer, props3D);

                } else {

                        Rectangle2D layerExtent = null;

                        try {

                                layerExtent = layer.getFullExtent();

                        } catch (ExpansionFileReadException e) {

                                e.printStackTrace();

                        } catch (ReadDriverException e) {

                                e.printStackTrace();

                        }

                        if (layerExtent == null) { // hack for missing extents

                                if (_terrain.getCoordinateSystemType() == Terrain.CoordinateSystemType.GEOCENTRIC)

                                        layerExtent = new Rectangle2D.Double(-180.0, -90.0, 360.0,

                                                        180.0);

                                else

                                        layerExtent = new Rectangle2D.Double(-20000000.0,

                                                        -10000000.0, 40000000.0, 20000000.0);

                                // TODO toggle comment because this code use WCS extension. When

                                // WCS extension runs correctly uncoment!!!

                                if (layer instanceof FLyrWCS)

                                        ((FLyrWCS) layer).setFullExtent(layerExtent);

                        }

                        Extent extent = null;

                        if (_terrain.getCoordinateSystemType() == CoordinateSystemType.PROJECTED) {

                                extent = new Extent(layerExtent.getMinX(), layerExtent

                                                .getMinY(), layerExtent.getMaxX(), layerExtent

                                                .getMaxY());

                        } else {

                                extent = new Extent(Math.toRadians(layerExtent.getMinX()), Math

                                                .toRadians(layerExtent.getMinY()), Math

                                                .toRadians(layerExtent.getMaxX()), Math

                                                .toRadians(layerExtent.getMaxY()));

                        }

                        if (props3D.getType() == Layer3DProps.layer3DImage) {

                                RasterLayer rlayer = new RasterLayer();

                                rlayer.setEnabled(layer.isVisible());

                                rlayer.setExtent(extent);

                                rlayer.setOpacity(props3D.getOpacity());

                                rlayer.setDataDriver(_terrainDataManager);

                                _terrainLayerManager.addLayer(rlayer);

                                _terrainFLayerMap.put(layer, rlayer);

                                _terrainLayerMap.put(rlayer.getLayerID(), layer);

                                props3D.setTerrainLayer(rlayer);

                        } else if (props3D.getType() == Layer3DProps.layer3DElevation) {

                                HeightfieldLayer hlayer = new HeightfieldLayer();

                                hlayer.setEnabled(layer.isVisible());

                                hlayer.setExtent(extent);

                                hlayer.setVerticalExaggeration(props3D.getVerticalEx());

                                hlayer.setDataDriver(_terrainDataManager);

                                _terrainLayerManager.addLayer(hlayer);

                                _terrainFLayerMap.put(layer, hlayer);

                                _terrainLayerMap.put(hlayer.getLayerID(), layer);

                                props3D.setTerrainLayer(hlayer);

                        } else if (props3D.getType() == Layer3DProps.layer3DVectorMR) {

                                VectorLayer vlayer = new VectorLayer();

                                vlayer.setEnabled(true);

                                vlayer.setExtent(extent);

                                vlayer.setDensity(1.0f);

                                vlayer.setDataDriver(_terrainDataManager);

                                _terrainLayerManager.addLayer(vlayer);

                                _terrainFLayerMap.put(layer, vlayer);

                                _terrainLayerMap.put(vlayer.getLayerID(), layer);

                                props3D.setTerrainLayer(vlayer);

                        }

                        if (bVerifyLegend) {

                                _bListenToLegend = false;

                                props3D.VerifyLegend(_terrain.getTerrainName());

                                _bListenToLegend = true;

                        }

                }

        }

        private void CreateOSGLayer(FLayer layer, Layer3DProps props3D) {

                if (_terrain == null || _viewProjection == null)

                        return;

                OSGCacheService cacheService = (OSGCacheService) props3D

                                .getCacheService();

                if (cacheService == null) {

                        cacheService = new OSGCacheService(_canvas3d, _terrain, props3D

                                        .getCacheName(), layer, _viewProjection);

                        cacheService.setCacheRootDir(Layer3DProps.m_cacheDir);

                        props3D.setCacheService(cacheService);

                }

                // use VectorCacheService to add features to planet

                cacheService.AddFeaturesToTerrain();

        }

        @Override

        public XMLEntity getXMLEntity() throws XMLException {

                // TODO Auto-generated method stub

                XMLEntity xml = super.getXMLEntity();

                SingleLayerIterator lyrIterator = new SingleLayerIterator(layers);

                while (lyrIterator.hasNext()) {

                        FLayer lyr = lyrIterator.next();

                        Layer3DProps props3D = getLayer3DProps(lyr);

                        int type = props3D.getType();

                        if (type == Layer3DProps.layer3DOSG) {

                                OSGCacheService cacheService = (OSGCacheService) props3D

                                                .getCacheService();

                                if (cacheService != null) {

                                        // use VectorCacheService to add features to planet

                                        if (props3D.isEditing()) {

                                                // TODO: PONER AKI EL CODIGO DE SALVAR

                                        }

                                }

                        }

                }

                return xml;

        }

        private void CreateVectors(FLayer layer, Layer3DProps props3D) {

                if (_terrain == null || _viewProjection == null)

                        return;

                VectorCacheService cacheService = (VectorCacheService) props3D

                                .getCacheService();

                if (cacheService == null) {

                        cacheService = new VectorCacheService(_canvas3d, _terrain, props3D

                                        .getCacheName(), layer, _viewProjection);

                        cacheService.setCacheRootDir(Layer3DProps.m_cacheDir);

                        props3D.setCacheService(cacheService);

                }

                // use VectorCacheService to add features to terrain

                cacheService.addFeaturesToTerrain();

        }

        private void DeleteVectors(FLayer layer, Layer3DProps props3D) {

                if (_terrain == null || _viewProjection == null)

                        return;

                VectorCacheService cacheService = (VectorCacheService) props3D

                                .getCacheService();

                if (cacheService != null) {

                        // use VectorCacheService to delete features to terrain

                        cacheService.deleteFeaturesToTerrain();

                }

        }

        /**

         * Sets the given zoom extent to the view

         *

         * @param extent

         *            The extent to zoom to.

         */

        public void zoomToExtent(Rectangle2D geoExtent) {

                double maxHeight = 0.0;

                // Getting extent positions

                double minLat = geoExtent.getMinY();

                double maxLat = geoExtent.getMaxY();

                double cenLon = geoExtent.getCenterX();

                double cenLat = geoExtent.getCenterY();

                double elevation = 0;

                // calculate altitude

                double avLat = 0;

                if (minLat > 0.0 || maxLat < 0.0)

                        avLat = Math.min(Math.abs(minLat), Math.abs(maxLat));

                double avLon = Math.min(180.0, geoExtent.getWidth());

                double terrainRadius = _terrain.getRadiusEquatorial();

                double radiusLat = terrainRadius * Math.cos(Math.toRadians(avLat));

                double deltaLon = Math.sqrt(2 * radiusLat * radiusLat

                                * (1 - Math.cos(Math.toRadians(avLon))));

                double deltaLat = Math.sqrt(2 * terrainRadius * terrainRadius

                                * (1 - Math.cos(Math.toRadians(geoExtent.getHeight()))));

                double zoomFactor = 1.5;

                elevation = (Math.max(deltaLon, deltaLat) * zoomFactor) + maxHeight;

                // Calculate XYZ positions for camera.

                int terrainType = _terrain.getCoordinateSystemType();

                Vec3 eye = new Vec3();

                Vec3 center = new Vec3();

                Vec3 up = new Vec3();

                // Calculate positions for PLAIN MODE.

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

                        double difx = (geoExtent.getMaxX() - geoExtent.getX()) / 1.2d;

                        double dify = (geoExtent.getMaxY() - geoExtent.getY()) / 1.2d;

                        double height;

                        height = Math.sqrt(difx * difx + dify * dify);

                        double fullWindowFactor = 1.7;

                        // EYE

                        eye.setX(cenLon);

                        eye.setY(cenLat);

                        eye.setZ(height * fullWindowFactor);

                        // CENTER

                        center.setX(cenLon);

                        center.setY(cenLat);

                        center.setZ(0.0);

                        // UP

                        up.setX(0.0);

                        up.setY(1.0);

                        up.setZ(0.0);

                } else

                // Calculate positions for SPHERICAL MODE.

                if (terrainType == Terrain.CoordinateSystemType.GEOCENTRIC) {

                        // EYE

                        Vec3 aux = new Vec3(cenLat, cenLon, elevation);

                        eye = _terrain.convertLatLongHeightToXYZ(aux);

                        // CENTER

                        center.setX(0.0);

                        center.setY(0.0);

                        center.setZ(0.0);

                        // UP

                        up.setX(0.0);

                        up.setY(0.0);

                        up.setZ(1.0);

                }

                Camera cam = new Camera();

                cam.setViewByLookAt(eye, center, up);

                _terrainViewer.setCamera(cam);

        }

        private void PrintDebugLayers() {

                if (_terrainLayerManager != null) {

                        System.out.println("===========================");

                        System.out.println("Total terrain layers: "

                                        + _terrainLayerManager.getNumLayers());

                        System.out.println("===========================");

                }

                SingleLayerIterator lyrIterator = new SingleLayerIterator(layers);

                int pos = 0;

                while (lyrIterator.hasNext()) {

                        FLayer layer = lyrIterator.next();

                        System.out.println("  Layer " + layer.getName());