| gvSIG desktop 1

/* 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.StringTokenizer;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.gvsig.raster.grid.filter.enhancement.BrightnessContrastListManager;

import org.gvsig.raster.grid.filter.enhancement.EnhancementListManager;

import org.gvsig.raster.shared.RasterUtilities;

/*

 * 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 implements IRasterFilterListManager {

    protected RasterFilterList                 rasterFilterList = null;

    private boolean                                 debug = false;

    public int[]                                         priority = null;

    protected ArrayList                         filterList = null;

    private static ArrayList                stackManagerClass = new ArrayList();

    private ArrayList                                 managers = new ArrayList();

    static{

            RasterFilterListManager.addClassListManager(BrightnessContrastListManager.class);

            RasterFilterListManager.addClassListManager(EnhancementListManager.class);

    }

        /**

         * Registra las clases que tendr?n gesti?n de alg?n filtro. Esta funci?n suele llamarse en 

         * la carga de una extensi?n.

         * @param clase Clase a registrar

         */

        public static void addClassListManager(Class clase) {

                boolean esta = false;

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

                        if(((Class)stackManagerClass.get(i)).equals(clase))

                                esta = true;

                if(!esta)

                        RasterFilterListManager.stackManagerClass.add(clase);

        }

    /**

     * Constructor

     * @param filterStack

     */

    public RasterFilterListManager(RasterFilterList filterStack) {

        this.rasterFilterList = filterStack;

        init();

        //Cargamos el manager con los gestores de drivers registrados

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

                Object obj = RasterFilterListManager.loadClass((Class)stackManagerClass.get(i), this);

                if(obj != null)

                        managers.add(obj);

        }

    }

    /**

     * Inicializaci?n. Asigna el orden de los filtros

     */

    protected void init() {

    }

    /**

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

                        classFilter = rasterFilterList.get(i - 1).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();

    }

    /**

     * Obtiene el objeto de estadisticas asignado a la pila.

     * @return

     */

    /*public Statistic getStackStats() {

        return filterStack.getStats();

    }*/

    /* (non-Javadoc)

     * @see org.cresques.io.raster.StackManager#getStringsFromStack()

     */

    public ArrayList getStringsFromStack() {

        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)).getStringsFromStack(filterList, rf);

            }

        }

        return filterList;

    }

    /* (non-Javadoc)

     * @see org.cresques.io.raster.StackManager#getStringsFromStack()

     */

    public ArrayList getStringsFromStack(ArrayList filterList, RasterFilter rf){

            return null;

    }

    /*

     *  (non-Javadoc)

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

     */

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

                return filteri;

        }

    /*

     *  (non-Javadoc)

     * @see org.gvsig.fmap.grid.filter.IStackManager#createStackFromStrings(java.util.ArrayList)

     */

    public void createStackFromStrings(ArrayList f) {

        createStackFromStrings(f, new Integer(0));

    }

    /*

     *  (non-Javadoc)

     * @see org.gvsig.fmap.grid.filter.IStackManager#createStackFromStrings(java.util.ArrayList, java.lang.Integer)

     */

    public void createStackFromStrings(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)).createStackFromStrings(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;

        }

}