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.regex.Matcher;

import java.util.regex.Pattern;

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

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

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

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

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.util.RasterUtils;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.extensionpoint.ExtensionPoint;

import org.gvsig.tools.extensionpoint.ExtensionPointManager;

import org.gvsig.tools.extensionpoint.ExtensionPoint.Extension;

/*

 * TODO: FUNCIONALIDAD: Anulada las estad?sticas. Hay que incluirlas de nuevo.

 */

/**

 * Esta clase es de la parte cliente y es la encargada de la gesti?n de la pila

 * de filtros. Cada tipo de filtro o conjunto de tipos de filtro deben tener un

 * gestor que implementa IRasterFilterManager. Esos gestores deben registrarse

 * en esta clase con la funci?n addClassListManager. Este registro puede hacerse

 * desde esta misma clase o desde una extensi?n. Un cliente que desee aplicar un

 * filtro deber? introducirlo en la lista usando para ello las funciones que su

 * manager de filtros le ofrece. Adem?s se encarga de otras funciones como la

 * conversi?n de un filtro a cadena de Strings y la recuperaci?n desde cadena de

 * Strings y el control de tipos de la salida de un raster de la lista con la

 * entrada del siguiente filtro.

 *

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

 */

public class RasterFilterListManagerImpl {

        protected RasterFilterList                rasterFilterList       = null;

        protected List<String>                        filterList             = null;

        private List<RasterFilterListManager>                        

                                            managers               = new ArrayList<RasterFilterListManager>();

        /**

         * Constructor

         * @param filterStack

         */

        @SuppressWarnings("unchecked")

        public RasterFilterListManagerImpl(RasterFilterList filterStack) {

                this.rasterFilterList = filterStack;

                // Cargamos el manager con los gestores de drivers registrados

                ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

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

                Iterator iterator = point.iterator();

                while (iterator.hasNext()) {

                        ExtensionPoint.Extension entry = (ExtensionPoint.Extension) iterator

                                        .next();

                        if (entry != null) {

                                Class RasterClass = entry.getExtension();

                                Object obj = RasterFilterListManagerImpl.loadClass(RasterClass, this);

                                if (obj != null)

                                        managers.add((RasterFilterListManager)obj);

                        }

                }

        }

        /**

         * Controla que los tipos de los filtros de la pila sean correctos, es decir,

         * que el tipo de salida de un filtro de salida coincida con el tipo de la

         * entrada del siguiente. En caso de no ser as? crea el filtro de tipo

         * adecuado y lo sustituye en el no coincidente. Esto es necesario ya que en

         * la eliminaci?n de filtros puede quedarse en inconsistencia de tipos.

         */

        public void controlTypes() throws FilterTypeException {

                RasterUtils util = RasterLocator.getManager().getRasterUtils();

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

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

                        String classFilter = null, packageFilter = null, oldClass = null;

                        try {

                                RasterFilter rf = rasterFilterList.get(i);

                                if (rf == null)

                                        return;

                                classFilter = rf.getClass().toString();

                                packageFilter = classFilter.substring(classFilter.indexOf(" ") + 1, classFilter.lastIndexOf("."));

                                oldClass = classFilter.substring(classFilter.lastIndexOf(".") + 1, classFilter.length());

                        } catch (ArrayIndexOutOfBoundsException ex) {

                                return;

                        } catch (NullPointerException ex) {

                                return;

                        }

                        // Para el primer filtro comprobamos con el tipo de dato de entrada a la pila

                        if (i == 0) {

                                if (rasterFilterList.getInitDataType() != rasterFilterList.get(i).getInRasterDataType()) {

                                        Pattern p = Pattern.compile(util.typesToString(rasterFilterList.get(i).getInRasterDataType()));

                                        Matcher m = p.matcher(oldClass);

                                        String newClass = m.replaceAll(util.typesToString(rasterFilterList.getInitDataType()));

                                        String strPackage = packageFilter + "." + newClass;

                                        renewFilterFromControlTypes(strPackage, i, exceptions);

                                }

                                // Desde el filtro 2 en adelante se compara la salida de uno con la entrada del siguiente

                        } else if (rasterFilterList.get(i - 1).getOutRasterDataType() != rasterFilterList.get(i).getInRasterDataType()) {

                                Pattern p = Pattern.compile(util.typesToString(rasterFilterList.get(i).getInRasterDataType()));

                                Matcher m = p.matcher(oldClass);

                                String newClass = m.replaceAll(util.typesToString(rasterFilterList.get(i - 1).getOutRasterDataType()));

                                String strPackage = packageFilter + "." + newClass;

                                renewFilterFromControlTypes(strPackage.trim(), i, exceptions);

                        }

                }

                if (exceptions.size() > 0)

