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

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Stack;

import java.util.TreeMap;

import org.gvsig.fmap.dal.coverage.dataset.Buffer;

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.coverage.grid.filter.BaseRasterFilter;

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

import org.gvsig.raster.impl.store.ParamsImpl;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.extensionpoint.ExtensionPoint;

import org.gvsig.tools.extensionpoint.ExtensionPointManager;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

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

/**

 * Esta clase representa la lista de filtros que debe ser manejada desde el

 * RasterFilterListManager.

 *

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

 */

public class DefaultRasterFilterList implements RasterFilterList {

        public static final String      PERSISTENT_NAME        = "RasterFilterList_Persistent";

    public static final String      PERSISTENT_DESCRIPTION = "RasterFilterList Persistent";

        private Buffer                  initialRasterBuffer    = null;

        private Buffer                  outputRasterBuffer     = null;

        private int                     typeFilter             = -1;

        private TreeMap<String, Object>

                                        environment            = new TreeMap<String, Object>();

        private List<RasterFilter>        

                                        list                   = new ArrayList<RasterFilter>();

        private Stack<List<RasterFilter>>            

                                        status                 = new Stack<List<RasterFilter>>();

        /**

         * Array de listeners que ser?n informados cuando cambia la lista de filtros

         */

        private List<FilterListChangeListener>        

                                        filterListListener     = new ArrayList<FilterListChangeListener>();

        private RasterFilterListManagerImpl

                                    manager                = null;

        /**

         * Asigna un listener a la lista que ser? informado cuando cambie un

         * filtro o posici?n en la lista.

         * @param listener FilterListListener

         */

        public void addFilterListListener(FilterListChangeListener listener) {

                filterListListener.add(listener);

        }

        /**

         * M?todo llamado cuando hay un cambio en una propiedad de visualizaci?n

         */

