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.List;

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

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

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

import org.gvsig.fmap.dal.coverage.exception.FileNotFoundInListException;

import org.gvsig.fmap.dal.coverage.exception.FilterManagerException;

import org.gvsig.fmap.dal.coverage.exception.FilterTypeException;

import org.gvsig.fmap.dal.coverage.exception.InvalidSourceException;

import org.gvsig.fmap.dal.coverage.exception.NotSupportedExtensionException;

import org.gvsig.fmap.dal.coverage.exception.OperationNotSupportedException;

import org.gvsig.fmap.dal.coverage.exception.RasterDriverException;

import org.gvsig.fmap.dal.coverage.grid.RasterFilterList;

import org.gvsig.fmap.dal.coverage.grid.RasterFilterListManager;

import org.gvsig.fmap.dal.coverage.store.RasterDataStore;

import org.gvsig.fmap.dal.coverage.store.props.ColorInterpretation;

import org.gvsig.fmap.dal.coverage.store.props.ColorTable;

import org.gvsig.fmap.dal.coverage.store.props.Transparency;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

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

/**

 * Esta clase almacena el estado de un raster en cuanto a las caracteristicas

 * de opacidad, bandas y filtros. Estas caracter?sticas pueden ser salvadas a 

 * un xml y recuperadas por la capa a trav?s de las funciones setXMLEntity y 

 * getXMLEntity

 * 

 * @deprecated

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class StatusLayerRaster implements IStatusRaster {

        public static String                         defaultClass    = "org.gvsig.fmap.raster.layers.StatusLayerRaster";

        //Valor de opacidad global de la imagen

        public int                                                transparency    = 255;

        //Rangos de transparencia

        public ArrayList<TransparencyRange>                

                                        ranges          = new ArrayList<TransparencyRange>();

        //(Selecci?n de bandas)N?mero de banda  asignado al Rojo, verde y azul         

        public int                                                 bandR           = 0;

        public int                                                 bandG           = 1;

        public int                                                 bandB           = 2;

        public List<String>                        files           = new ArrayList<String>();

        //Filtros para poder montar una nueva pila

        public List<String>                        filters         = new ArrayList<String>();

        private DefaultFLyrRaster       layer           = null;

        private int                     alphaBandNumber = -1;

        //Utilizado para la persistencia

        private boolean                                 loadClass                = false;

        public void loadFromState(PersistentState state, DefaultFLyrRaster layer)throws PersistenceException {

//                this.layer = layer;

//                //RECUPERAR PROPIEDADES

//                

//                //Recuperamos las propiedades de los filtros

//                for(int i = 0; i < xml.getPropertyCount(); i++) {

//                        if(xml.getPropertyName(i).startsWith("filter."))        

//                                filters.add(xml.getPropertyName(i) + "=" + xml.getPropertyValue(i));

//                }

//                

//                //Rangos de transparencia

//                if (xml.contains("filter.transparency.active") && xml.getBooleanProperty("filter.transparency.active")) {

//                        int i = 0;

//                        String value = null;

//                        while(true) {

//                                if(xml.contains("filter.transparency.transparencyRange" + i)) {

//                                        value = xml.getStringProperty("filter.transparency.transparencyRange" + i);

//                                        int alpha = 0;

//                                        if(value.indexOf("@") != 0) {

//                                                try {

//                                                        alpha = Integer.parseInt(value.substring(value.indexOf("@") + 1, value.length()));

//                                                } catch (NumberFormatException e) {

//                                                        alpha = 0;

//                                                }

//                                                if(value.indexOf("@") != -1)

//                                                        value = value.substring(0, value.indexOf("@"));

//                                        }

//                                        TransparencyRange range = new TransparencyRange(value);

//                                        if(alpha != 0)

//                                                range.setAlpha(alpha);

//                                        ranges.add(range);

//                                } else 

//                                        break;

//                                i ++;

//                        }

//                }

//                

//                if(xml.contains("filter.transparency.bandnumber")) 

//                        alphaBandNumber = xml.getIntProperty("filter.transparency.bandnumber");

//                

//                if (xml.contains("raster.opacityLevel")) {

//                        transparency = xml.getIntProperty("raster.opacityLevel");

//                        //Esto soluciona un problema de compatibilidad entre branch v10 y HEAD. Eliminar en futuras versiones

//                        if(nameClass != null && nameClass.compareTo("com.iver.cit.gvsig.fmap.layers.StatusLayerRaster") == 0)

//                                transparency = 255 - transparency;

//                }

//                                

//                if (xml.contains("raster.bandR")) 

//                        bandR = xml.getIntProperty("raster.bandR");

//                

//                if (xml.contains("raster.bandG")) 

//                        bandG = xml.getIntProperty("raster.bandG");

//                

//                if (xml.contains("raster.bandB")) 

//                        bandB = xml.getIntProperty("raster.bandB");

//                

//        

//                int cont = 0;

//                while(true && cont < 50) {

//                        if (xml.contains("raster.file" + cont)) {

//                                files.add(xml.getStringProperty("raster.file" + cont));

//                                cont++;

//                        }else 

//                                break;

//                }

        }        

        @SuppressWarnings("unchecked")

        public void loadFromState(PersistentState state)

                        throws PersistenceException {

                this.transparency = state.getInt("transparency");

                this.bandR = state.getInt("bandR");

                this.bandG = state.getInt("bandG");

                this.bandB = state.getInt("bandB");

                this.alphaBandNumber = state.getInt("alphaBandNumber");

                this.loadClass = state.getBoolean("loadClass");

                this.layer = (DefaultFLyrRaster)state.get("layer");

                this.ranges = new ArrayList(state.getList("ranges"));

                this.files = new ArrayList(state.getList("files"));

                this.filters = new ArrayList(state.getList("filters"));

        }

        public void saveToState(PersistentState state) throws PersistenceException {

                state.set("transparency", this.transparency);

                state.set("bandR", this.bandR);

                state.set("bandG", this.bandG);

                state.set("bandB", this.bandB);

                state.set("alphaBandNumber", this.alphaBandNumber);

                state.set("loadClass",this.loadClass);

                state.set("layer", this.layer);

                state.set("ranges", this.ranges);

                state.set("files", this.files);

                state.set("filters",this.filters);

        }

        public void setStateProperties(boolean loadClass, DefaultFLyrRaster layer) throws PersistenceException {

                this.layer = layer;

                this.loadClass = loadClass;

        }

        public static void registerPersistence() {

                PersistenceManager manager = ToolsLocator.getPersistenceManager();

                DynStruct definition = manager.addDefinition(StatusLayerRaster.class,

                                "StatusLayerRaster_Persistent",

                                "StatusLayerRaster Persistent definition (FIXME loadClass)", null, null);

                definition.addDynFieldInt("transparency");

                definition.addDynFieldInt("bandR").setMandatory(true);

                definition.addDynFieldInt("bandG").setMandatory(true);

                definition.addDynFieldInt("bandB").setMandatory(true);

                definition.addDynFieldInt("alphaBandNumber");

                definition.addDynFieldBoolean("loadClass");

                definition.addDynFieldObject("layer")

                        .setClassOfValue(DefaultFLyrRaster.class);

                definition.addDynFieldList("ranges")

                        .setClassOfItems(TransparencyRange.class);

                definition.addDynFieldList("files")

                        .setClassOfItems(String.class);

                definition.addDynFieldList("filters")

                        .setClassOfItems(String.class);

        }

        public List<String> getFilters() {

                return this.filters;

        }

        public void applyStatus(DefaultFLyrRaster layer) throws NotSupportedExtensionException, RasterDriverException, FilterTypeException, FileNotFoundInListException, OperationNotSupportedException, FilterManagerException, InvalidSourceException {

                //Eliminamos el fichero inicial y cargamos las bandas si hay para que se carguen 

                //en el orden correcto

                if(layer instanceof DefaultFLyrRaster) {

                        if(files != null && files.size() != 0){

                                //((FLyrRasterSE)layer).delFile((String)files.get(0));

                                for (int i = 1; i < files.size(); i++) 

                                        ((DefaultFLyrRaster)layer).addFile((String)files.get(i));

                        }

                }

                //Asigna las bandas

                String[] valuesCI = new String[layer.getDataStore().getBandCount()];

                valuesCI[bandR] = ColorInterpretation.RED_BAND;

                valuesCI[bandG] = ColorInterpretation.GREEN_BAND;

                valuesCI[bandB] = ColorInterpretation.BLUE_BAND;

                ColorInterpretation ci = RasterLocator.getManager().getDataStructFactory().createColorInterpretation(valuesCI);

                if(layer.getRender() != null)

                        layer.getRender().setRenderColorInterpretation(ci);

                //Asigna la transparencia

                Transparency transp = layer.getRender().getRenderingTransparency(); 

                if(transp != null && transparency != 255) { 

                        transp.setOpacity(transparency);

                        transp.activeTransparency();

                }

                //Rangos de transparencia

                if(transp != null && ranges != null) {

                        transp.setTransparencyRangeList(ranges);

                        transp.activeTransparency();

                }

                //Banda de transparencia

                if(transp != null && alphaBandNumber != -1) {

                        transp.setTransparencyBand(alphaBandNumber);

                        transp.activeTransparency();

                }

                //Filtros

                /*if (layer.getRender().getFilterList() != null) {

                        layer.getRender().getFilterList().createFilterListFromStrings((ArrayList<String>)filters);

                        enhancedCompV10((ArrayList<String>)filters, layer);

                        //sortFilters(layer.getRenderFilterList());

                }*/

                //Refrescamos todas las vistas

                layer.getMapContext().invalidate();

                /*IWindow[] w = PluginServices.getMDIManager().getAllWindows();

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

                        if(w[i] != null && w[i] instanceof AbstractViewPanel) 

                                ((AbstractViewPanel)w[i]).getMapControl().getMapContext().invalidate();        

                }*/

        }

        /**

         * M?todo para mantener la compatibilidad con la v10 del realce. El realce de la v10 no

         * aporta suficiente informaci?n por lo que se a?ade un filtro de realce generico v1.9

         * @param filterArguments

         * @param layer

         * @param filterListManager

         * @throws FilterTypeException

         * @throws FilterManagerException 

         */

        public static void enhancedCompV10(ArrayList<String> filterArguments, DefaultFLyrRaster layer) throws FilterTypeException, FilterManagerException {

                RasterFilterList filterList = layer.getRender().getFilterList();

                filterList.remove("enhanced_stretch");

                filterList.remove("tailTrim");

                /*boolean removed = false;

                RasterFilterList list = layer.getRender().getFilterList();

                for (int i = 0; i < list.lenght(); i++) {

                        RasterFilter f = list.get(i); 

                        if(f instanceof TailTrimFilter || f instanceof LinearEnhancementFilter) { 

                                list.remove(f.getName());

                                removed = true;

                        }

                }

                if(removed)

                        list.controlTypes();*/

                //Para compatibilidad de realce con proyectos antiguos

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

                        if(((String)filterArguments.get(i)).startsWith("filter.enhanced.active=true")) {

                                RasterFilterListManager enhancementManager = filterList.getManagerByID("EnhancementStretch");

                                Params params = filterList.createEmptyFilterParams();

                                params.setParam("stats", ((RasterDataStore)layer.getDataStore()).getStatistics());

                                params.setParam("remove", new Boolean(false));

                                params.setParam("renderBands", layer.getRender().getRenderColorInterpretation().buildRenderBands());

                                params.setParam("stretchs", null);//coge el LinearStretchParams por defecto

                                enhancementManager.addFilter(params);

                        }

                }

        }

        public int[] getRenderBands() {

                return new int[]{bandR, bandG, bandB};

        }

        public RasterFilterList getFilterList() throws FilterTypeException {

                /*RasterManager rManager = RasterLocator.getManager();

                try {

                        RasterFilterList filterList = layer.getRender().getFilterList();

                        if(filterList != null)

                                filterList.createFilterListFromStrings((ArrayList<String>)filters);

                        else {

                                filterList = rManager.createEmptyFilterList(Buffer.TYPE_BYTE);

                        }

                        return filterList;

                } catch (NullPointerException e) {

                        return null;

                }*/

                return null;

        }

        public ColorTable getColorTable() throws FilterTypeException {

                return layer.getRender().getColorTable();

        }

        public List<String> getFilterArguments() {

                return filters;

        }

        String nameClass = null;

        /**

         * Asigna el nombre de la clase que se ha leido desde el proyecto

         * @param nameClass

         */

        public void setNameClass(String nameClass) {

                this.nameClass = nameClass;                

        }

}