Application: gvSIG desktop

/*

 * Cresques Mapping Suite. Graphic Library for constructing mapping applications.

 *

 * Copyright (C) 2004-5.

 *

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

 *

 * For more information, contact:

 *

 * cresques@gmail.com

 */

package org.cresques.filter;

import java.awt.Image;

import java.util.ArrayList;

import java.util.Vector;

import org.cresques.geo.ViewPortData;

import org.cresques.io.data.RasterBuf;

import org.cresques.io.datastruct.Statistic;

import org.cresques.px.Extent;

/**

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

 * RasterFilterStackManager.

 * @author Nacho Brodin (brodin_ign@gva.es)

 *

 */

public class RasterFilterStack {

    private Image                         image = null;

    private RasterBuf                 rasterBuf = null;

    private RasterFilter         rasterFilter = null;

    private int[]                         order = null;

    private Statistic                 stats = null;

    //Pila de objetos Filter (Contiene un RasterFilter)

    private Vector                        stack = new Vector();

    private int                         typeFilter = -1;

    private ViewPortData        viewPortData = null;

    private Extent                        extent = null;

    private int[]                        stepX = null;

    private int[]                        stepY = null;

    /**

     * Constructor

     * @param stats

     */

    public RasterFilterStack(Statistic stats) {

        this.stats = stats;

    }

    /**

     * Resetea el flag de temporalidad de los filtros de la pila.

     * Esto equivale a fijar los filtros que ya existen en la pila. A partir de

     * ese momento los filtros que se introduzcan podr?n ser eliminados de golpe

     * llamando a la funci?n deleteTempFilters

     */

    public void resetTempFilters() {

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

            ((Filter) stack.get(i)).tmp = false;

    }

    /**

     * Elimina los filtros temporales, es decir, todos los filtros introducidos desde

     * el ?ltimo resetTempFilters que se ha realizado.

     */

    public void deleteTempFilters() {

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

            if (((Filter) stack.get(i)).tmp) {

                stack.remove(i);

            }

        }