                        throw new FilterTypeException("");

        }

        /**

         * Reemplaza un filtro segun su nombre a la lista de filtros, util para cambiar

         * el tipo de datos de un filtro en la pila de filtros.

         * @param nameFilter

         * @param pos

         * @param exceptions

         */

        private void renewFilterFromControlTypes(String nameFilter, int pos, List<Exception> exceptions) {

                try {

                        RasterFilter newFilter = rasterFilterList.createEmptyFilter(nameFilter);

                        newFilter.setParams(rasterFilterList.get(pos).getParams());

                        if (newFilter.getParams().get("filterName") != null)

                                newFilter.setName((String) newFilter.getParams().get("filterName"));

                        else

                                newFilter.setName(rasterFilterList.get(pos).getName());

                        rasterFilterList.replace(newFilter, pos);

                } catch (FilterTypeException e) {

                        exceptions.add(e);

                }

        }

        /**

         * 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(String name) {

                return rasterFilterList.isActive(name);

        }

        /**

         * Elimina los filtros de la pila de un determinado tipo

         *

         * @param type Tipo de filtro a eliminar

         * @throws FilterTypeException

         */

        public void removeFilter(String name) throws FilterTypeException {

                rasterFilterList.remove(name);

                this.controlTypes();

        }

        public List<String> getStringsFromFilterList() {

                filterList = new ArrayList<String>();

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

                        RasterFilter rf = rasterFilterList.get(i);

                        // Se recorren todos los managers registrados comprobando si corresponde a

                        // la clase del filtro

                        for (int j = 0; j < managers.size(); j++)

                                filterList = ((RasterFilterListManager) managers.get(j)).getStringsFromFilterList(filterList, rf);

                }

                return filterList;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.grid.filter.IRasterFilterListManager#createStackFromStrings(java.util.ArrayList, java.lang.String, int)

         */

        @SuppressWarnings("unchecked")

        public int createStackFromStrings(List filters, String fil, int filteri) {

                return filteri;

        }

        /**

         * Crea una pila de filtros a partir de un Array de Strings. Cada elemento del array debe

         * tener la forma elemento=valor.

         * @param filters

         * @throws FilterTypeException

         */

        public static void createFilterListFromStrings(RasterFilterList rasterFilterList, List<String> f) throws FilterTypeException {

                new RasterFilterListManagerImpl(rasterFilterList).createFilterListFromStrings(f, new Integer(0));

        }

        /**

         * Crea una pila de filtros a partir de un Array de Strings. Cada elemento del array debe

         * tener la forma elemento=valor.

         * @param filters

         * @throws FilterTypeException

         */

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

                createFilterListFromStrings(f, new Integer(0));

        }

        /**

         * Crea una pila de filtros a partir de un Array de Strings. Cada elemento del array debe

         * tener la forma elemento=valor.

         * @param pos Posici?n desde la cual se empieza a analizar.

         * @param filters

         * @throws FilterTypeException

         */

        @SuppressWarnings("unchecked")

        private void createFilterListFromStrings(List<String> f, Integer pos) throws FilterTypeException {

                List<String> filters = null;

                if(f instanceof ArrayList) {

                        filters = (List<String>)((ArrayList<String>) f).clone();

                } else {

                        filters = new ArrayList<String>();

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

                                filters.add(f.get(i));

                        }

                }

                rasterFilterList.clear();

                int filteri = pos.intValue();

                // Busca un filtro activo y despu?s todas las propiedades que necesita ese

                // filtro para ser creado. Una vez las tiene a?ade en la pila el tipo de

                // filtro.

                while ((filters.size() > 0) && (filteri < filters.size())) {

                        String fil = (String) filters.get(filteri);

                        for (int j = 0; j < managers.size(); j++)

                                try {

                                        filteri = ((RasterFilterListManager) managers.get(j)).createFilterListFromStrings(filters, fil, filteri);

                                } catch (NullPointerException e) {

                                }

                        filteri++;

                }

        }

        /**

         * Obtiene el elemento de una cadena de la forma elemento=valor

         * @param cadena

         * @return

         */

        public static String getElem(String cadena) {

                if (cadena != null)

                        return cadena.substring(0, cadena.indexOf("="));

                else

                        return null;

        }

        /**

         * Obtiene el valor de una cadena de la forma elemento=valor

         * @param cadena

         * @return

         */

        public static String getValue(String cadena) {

                if (cadena != null)

                        return cadena.substring(cadena.indexOf("=") + 1, cadena.length());

                else

                        return null;

        }

        /**

         * Carga una clase pasada por par?metro. Como argumento del constructor de la

         * clase se pasar? un RasterFilterStackManager. Esto es usado para instanciar

         * los gestores de filtros registrados

         * @param clase Clase a instanciar

         * @param stackManager Par?metro del constructor de la clase a instanciar

         * @return Objeto que corresponde a la instancia de la clase pasada.

         */

        @SuppressWarnings("unchecked")

        public static Object loadClass(Class clase, RasterFilterListManagerImpl stackManager) {

                Object obj = null;

                try {

                        try {

                                Constructor hazNuevo = clase.getConstructor(new Class[]{ RasterFilterList.class });

                                obj = hazNuevo.newInstance(new Object[]{stackManager.getFilterList()});

                        } catch (NoSuchMethodException e) {

                                Constructor hazNuevo = clase.getConstructor(new Class[]{ RasterFilterListManagerImpl.class });

                                obj = hazNuevo.newInstance(new Object[]{stackManager});

                        }

                } 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 obj;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.grid.RasterFilterListManager#getFilterList()

         */

        public RasterFilterList getFilterList() {

                return rasterFilterList;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.grid.RasterFilterListManager#getManagerByID(java.lang.String)

         */

        @SuppressWarnings("unchecked")

        public RasterFilterListManager getManagerByID(String id) throws FilterManagerException {

                // Cargamos el manager con los gestores de drivers registrados

                ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

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

                Extension ext = point.get(id);

                if (ext != null) {

                        Class clase = ext.getExtension();

                        Class [] args = {RasterFilterListManagerImpl.class};

                        try {

                                Constructor hazNuevo = clase.getConstructor(args);

                                Object [] args2 = {this};

                                return (RasterFilterListManager) hazNuevo.newInstance(args2);

                        } catch (SecurityException e) {

                                throw new FilterManagerException("Error SecurityException in open", e);

                        } catch (NoSuchMethodException e) {

                                throw new FilterManagerException("Error NoSuchMethodException in open", e);

                        } catch (IllegalArgumentException e) {

                                throw new FilterManagerException("Error IllegalArgumentException in open", e);

                        } catch (InstantiationException e) {

                                throw new FilterManagerException("Error InstantiationException in open", e);

                        } catch (IllegalAccessException e) {

                                throw new FilterManagerException("Error IllegalAccessException in open", e);

                        } catch (InvocationTargetException e) {

                                throw new FilterManagerException("Error opening this image with " + clase, e);

                        }

                }

                return null;

        }

        /**

         * Obtiene el manager registrado a partir de la clase

         * @return

         */

        @SuppressWarnings("unchecked")

        public RasterFilterListManager getManagerByClass(Class c) {

                for (int j = 0; j < managers.size(); j++)

                        if (managers.get(j).getClass().equals(c))

                                return (RasterFilterListManager) managers.get(j);

                return null;

        }

        /**

         * Obtiene el manager registrado a partir de la clase de un filtro

         * @return

         */

        @SuppressWarnings("unchecked")

        public RasterFilterListManager getManagerByFilterClass(Class c) {

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

                        RasterFilterListManager localMan = ((RasterFilterListManager) managers.get(i));

                        for (int j = 0; j < localMan.getRasterFilterList().size(); j++) {

                                Class f = (Class)localMan.getRasterFilterList().get(j);

                                if (f.isAssignableFrom(c))//(f.equals(c))

                                        return localMan;

                        }

                }

                return null;

        }

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

                List<Class<?>> filters = new ArrayList<Class<?>>();

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

                        List<Class<?>> auxFilters = ((RasterFilterListManager) managers.get(i)).getRasterFilterList();

                        for (int j = 0; j < auxFilters.size(); j++)

                                filters.add(auxFilters.get(j));

                }

                return filters;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.grid.RasterFilterListManager#addFilter(java.lang.Class, org.gvsig.fmap.dal.coverage.datastruct.Params)

         */

        @SuppressWarnings("unchecked")

        public void addFilter(Class classFilter, Params params)

                        throws FilterTypeException {

                // TODO Auto-generated method stub

        }

        public void addFilter(Params params) throws FilterTypeException {

                throw new FilterTypeException("Method not implemented in globar manager");

        }

        public int createFilterListFromStrings(List<String> filters,

                        String fil, int filteri) throws FilterTypeException {

                // TODO Auto-generated method stub

                return 0;

        }

        public List<String> getStringsFromFilterList(

                        List<String> filterList, RasterFilter rf) {

                // TODO Auto-generated method stub

                return null;

        }

        /*

         * (non-Javadoc)

         * @see java.lang.Object#finalize()

         */

        protected void finalize() throws Throwable {

                rasterFilterList           = null;

                if(managers != null) {

                        managers.clear();

                        managers = null;

                }

                if(filterList != null) {

                        filterList.clear();

                        filterList = null;

                }

                super.finalize();

        }

}