        private void callFilterListChanged(Object obj) {

                if(filterListListener != null) {

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

                                FilterListChangeEvent ev = new FilterListChangeEvent(obj);

                                ((FilterListChangeListener)filterListListener.get(i)).filterListChanged(ev);

                        }

                }

        }

        /**

         * A?ade un par?metro a la lista de filtros. Estos par?metros luego pueden ser

         * utilizados por los managers que se registren

         * @param key Nombre del par?metro que coincide con el nombre de la clase.

         * @param value Objeto

         */

        public void addEnvParam(String key, Object value) {

                environment.put(key, value);

        }

        /**

         * Obtiene un par?metro de la lista de filtros.

         * @param key Identificador del par?metro. Coincide con el nombre de la clase del par?metro.

         */

        public Object getEnvParam(String key) {

                return environment.get(key);

        }

        /**

         * Controla que los tipos de entrada y salida de los filtros sean los

         * correctos

         * @throws FilterTypeException

         */

        public void controlTypes() throws FilterTypeException {

                RasterFilterListManagerImpl stackManager = new RasterFilterListManagerImpl(this);

                stackManager.controlTypes();

        }

        /**

         * A?ade un filtro al final de la lista

         * @param filter        filtro a?adido

         * @throws FilterTypeException

         */

        public void add(RasterFilter filter) throws FilterTypeException {

                if (isActive(filter.getName()))

                        replace(filter, filter.getName());

                else {

                        list.add(filter);

                        controlTypes();

                }

                filter.setEnv(environment);

                callFilterListChanged(this);

        }

        /**

         * Sustituye un filtro de una posici?n de la pila por otro

         * @param filter

         * @param i

         * @throws FilterTypeException

         */

        public void replace(RasterFilter filter, String name) throws FilterTypeException {

                boolean changed = false;

                filter.setEnv(environment);

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

                        if (((BaseRasterFilter) list.get(i)).getName().equals(name)) {

                                list.remove(i);

                                list.add(i, filter);

                                changed = true;

                        }

                if (changed)

                        controlTypes();

                callFilterListChanged(this);

        }

        /**

         * A?ade un filtro en la lista en la posici?n indicada.

         * @param filter        filtro a?adido

         * @param pos        posici?n

         * @throws FilterTypeException

         */

        public void add(RasterFilter filter, int pos) throws FilterTypeException {

                try {

                        list.add(pos, filter);

                        controlTypes();

                } catch (IndexOutOfBoundsException e) {

                        add(filter);

                }

                filter.setEnv(environment);

                callFilterListChanged(this);

        }

        /**

         * Elimina un filtro a partir de su nombre

         * @param name Nombre del filtro a eliminar

         * @throws FilterTypeException

         */

        public void remove(String name) throws FilterTypeException {

                boolean changed = false;

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

                        if (((BaseRasterFilter) list.get(i)).getName().equals(name)) {

                                list.remove(i);

                                changed = true;

                        }

                if (changed)

                        controlTypes();

                callFilterListChanged(this);

        }

        /**

         * Elimina un filtro por clase.

         *

         * @param baseFilterClass

         * @throws FilterTypeException

         */

        public void remove(Class<?> baseFilterClass) throws FilterTypeException {

                boolean changed = false;

                for (int i = 0; i < lenght(); i++)

                        if (baseFilterClass.isInstance(list.get(i))) {

                                list.remove(i);

                                i--;

                                changed = true;

                        }

                if (changed)

                        controlTypes();

                callFilterListChanged(this);

        }

        /**

         * Devuelve el tipo de dato de retorno al aplicar la pila de filtros

         * @return

         */

        public int getOutDataType() {

                if (list.size() > 0)

                        return ((BaseRasterFilter) list.get(list.size() - 1)).getOutRasterDataType();

                else

                        if(outputRasterBuffer != null)

                                return outputRasterBuffer.getDataType();

                        else

                                return initialRasterBuffer.getDataType();

        }

        /**

         * Devuelve el raster resultado de la aplicacion de la pila de filtros

         * @return

         */

        public Buffer getResult() {

                return outputRasterBuffer;

        }

        /**

         * Obtiene la cantidad de filtros en la lista

         * @return N?mero de filtros apilados

         */

        public int lenght() {

                return list.size();

        }

        /**

         * Obtiene el filtro apilado de la posici?n i o null si el indice es incorrecto

         * @param i        Posici?n a acceder en la pila

         * @return        Filtro

         */

        public RasterFilter get(int i) {

                if (i >= list.size() || i < 0)

                        return null;

                return (BaseRasterFilter) list.get(i);

        }

        /**

         * Obtiene el filtro apilado de nombre name o null si no existe

         * @param i       Nombre del filtro buscado

         * @return        Filtro

         */

        public RasterFilter get(String name) {

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

                        if (((BaseRasterFilter) list.get(i)).getName().equals(name))

                                return (BaseRasterFilter) list.get(i);

                return null;

        }

        /**

         * Obtiene el filtro apilado que corresponde con el nombre

         * @param name        Nombre de filtro

         * @return      Filtro en caso de que exista un filtro apilado de ese tipo

         * o null si no hay ninguno.

         */

        public RasterFilter getByName(String name) {

                for (int i = 0; i < lenght(); i++)

                        if (((BaseRasterFilter) list.get(i)).getName().equals(name))

                                return (BaseRasterFilter) list.get(i);

                return null;

        }

        /**

         * Obtiene el primer filtro de la lista que es instancia de la clase pasada por

         * par?metro

         * @param baseFilterClass Filtro base

         * @return RasterFilter

         */

        public RasterFilter getFilterByBaseClass(Class<?> baseFilterClass) {

                for (int i = 0; i < lenght(); i++)

                        if (baseFilterClass.isInstance(list.get(i)))

                                return (BaseRasterFilter) list.get(i);

                return null;

        }

        /**

         * Obtiene el tipo del filtro de la pila de la posici?n i

         * @param i Posici?n a acceder en la pila

         * @return tipo de filtro

         */

        public String getName(int i) {

                return ((BaseRasterFilter) list.get(i)).getName();

        }

        /**

         * Removes all filter of this stack

         */

        public void clear() {

                list.clear();

                callFilterListChanged(this);

        }

        /**

         * Replaces a filter in the i position by another

         * @param filter

         * @param i

         */

        public void replace(RasterFilter filter, int i) {

                filter.setEnv(environment);

                list.remove(i);

                list.add(i, filter);

                callFilterListChanged(this);

        }

        /**

         * Moves a specific filter to anothe position

         * @param filter 

         *                         Filter to move

         * @param position 

         *                         New position

         * @return If the filter existed returns true else it will return false

         */

        public boolean move(Class<?> filter, int position) {

                BaseRasterFilter f = null;

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

                        if(filter.isInstance(list.get(i))) {

                                f = (BaseRasterFilter) list.get(i);

                                list.remove(i);

                                break;

                        }

                if(f != null) {

                        list.add(position, f);

                        return true;

                }

                return false;

        }

        /**

         * Asigna el raster de entrada inicial

         * @param raster

         */

        public void setInitRasterBuf(Buffer raster) {

                initialRasterBuffer = raster;

                if(initialRasterBuffer != null)

                        typeFilter = initialRasterBuffer.getDataType();

        }

        /**

         * Devuelve el tipo de datos inicial de la lista

         * @return Tipo de dato del raster inicial

         */

        public int getInitDataType() {

                return typeFilter;

        }

        /**

         * Asigna el tipo de dato inicial

         * @param dt

         */

        public void setInitDataType(int dt) {

                this.typeFilter = dt;

        }

        /**

         * M?todo que devuelve true si el tipo de filtro pasado por par?metro est? en la

         * pila y false si no lo est?.

         * @param type        Tipo de par?metro a comprobar

         * @return true si est? en la pila y false si no lo est?

         */

        public boolean isActive(String name) {

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

                        if (((RasterFilter) list.get(i)).getName().equals(name))

                                return true;

                return false;

        }

        /**

         * M?todo que devuelve true si el tipo de filtro pasado por par?metro est? en

         * la pila y false si no lo est?.

         *

         * @param filter Tipo de filtro a comprobar

         * @return true si est? en la pila y false si no lo est?

         */

        public boolean isActive(RasterFilter filter) {

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

                        if (((RasterFilter) list.get(i)).equals(filter))

                                return true;

                return false;

        }

        /**

         * Devuelve la posici?n en la lista de una clase de filtro concreta

         *

         * @param c Clase a buscar en la lista

         * @return posici?n en la lista

         */

        public int getPosition(Class<?> c) {

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

                        if (c.isInstance(list.get(i)))

                                return i;

                return -1;

        }

        /**

         * Aplica los filtros de la pila sobre el buffer correspondiente

         * @param dataType

         * @throws ProcessInterruptedException

         */

        private void executeFilterByDataType(int dataType) throws ProcessInterruptedException, FilterAddException {

                if(outputRasterBuffer != null && initialRasterBuffer != outputRasterBuffer) {

                        outputRasterBuffer.dispose();

                        outputRasterBuffer = null;

                }

                Buffer bufferToProcess = initialRasterBuffer;

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

                        BaseRasterFilter filter = (BaseRasterFilter) list.get(i);

                        // TODO: Arquitectura. Quitar el ControlTypes y en este momento

                        // cerciorarse de si el tipo del filtro es totalmente el correcto o hay

                        // que recrearlo. Ejemplo:

                        // Si el filtro que tenemos antes de preprocesar es de tipo Byte y la

                        // entrada de datos es de tipo float, reconstruir solo este filtro para

                        // que sea de tipo float

                        filter.addParam("raster", bufferToProcess);

                        filter.execute();

                        if (filter.getResult(RasterFilter.RESULT_BUFFER) != null) {

                                //Si no es el ?ltimo filtro se asigna el buffer de la pr?xima iteraci?n y se libera el anterior

                                if(i < (list.size() - 1)) {

                                        if(bufferToProcess != null && initialRasterBuffer != bufferToProcess)

                                                bufferToProcess.dispose();

                                        bufferToProcess = (Buffer) filter.getResult(RasterFilter.RESULT_BUFFER);

                                } else {

                                        //Si es el ?ltimo se carga el de salida

                                        outputRasterBuffer = (Buffer) filter.getResult(RasterFilter.RESULT_BUFFER);

                                }

                        }

                        if (i == list.size() - 1  && filter.getResult(RasterFilter.RESULT_TRANSPARENCY) != null) {

                                addEnvParam("Transparency", filter.getResult(RasterFilter.RESULT_TRANSPARENCY));

                        }

                }

        }

        /**

         * Aplica los filtros sobre un RasterBuf

         * @return Buffer de salida

         * @throws ProcessInterruptedException

         * @throws FilterAddException 

         */

        public Buffer execute() throws ProcessInterruptedException, FilterAddException {

                if (initialRasterBuffer == null)

                        return null;

                executeFilterByDataType(initialRasterBuffer.getDataType());

                return initialRasterBuffer;

        }

        /**

         * Muestra el contenido de la pila de filtros para depuraci?n

         */

        public void show() {

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

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

                        System.out.println("FILTRO:" + i + " NAME:" + ((BaseRasterFilter) list.get(i)).getName() + " FIL:" + ((BaseRasterFilter) list.get(i)).toString());

        }

        public void resetPercent() {

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

                        ((BaseRasterFilter) list.get(i)).resetPercent();

        }

        public int getPercent() {

                int percent = 0;

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

                        return 0;

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

                        percent += ((BaseRasterFilter) list.get(i)).getPercent();

                percent = percent / list.size();

                return percent;

        }

        /**

         * Guarda el estado de la lista de filtros en una pila, que se podr?

         * ir recuperando con popStatus()

         */

        public void pushStatus() {

                status.push(getStatusCloned());

        }

        /**

         * Obtiene el estado actual de los filtros, el ArrayList devuelto es una

         * clonaci?n del original, asi no compartiran datos.

         * @return

         */

        public List<RasterFilter> getStatusCloned() {

                List<RasterFilter> newArray = new ArrayList<RasterFilter>();

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

                        try {

                                newArray.add((RasterFilter)(((BaseRasterFilter) list.get(i)).clone()));

                        } catch (CloneNotSupportedException e) {

                                System.out.println("No se ha podido clonar");

                        }

                return newArray;

        }

        /**

         * Saves the current status of the filters

         * @param newArray

         */

        public void setStatus(List<RasterFilter> newArray) {

                if(list != null)

                        list.clear();

                if(newArray == null)

                        return;

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

                        if(list != null)

                                list.add(newArray.get(i));

                callFilterListChanged(this);

        }

        /**

         * Gets a status saved before through the call <code>pushStatus()</code>

         */

        public void popStatus() {

                if (status.size() <= 0)

                        return;

                setStatus((List<RasterFilter>) status.pop());

        }

        /**

         * Gets a TreeMap with the environment parameters 

         * @return TreeMap

         */

        public TreeMap<String, Object> getEnv() {

                return environment;

        }

        /**

         * Sets a TreeMap with the environment parameters 

         * @param env

         */

        public void setEnv(TreeMap<String, Object> env) {

                this.environment = env;

        }

        public void createFilterListFromStrings(List<String> f) throws FilterTypeException {

                RasterFilterListManagerImpl.createFilterListFromStrings(this, f);

        }

        public RasterFilterListManager getManagerByID(String id) throws FilterManagerException {

                return new RasterFilterListManagerImpl(this).getManagerByID(id);

        }

        public RasterFilterListManager getManagerByFilterClass(Class<?> c) {

                if(manager == null)

                        manager = new RasterFilterListManagerImpl(this);

                return manager.getManagerByFilterClass(c);

        }

        public RasterFilterListManager getManagerByClass(Class<?> clase) {

                Object obj = null;

                Class<?>[] args = { RasterFilterList.class };

                try {

                        Constructor<?> hazNuevo = clase.getConstructor(args);

                        Object[] args2 = { this };

                        obj = hazNuevo.newInstance(args2);

                } catch (SecurityException e) {

                        e.printStackTrace();

                } catch (NoSuchMethodException e) {

                        e.printStackTrace();

                } catch (IllegalArgumentException e) {

                        e.printStackTrace();

                } catch (InstantiationException e) {

                        e.printStackTrace();

                } catch (IllegalAccessException e) {

                        e.printStackTrace();

                } catch (InvocationTargetException e) {

                        e.printStackTrace();

                }

                return (RasterFilterListManager)obj;

        }

        public Class<?> getFilterClassByID(String id) {

                ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

                ExtensionPoint point = extensionPoints.get("RasterFilter");

                Iterator<?> it = point.iterator();

                while(it.hasNext()) {

                        ExtensionPoint.Extension entry = (ExtensionPoint.Extension) it.next();

                        if (entry != null) {

                                Class<?> managerClass = entry.getExtension();

                                RasterFilterListManager manager = getManagerByClass(managerClass);

                                if(manager != null) {

                                        Class<?> c = manager.getFilterClassByID(id);

                                        if(c != null)

                                                return c;

                                }

                        }

                }

                return null;

        }

        public Params createEmptyFilterParams() {

                return new ParamsImpl();

        }

        public List<Class<?>> getRegisteredFilterList() {

                if(manager == null)

                        manager = new RasterFilterListManagerImpl(this);

                return manager.getRasterFilterList();

        }

        public List<Class<?>> getRegisteredFilterListByDataType(int dataType) {

                if(manager == null)

                        manager = new RasterFilterListManagerImpl(this);

                return manager.getRasterFilterListByDataType(dataType);

        }

        public RasterFilter createEmptyFilter(String strPackage) throws FilterTypeException {

                Class<?> filterClass = null;

                try {

                        filterClass = Class.forName(strPackage.trim());

                } catch (ClassNotFoundException e) {

                        throw new FilterTypeException("No puedo instanciar " + strPackage.trim());

                }

                Constructor<?> con = null;

                try {

                        con = filterClass.getConstructor();

                } catch (SecurityException e) {

                        throw new FilterTypeException("");

                } catch (NoSuchMethodException e) {

                        throw new FilterTypeException("");

                }

                BaseRasterFilter newFilter = null;

                try {

                        newFilter = (BaseRasterFilter) con.newInstance();

                } catch (IllegalArgumentException e) {

                        throw new FilterTypeException("");

                } catch (InstantiationException e) {

                        throw new FilterTypeException("");

                } catch (IllegalAccessException e) {

                        throw new FilterTypeException("");

                } catch (InvocationTargetException e) {

                        throw new FilterTypeException("");

                }

                return newFilter;

        }

        public void loadFromState(PersistentState state)

                        throws PersistenceException {

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

                /*List<PersistencyFilterParam> listFilterUsed = state.getList("paramlist");

                ArrayList<Exception> exc = new ArrayList<Exception>();

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

                        try {

                                PersistencyFilterParam pfp = (PersistencyFilterParam) listFilterUsed.get(i);

                                if(pfp != null && pfp.getFilterClass() != null && pfp.getFilterParam() != null) {

                                        RasterFilterListManager filterManager = getManagerByFilterClass(pfp.getFilterClass());

                                        filterManager.setFilterList(this);

                                        if(filterManager != null)

                                                filterManager.addFilter(pfp.getFilterClass(), pfp.getFilterParam());

                                }

                        } catch (FilterTypeException e) {

                                exc.add(e);

                        }

                }*/

        }

        public void saveToState(PersistentState state) throws PersistenceException {

                state.set("typeFilter", typeFilter);

                /*ArrayList<PersistencyFilterParam> filters = new ArrayList<PersistencyFilterParam>();

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

                        RasterFilter f = list.get(i);

                        Params uipar = f.getUIParams(f.getName());

                        PersistencyFilterParam param = new PersistencyFilterParam();

                        param.setFilterParam(uipar);

                        param.setFilterClass(f.getClass());

                        param.setFilterName(f.getName());

                        filters.add(param);

                }

                state.set("paramlist", filters);*/

        }        

        public static void registerPersistence() {

                PersistenceManager manager = ToolsLocator.getPersistenceManager();

                DynStruct definition = manager.getDefinition(PERSISTENT_NAME);

                if( definition == null ) {

                        definition = manager.addDefinition(

                                        DefaultRasterFilterList.class,

                                        PERSISTENT_NAME,

                                        PERSISTENT_DESCRIPTION,

                                        null, 

                                        null

                        );

                        definition.addDynFieldInt("typeFilter").setMandatory(false);

                        //definition.addDynFieldList("paramlist").setClassOfItems(PersistencyFilterParam.class).setMandatory(false);

                }

        }

        /**

         * Releases buffer resources

         */

        public void dispose() {

                if (initialRasterBuffer != null)

                        initialRasterBuffer.dispose();

                try {

                        finalize();

                } catch (Throwable e) {

                }

        }

        public Transparency getTransparency() {

                return (Transparency)getEnvParam("Transparency");

        }

        protected void finalize() throws Throwable {

                initialRasterBuffer = null;

                if(filterListListener != null) {

                        filterListListener.clear();

                        filterListListener = null;

                }

                if(status != null) {

                        status.clear();

                        status = null;

                }

                if(list != null) {

                        list.clear();

                        list = null;

                }

                super.finalize();

        }

}