Application: gvSIG desktop » gvSIG raster

/* 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.raster.fmap.layers;

import java.util.ArrayList;

import java.util.HashMap;

import org.gvsig.fmap.dal.coverage.RasterLocator;

import org.gvsig.fmap.dal.coverage.datastruct.Extent;

import org.gvsig.fmap.dal.coverage.grid.render.Render;

import org.gvsig.fmap.mapcontext.MapContext;

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

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

/**

 * Aplica estrategias de dibujado para las capas raster. Hace que las 

 * capas que est?n ocultas por otras no sean dibujadas. Esta estrategia tiene que ser

 * aplicada a capas raster de FMap por falta de eficiencia en el dibujado. Esta clase

 * es totalmente dependiente de FMap y puede ser eliminada en caso de que este no exita.

 * 28/11/2007

 * @author Nacho Brodin nachobrodin@gmail.com

 */

public class RasterDrawStrategy {

        /**

         * Cada mapContext existente lleva asociadad una estrategia de dibujado

         */

        public static HashMap<MapContext, HashMap<DefaultFLyrRaster, Boolean>>        

                                     mapContextStrategy    = new HashMap<MapContext, HashMap<DefaultFLyrRaster, Boolean>> ();

        private MapContext           mapContext            = null;

        private DefaultFLyrRaster         lyrRaster             = null;

        /**

         * Estructura de datos para almacenar la asociaci?n entre el extent de una capa

         * y su informaci?n de transparencia. Esta es necesaria para la comprobaci?n de si la 

         * capa con la que se est? intersectando tiene transparencia o no la tiene. Con esto 

         * se puede decidir si dibujar la capa actual o no.

         * 16/06/2008

         * @author Nacho Brodin nachobrodin@gmail.com

         */

        public class LayerIntersection {

                public Extent  extent          = null;

                public boolean hasTransparency = false;

                /**

                 * Constructor. Asigna el Extent y la informaci?n de transparencia

                 * @param ext Extent

                 * @param transp Transparencia

                 */

                public LayerIntersection(Extent ext, boolean transp) {

                        this.extent = ext;

                        this.hasTransparency = transp;

                } 

        }

        /**

         * Al constructor le pasamos el contexto de dibujado para la toma de decisi?n.

         * @param mapContext Context

         * @throws ExpansionFileReadException

         * @throws ReadDriverException

         */

        public RasterDrawStrategy(MapContext mapContext, DefaultFLyrRaster lyrRaster) {

                this.mapContext = mapContext;

                this.lyrRaster = lyrRaster;

        }

        /**

         * <P>

         * Estrategia de dibujado para las capas raster que hace que si

         * una capa est? oculta completamente por otra que no tiene transparencias entonces

         * esta no ser? dibujada.

         * </P>

         * <P>

         * La estrategia la calcula solo la primera capa raster que aparezca. El resto

         * de las capas la preguntaran a esta.

         * </P>

         * <P>

         * <code>Estrategia:</code>

         * Analizamos la lista de capas desde la primera que se dibuja en el TOC hasta la ?ltima

         * <UL>

         * <LI>Si la capa tiene rotaci?n se dibuja siempre.</LI>

         * <LI>Si la capa no est? activa en el TOC no se dibuja nunca</LI>

         * <LI>Si la capa no es transparente y no hay extents en la lista se dibuja y se a?ade el extent a la lista</LI>

         * <LI>Si el extent de la capa intersecta con uno de la lista</LI>

         * </UL>

         * Comprobamos si est? detr?s de un extent de la lista. Si es as? no se dibuja

         * Si no est? est? detr?s de un extent comprobamos si tiene transparencias

         * Si no tiene transparencias a?adimos el extent a la lista

         * </P>

         * @param lyrs

         * @throws ReadDriverException 

         * @throws ExpansionFileReadException 

         */

