Application: gvSIG desktop

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2006 IVER T.I. and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 */

package org.gvsig.raster.grid.filter;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.StringTokenizer;

import java.util.Map.Entry;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.gvsig.raster.util.RasterUtilities;

import org.gvsig.raster.util.extensionPoints.ExtensionPoint;

import org.gvsig.raster.util.extensionPoints.ExtensionPoints;

import org.gvsig.raster.util.extensionPoints.ExtensionPointsSingleton;

/*

 * 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 RasterFilterListManager {

        protected RasterFilterList        rasterFilterList = null;

        private boolean                                debug = false;

        public int[]                                priority = null;

        protected ArrayList                        filterList = null;

        private ArrayList                        managers = new ArrayList();

  /**

         * Constructor

         * @param filterStack

         */

        public RasterFilterListManager(RasterFilterList filterStack) {

                this.rasterFilterList = filterStack;

                // Cargamos el manager con los gestores de drivers registrados

                ExtensionPoints extensionPoints = ExtensionPointsSingleton.getInstance();

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

                Iterator iterator = extensionPoint.entrySet().iterator();

                while (iterator.hasNext()) {

                        Entry entry = (Entry) iterator.next();

                        if (entry != null) {

                                Class RasterClass = (Class) entry.getValue();

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

                                if (obj != null)

                                        managers.add(obj);

                        }

                }

        }

  /**

         * Sustituye el tipo de filtro de strPackage por el de newClass

         * @param strPackage cadena con el paquete y filtro a sustituir, por ej:

         *          org.cresques.filter.enhanced.ContrastImageFilter

         * @param newClass clase con el tipo a sustituir. Por ej: ContrastShortFilter

         * @return devuelve strPackage con la sustituci?n hecha. Por ej:

         *         org.cresques.filter.enhanced.ContrastShortFilter

         */

        private String getStrPackage(String strPackage, String newClass) {

                if (newClass.endsWith("ImageFilter"))

                        strPackage = strPackage + newClass.substring(0, newClass.lastIndexOf("ImageFilter"));

                else if (newClass.endsWith("ShortFilter"))

                        strPackage = strPackage + newClass.substring(0, newClass.lastIndexOf("ShortFilter"));

                else if (newClass.endsWith("DoubleFilter"))

                        strPackage = strPackage + newClass.substring(0, newClass.lastIndexOf("DoubleFilter"));

                else if (newClass.endsWith("FloatFilter"))

                        strPackage = strPackage + newClass.substring(0, newClass.lastIndexOf("FloatFilter"));

                strPackage = strPackage + "." + newClass;

                return strPackage;

        }

        /**

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

                for (int i = rasterFilterList.lenght(); i >= 0; i--) {

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

                        try {

                                RasterFilter rf = rasterFilterList.get(i - 1);

                                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;

                        }

                        if ((i - 1) >= 0) {

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

                                // pila

                                if (i == rasterFilterList.lenght()) {

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

                                                Pattern p = Pattern.compile(RasterUtilities.typesToString(rasterFilterList.get(i - 1).getInRasterDataType()));

                                                Matcher m = p.matcher(oldClass);

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

                                                String strPackage = packageFilter + "." + newClass;

                                                try {

                                                        Class filterClass = Class.forName(strPackage);

                                                        Constructor con = filterClass.getConstructor(null);

                                                        RasterFilter newFilter = (RasterFilter) con.newInstance(null);

                                                        newFilter.params = rasterFilterList.get(i - 1).params;

                                                        rasterFilterList.replace(newFilter, i - 1);

                                                } catch (Exception e) {

                                                        e.printStackTrace();

                                                }

                                        }

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

                                        // entrada del siguiente

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

                                        Pattern p = Pattern.compile(RasterUtilities.typesToString(rasterFilterList.get(i - 1).getInRasterDataType()));

                                        Matcher m = p.matcher(oldClass);

                                        String newClass = m.replaceAll(RasterUtilities.typesToString(rasterFilterList.get(i).getOutRasterDataType()));

                                        String strPackage = packageFilter + "." + newClass;

                                        try {

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

                                                Constructor con = filterClass.getConstructor(null);

                                                RasterFilter newFilter = (RasterFilter) con.newInstance(null);

//                                                newFilter.setFilterName(filterStack.get(i - 1).getFilterName());

                                                newFilter.params = rasterFilterList.get(i - 1).params;

                                                rasterFilterList.replace(newFilter, i - 1);

                                        } catch (Exception e) {

                                                e.printStackTrace();

                                        }

                                }

                        }

                }

                if (debug)

                        rasterFilterList.show();

        }

        /**

         * 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

         */

        public void removeFilter(String name) {

                rasterFilterList.remove(name);

                this.controlTypes();

        }

  /**

   * Elimina los filtros de la pila de una determinada prioridad

   * 

   * @param priority Prioridad de los filtros a elimina

   */

        public void removeFilter(int priority) {

                rasterFilterList.remove(priority);

                this.controlTypes();

        }

        public ArrayList getStringsFromFilterList() {

                filterList = new ArrayList();

                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 = ((IRasterFilterListManager) 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)

   */

  public int createStackFromStrings(ArrayList 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

   */

  public void createFilterListFromStrings(ArrayList f) {

          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

   */

  private void createFilterListFromStrings(ArrayList f, Integer pos) {

                ArrayList filters = (ArrayList) f.clone();

                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++)

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

                        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;

                }

        }

  /**

         * Convierte un rango contenido en una array doble en una cadena de strings

         * para poder salvar a xml

         * @param rang

         * @return

         */

  private String rangeToString(int[][] rang) {

                StringBuffer rangoStr = new StringBuffer();

                if (rang != null) {

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

                                rangoStr.append(String.valueOf(rang[i][0]) + ":");

                                rangoStr.append(String.valueOf(rang[i][1]) + ":");

                        }

                        String r = rangoStr.toString();

                        if (r.endsWith(":")) {

                                r = r.substring(0, r.length() - 1);

                        }

                        return r;

                } else {

                        return null;

                }

        }

  /**

         * Convierte una cadena en una lista de rangos numericos para poder asignar

         * transparencias a la imagen

         * @param rang

         * @return

         */

  private int[][] stringToRange(String rang) {

                if ((rang != null) && !rang.equals("null")) {

                        ArrayList lista = new ArrayList();

                        StringTokenizer tokenizer = new StringTokenizer(rang, ":");

                        while (tokenizer.hasMoreTokens())

                                lista.add(tokenizer.nextToken());

                        int[][] intervalos = new int[(int) (lista.size() / 2)][2];

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

                                intervalos[i / 2][0] = Integer.valueOf((String) lista.get(i)).intValue();

                                intervalos[i / 2][1] = Integer.valueOf((String) lista.get(i + 1)).intValue();

                        }

                        return intervalos;

                } else {

                        return null;

                }

        }

  /**

         * Obtiene la lista de filtros

         * @return RasterFilterList

         */

        public RasterFilterList getFilterList() {

                return rasterFilterList;

        }

        /**

         * 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.

         */

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

                Object obj = null;

                Class[] args = { RasterFilterListManager.class };

                try {

                        Constructor hazNuevo = clase.getConstructor(args);

                        Object[] args2 = { stackManager };

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

        }

        /**

         * Obtiene el manager registrado a partir de la clase

         * @return

         */

        public IRasterFilterListManager getManagerByClass(Class c) {

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

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

                                return (IRasterFilterListManager) managers.get(j);

                }

                return null;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.grid.filter.IRasterFilterListManager#getRasterFilterList()

         */

        public ArrayList getRasterFilterList() {

                ArrayList filters = new ArrayList();

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

                        ArrayList auxFilters = ((IRasterFilterListManager) managers.get(i)).getRasterFilterList();

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

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

                        }

                }

                return filters;

        }

}