        sort();

    }

    /**

     * A?ade un filtro a la pila

     * @param type        Tipo de filtro

     * @param filter        filtro a?adido

     */

    public void addFilter(int type, RasterFilter filter) {

        stack.add(new Filter(type, filter));

        this.sort();

    }

    /**

     * Elimina el ?ltimo filtro de la pila

     */

    public void removeFilter() {

        stack.remove(stack.size() - 1);

    }

    /**

     * Asigna el tipo filtro

     * @param type

     */

    public void setDataTypeInFilter(int type) {

        this.typeFilter = type;

    }

    /**

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

     * @return

     */

    public int getOutDataType() {

        if ((image != null) && (rasterBuf == null)) {

            return RasterBuf.TYPE_IMAGE;

        } else {

            return rasterBuf.getDataType();

        }

    }

    /**

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

     * @return

     */

    public Object getResult() {

        if ((image != null) && (rasterBuf == null)) {

            return image;

        } else {

            return rasterBuf;

        }

    }

    /**

     * Devuelve true si typeA est? por encima de typeB en la pila y false si no lo est?

     * @param typeA        Tipo de filtro

     * @param typeB Tipo de filtro

     * @return

     */

    private boolean isOnTop(int typeA, int typeB) {

        int posA = -1;

        int posB = -1;

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

            if (order[i] == typeA) {

                posA = i;

            }

            if (order[i] == typeB) {

                posB = i;

            }

            if ((posA != -1) && (posB != -1)) {

                break;

            }

        }

        if (posA < posB) {

            return true;

        } else {

            return false;

        }

    }

    /**

     * Dado un tipo de filtro calcula a partir de la pila en que posici?n est? situado y

     * obtiene el tipo de dato de la salida anterior. Esto le dir? al cliente de que tipo

     * es el filtro que tiene que introducir.

     * @param type

     */

    public int getDataTypeInFilter(int type) {

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

            if (isOnTop(((Filter) stack.get(i)).type, type)) {

                return ((Filter) stack.get(i)).filter.getOutRasterDataType();

            }

        }

        return this.typeFilter;

    }

    /**

     * Asigna el vector para la ordenaci?n por tipos

     * @param order

     */

    public void setOrder(int[] order) {

        this.order = order;

    }

    /**

     * Ordena los filtros en el orden establecido por el Manager

     */

    public void sort() {

        Vector aux = new Vector();

        for (int norden = order.length - 1; norden >= 0; norden--) {

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

                if (((Filter) stack.get(i)).type == order[norden]) {

                    aux.add(stack.get(i));

                }

            }

        }

        stack = aux;

        aux = null;

    }

    /**

     * Elimina los filtros de la pila de un determinado tipo

     * @param type        Tipo de filtro a eliminar

     */

    public void removeFilter(int type) {

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

            if (((Filter) stack.get(i)).type == type) {

                stack.remove(i);

            }

        }

    }

    /**

     * Elimina un filtro concreto de la pila

     * @param type

     */

    public void removeFilter(RasterFilter filter) {

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

            if (((Filter) stack.get(i)).filter.equals(filter)) {

                stack.remove(i);

            }

        }

    }

    /**

     * Obtiene la cantidad de filtros en la pila

     * @return N?mero de filtros apilados

     */

    public int lenght() {

        return stack.size();

    }

    /**

     * Obtiene el filtro apilado de la posici?n i

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

     * @return        Filtro

     */

    public RasterFilter get(int i) {

        return ((Filter) stack.get(i)).filter;

    }

    /**

     * Obtiene el filtro apilado que corresponde con el tipo

     * @param type        Tipo de filtro

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

     * o null si no hay ninguno.

     */

    public RasterFilter getByType(int type) {

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

                    if(((Filter) stack.get(i)).type == type)

                            return ((Filter) stack.get(i)).filter;

            }

        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 int getType(int i) {

        return ((Filter) stack.get(i)).type;

    }

    /**

     * Elimina todos los filtros de la pila

     */

    public void clear() {

        stack.removeAllElements();

    }

    /**

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

     * @param filter

     * @param i

     */

    public void replace(RasterFilter filter, int i, int type) {

        ((Filter) stack.get(i)).filter = filter;

        ((Filter) stack.get(i)).type = type;

    }

    /**

     * Asigna el raster de entrada inicial

     * @param raster

     */

    public void setInitRasterBuf(Object raster) {

        if (raster instanceof RasterBuf) {

            rasterBuf = (RasterBuf) raster;

            this.typeFilter = rasterBuf.getDataType();

        }

        if (raster instanceof Image) {

            image = (Image) raster;

            this.typeFilter = RasterBuf.TYPE_IMAGE;

        }

    }

    /**

     * Devuelve el tipo de datos inicial de la pila

     * @return Tipo de dato del raster inicial

     */

    public int getInitDataType() {

        return typeFilter;

    }

    /**

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

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

            if (((Filter) stack.get(i)).type == type) {

                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 = stack.size() - 1; i >= 0; i--) {

            if (((Filter) stack.get(i)).filter.equals(filter)) {

                return true;

            }

        }

        return false;

    }

    /**

     * Obtiene el objeto Statistic

     * @return

     */

    public Statistic getStats() {

        return this.stats;

    }

    /**

     * Aplica los filtros de la pila sobre el buffer correspondiente

     * @param dataType

     */

    private void executeFilterByDataType(int dataType) {

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

            RasterFilter filter = ((Filter) stack.get(i)).filter;

            //System.err.println("SACANDO FILTRO "+i+"  "+filter.toString());

            if (filter.getInRasterDataType() == RasterBuf.TYPE_IMAGE) {

                filter.addParam("raster", image);

            } else {

                filter.addParam("raster", rasterBuf);

            }

            filter.setExtent(extent);

            filter.setViewPortData(viewPortData);

            filter.setStep(stepX, stepY);

            filter.execute();

            if (filter.getResult("stats") != null) {

                this.stats = (Statistic) filter.getResult("stats");

            }

            if (filter.getOutRasterDataType() == RasterBuf.TYPE_IMAGE) {

                if (filter.getResult("raster") != null) {

                    this.image = (Image) filter.getResult("raster");

                    this.rasterBuf = null;

                }

            } else {

                if (filter.getResult("raster") != null) {

                    this.rasterBuf = (RasterBuf) filter.getResult("raster");

                    this.image = null;

                }

            }

        }

    }

    /**

     * Aplica los filtros sobre un Image

     * @param image        Buffer inicial sobre el que se aplican los filtros

     */

    public void execute(Image image) {

        this.image = image;

        executeFilterByDataType(RasterBuf.TYPE_IMAGE);

    }

    /**

     * Aplica los filtros sobre un RasterBuf

     * @param rasterBuf        Buffer inicial sobre el que se aplican los filtros

     */

    public RasterBuf execute(RasterBuf rasterBuf) {

        this.rasterBuf = rasterBuf;

        //executeFilterByDataType(RasterBuf.TYPE_SHORT);

        executeFilterByDataType(rasterBuf.getDataType());

        return this.rasterBuf;

    }

    /**

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

     */

    public void show() {

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

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

            System.out.println("FILTRO:" + i + " TIPO:" +

                               ((Filter) stack.get(i)).type + " TEMP:" +

                               ((Filter) stack.get(i)).tmp + " FIL:" +

                               ((Filter) stack.get(i)).filter.toString());

        }

    }

    /**

     * Un RasterFilterStack almacena objetos Filter que representan a un filtro. Esta

     * clase contiene la informaci?n necesaria para el mantenimiento de de la pila y el

     * RasterFilter para cuando se aplica la pila sobre el raster de entrada.

     * @author Nacho Brodin <brodin_ign@gva.es>

     */

    class Filter {

        public int type = 0; //Tipo de filtro. Ctes en RasterFilterStackManager

        public boolean tmp = true; //Flag de temporalidad

        public RasterFilter filter = null; //Filtro

        public Filter(int type, RasterFilter filter) {

            this.filter = filter;

            this.type = type;

        }

    }

        /**

         * @param viewPortData The viewPortData to set.

         */

        public void setViewPortData(ViewPortData viewPortData) {

                this.viewPortData = viewPortData;

        }

        /**

         * @param extent The extent to set.

         */

        public void setExtent(Extent extent) {

                this.extent = extent;

        }

        /**

         * Asigna el valor del paso 

         * @param stepx paso en X

         * @param stepy paso en Y

         */

        public void setStep(int[] stepX, int[] stepY){

                this.stepX = stepX;

                this.stepY = stepY;

        }

}