        public void stackStrategy() {

                if(mapContext == null || lyrRaster == null)

                        return;

                ArrayList<FLayer> listLayers = new ArrayList<FLayer>();

                FLayers lyrs = mapContext.getLayers();

                listLayers = getLayerList(lyrs, listLayers);

                ArrayList<LayerIntersection> extentList = new ArrayList<LayerIntersection>();

                //Solo la primera capa calcula la estrategia. Las dem?s se la preguntan a esta.

                //Calculamos cual es la primera capa raster de FLayers y contamos cuantas capas raster hay

                int posFirstRasterLayer = 0;

                int nRasterLayers = 0;

                boolean firstTime = true;

                for (int i = 0; i < listLayers.size(); i++) {

                        FLayer lyr = (FLayer) listLayers.get(i);

                        if(firstTime && lyr instanceof DefaultFLyrRaster && lyr.isVisible()) {

                                posFirstRasterLayer = i;

                                firstTime = false;

                        }

                        if(lyr instanceof DefaultFLyrRaster)

                                nRasterLayers ++;

                }

                //Si hay solo una capa raster no se calcula ninguna estrategia

                if(nRasterLayers == 1) {

                        mapContextStrategy.put(mapContext, null);

                        return;

                }

                //Si no es la primera capa se obtiene la estrategia que calcul? la primera capa

                if(lyrRaster != listLayers.get(posFirstRasterLayer)) {

                        if(!(listLayers.get(posFirstRasterLayer) instanceof DefaultFLyrRaster))

                                return;

                        mapContextStrategy.put(mapContext, ((DefaultFLyrRaster)listLayers.get(posFirstRasterLayer)).getRasterStrategy());

                        return;

                }

                HashMap<DefaultFLyrRaster, Boolean> layersToPaint = new HashMap<DefaultFLyrRaster, Boolean>();

                //Calculo de estrategia. Solo llega aqu? la primera capa.

                //La lista de capas en FLayers est? en orden inverso a lo que aparece en el TOC, es decir, la ?ltima capa

                //del TOC es la primera de la lista de FLayers y la primera del TOC es la ?ltima de la lista.

                for (int i = (listLayers.size() - 1); i >= 0; i--) {

                        FLayer lyr = (FLayer) listLayers.get(i);

                        if (!(lyr instanceof DefaultFLyrRaster))

                                continue;

                        DefaultFLyrRaster rLyr = ((DefaultFLyrRaster)lyr);

                        if(rLyr.getRender() == null || rLyr.getRender().getFilterList() == null || rLyr.getFullEnvelope() == null)

                                continue;

                        //Si no est? activa y/o visible no se dibuja nunca 

                        if(!rLyr.isVisible()) {

                                layersToPaint.put(rLyr, new Boolean(false));

                                continue;

                        }

                        //Si tiene rotaci?n se dibuja siempre

                        if(rLyr.getAffineTransform() != null) {

                                if(        rLyr.getAffineTransform().getShearX() != 0 || 

                                                rLyr.getAffineTransform().getShearY() != 0) {

                                        layersToPaint.put(rLyr, new Boolean(true));

                                        continue;

                                }

                        }

                        //Si es la primera metemos el extent en la lista y se dibuja

                        //Si no es la primera y no intersecta con ning?n extent. Metemos el extent y dibujamos                        

                        LayerIntersection li = areIntersecting(extentList, rLyr);

                        if((i == (listLayers.size() - 1)) || li == null) {

                                boolean colorTableAlpha = false;

                                if(rLyr.getRender().getFilterList() != null) { 

                                        Render render = rLyr.getRender();

                                        if(render != null) {

                                                if(render.getColorTable() != null)

                                                        colorTableAlpha = render.getColorTable().hasAlpha();

                                        }

                                }

                                extentList.add(new LayerIntersection(rLyr.getFullRasterExtent(), (rLyr.existsAlphaBand() || rLyr.isTransparent() || colorTableAlpha)));

                                layersToPaint.put(rLyr, new Boolean(true));

                                continue;

                        }

                        //Si con la que intersecta no tiene transparencia no se dibuja

                        if(li != null && !li.hasTransparency) {

                                layersToPaint.put(rLyr, new Boolean(false));

                                continue;

                        }

                        if(!rLyr.isTransparent())

                                li.hasTransparency = false;

                        layersToPaint.put(rLyr, new Boolean(true));                        

                }

                mapContextStrategy.put(mapContext, layersToPaint);

        }

        /**

         * Obtiene la lista de capas del TOC. Si hay capas agrupadas lo tiene en cuenta y mira

         * dentro de la agrupaci?n.

         * @param srcLyrs

         * @param destLyrs

         * @return

         */

        public static ArrayList<FLayer> getLayerList(FLayers srcLyrs, ArrayList<FLayer> destLyrs) {

                for (int i = 0; i < srcLyrs.getLayersCount(); i++) {

                        if(srcLyrs.getLayer(i) instanceof DefaultFLyrRaster)

                                destLyrs.add(srcLyrs.getLayer(i));

                        if(srcLyrs.getLayer(i) instanceof FLayers)

                                destLyrs = getLayerList((FLayers)srcLyrs.getLayer(i), destLyrs);

                }

                return destLyrs;

        }

        /**

         * Comprueba si la capa que se pasa por par?metro est? oculta por alguno

         * de los extent de la lista

         * @param extentList Lista de extensiones

         * @param lyr Capa raster

         * @return 

         */

        private LayerIntersection areIntersecting(ArrayList<LayerIntersection> extentList, DefaultFLyrRaster lyr) {

                for (int i = 0; i < extentList.size(); i++) {

                        Extent ex = lyr.getFullRasterExtent();

                        Extent ex1 = ((LayerIntersection)extentList.get(i)).extent;

                        if(RasterLocator.getManager().getRasterUtils().isInside(ex, ex1))

                                return ((LayerIntersection)extentList.get(i));

                }

                return null;

        }

        /**

         * Obtiene un TreeMap con la lista de capas que se dibujan. Si se al TreeMap se

         * le pasa como par?metro una capa raster y devuelve null es que no se dibuja.

         *  

         * @return TreeMap con la lista de capas a dibujar.

         */

        public HashMap<DefaultFLyrRaster, Boolean> getStrategy() {

                return (HashMap<DefaultFLyrRaster, Boolean>)mapContextStrategy.get(mapContext);

        }

}