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.impl.grid;

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

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

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

import org.gvsig.raster.impl.store.properties.DataStoreTransparency;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynClass;

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;

//TODO: FUNCIONALIDAD: Convertir la transparencia a String y viceversa para salvar proyecto

/**

 * <P>

 * Representa el estado de transparencia de un grid. 

 * </P>

 * <P>

 * El estado de transparencia de un raster puede verse modificado desde los siguientes sitios:

 * <UL>

 * <LI>Color con transparencia definido en los metadatos de la imagen. Caracteristica de PNG.</LI>

 * <LI>Una banda del raster definida como banda de transparencia. PNGs, IMGs o TIFFs 

 * pueden tener bandas de transparencia</LI>

 * <LI>Tablas de color con valores de transparencia. GIF y PNG pueden tener tablas 

 * que definan entradas de color con transparencia</LI>

 * <LI>Informaci?n de transparencia en la cabecera raster. Tipicamente valores NO_DATA suelen 

 * ser interpretados como transparentes en la visualizaci?n.</LI>

 * <LI>Modificaci?n hecha por el usuario. En la visualizaci?n un usuario puede necesitar

 * asignar valores o rangos de valores como transparentes.</LI>

 * </UL> 

 * </P>

 * <P>

 * Estas transparencias quedan representadas por cinco tipo b?sicos:

 * <UL>

 * <LI><b>Transparencia por rangos. </b>Esta se aplicar? antes que ninguna y siempre sobre los valores

 * base del raster.</LI>

 * <LI><b>Banda de transparencia en un raster. </b></LI>

 * <LI>M?scara de transparencia</LI>

 * <LI>Opacidad</LI>

 * <LI>Zona de recorte</LI>

 * </UL>

 * </P>

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

 *

 */

public class GridTransparencyImpl extends DataStoreTransparency implements GridTransparency {

        /**

         * Flag de activaci?n de la transparencia cuando se visualiza o exporta.

         */

        private boolean                 transparencyActive           = false;

        /**

         * Constructor. Crea un objeto con las propiedades de la transparencia de un grid. 

         * Las variables conservan sus valores por defecto

         */

        public GridTransparencyImpl(){

                super();

                activeTransparency();

        };

        /**

         * Constructor. Crea un objeto con las propiedades de la transparencia de fichero

         * pasado como par?metro.

         * @param fileStatus Transparencia.

         */

        public GridTransparencyImpl(Transparency transp) {

                super(transp);

                activeTransparency();

        }

        /**

         * Comprueba si hay criterios para la aplicaci?n de transparencia y la activa si es

         * as? sino se desactiva. Los criterios son:

         * <P>

         * Que haya una mascara de transparencia.

         * </P><P>

         * Que exista un buffer de datos para la aplicaci?n de nodata

         * </P><P>

         * Que hayan reglas sobre la aplicaci?n de transparencia.

         * </P><P>

         * Que la opacidad sea distita de 255 (completamente opaco). 

         * </P>

         */

        public void activeTransparency() {

                if(        existAlphaBand() || isNoDataActive() ||

                        (transparencyRanges.size() > 0) ||

                        (opacity != 0xff))

                        transparencyActive = true;

                else

                        transparencyActive = false;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.grid.GridTransparency#processRGB(int, int, int, int, int)

         */

        public int processRGB(int r, int g, int b, int line, int col) {

                // Si el valor es noData se pone totalmente transparente y ya no se tiene en

                // cuenta nada m?s.

                if (originalData != null && isNoDataActive()) {

                        if (isNoData(line, col))

                                // El alpha no se pone para dejarlo a 0, totalmente transparente

                                return (r << 16 | g << 8 | b);

                }

                /**

                 * Para sacar el valor del nuevo alpha, lo que hacemos es convertir a

                 * porcentajes todos los alphas posibles (en porcentajes) y multiplicarlos

                 * entre si. Con esto conseguimos un nuevo porcentaje de alpha entre 0 y 1.

                 * Una vez hecho esto se multiplica por 255 para tenerlo dentro del rango

                 * deseado. Como queremos evitar operaciones de m?s, podemos quitar una

                 * division de 255 y as? nos ahorramos luego multiplicarlo por 255 otra vez.

                 */

                // Quitada la division para optimizar

                //double a = opacity / 255D;

                double a = opacity;

                int alphaRange = processRange(r, g, b);

                if (alphaRange != 255)

                        a *= (alphaRange / 255D);

                if (existAlphaBand() && getAlphaBand() != null)

                        a *= (getAlphaBand().getElemByte(line, col, 0) & 0xff) / 255D;

                // Quitada la multiplicacion para optimizar

                // a = (int)(a * 255D);

                return ((int) a << 24) | r << 16 | g << 8 | b;

        }

        /**

         * Aplica la transparecia por rangos al pixel pasado por par?metro. El valor

         * en la posici?n cero es el alpha por lo tanto ser? esta posici?n la que se

         * modificar?.

         * @param r

         * @param g

         * @param b

         * @return Un valor de 0 a 255. Donde 255 es totalmente opaco

         */

        private int processRange(int r, int g, int b) {

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

                        TransparencyRange tr = ((TransparencyRange) transparencyRanges.get(i));

                        if (tr == null) continue;

                        if (tr.isAnd()) {

                                if (tr.getRed() == null ||

                                                tr.getGreen() == null ||

                                                tr.getBlue() == null ||

                                                r < tr.getRed()[0]   || r > tr.getRed()[1] ||

                                                g < tr.getGreen()[0] || g > tr.getGreen()[1] ||

                                                b < tr.getBlue()[0]  || b > tr.getBlue()[1])

                                        continue;

                                return tr.getAlpha();

                        } else {

                                if (tr.getRed() != null) {

                                        if (r >= tr.getRed()[0] && r <= tr.getRed()[1]) {

                                                return tr.getAlpha();

                                        }

                                }

                                if (tr.getGreen() != null) {

                                        if (g >= tr.getGreen()[0] && g <= tr.getGreen()[1]) {

                                                return tr.getAlpha();

                                        }

                                }

                                if (tr.getBlue() != null) {

                                        if (b >= tr.getBlue()[0] && b <= tr.getBlue()[1]) {

                                                return tr.getAlpha();

                                        }

                                }

                        }

                }

                return 255;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.grid.GridTransparency#isTransparencyActive()

         */

        public boolean isTransparencyActive() {

                return transparencyActive;

        }

        /**

         * Asigna el flag de transparencia activa o desactivada.

         * @param transparencyActive true activa la transparencia false la desactiva

         */

        public void setTransparencyActive(boolean transparencyActive) {

                this.transparencyActive = transparencyActive;

        }

        public static void registerPersistent() {

                PersistenceManager manager = ToolsLocator.getPersistenceManager();

                DynStruct definition = manager.addDefinition(

                                GridTransparencyImpl.class,

                                "GridTransparency_Persistent",

                                "GridTransparency Persistent definition",

                                null, 

                                null

                );

                definition.extend(

                                (DynClass)ToolsLocator.getPersistenceManager()

                                        .getDefinition(Transparency.class)

                );

                definition.addDynFieldBoolean("transparencyActive");

        }

        @Override

        public void loadFromState(PersistentState state)

                        throws PersistenceException {

                super.loadFromState(state);

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

        }

        @Override

        public void saveToState(PersistentState state) throws PersistenceException {

                super.saveToState(state);

                state.set("transparencyActive",transparencyActive);

        }

}