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

import org.gvsig.raster.dataset.IBuffer;

import org.gvsig.raster.dataset.Params;

import org.gvsig.raster.shared.Extent;

/**

 * Filtro para raster. Ancestro de todos los filtros.

 *

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

 * @author Luis W. Sevilla (sevilla_lui@gva.es)

 */

public abstract class RasterFilter implements IRasterFilter, Cloneable {

        protected IBuffer                 raster = null;

        protected int                         height = 0;

        protected int                         width = 0;

        protected Hashtable        params = new Hashtable();

        protected Extent                extent = null;

        private int                                 percent = 0;

        private boolean                        canceled = false;

        private String                        fName = "";

        /**

         * Variable que control la aplicaci?n o no del filtro. Si est? a false aunque est? en

         * la pila el filtro no se ejecutar?.

         */

        protected boolean                 exec = true;

        /**

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

         */

        public static class Kernel {

                public double[][]        kernel        = null;

                protected double        divisor = 0;

                public Kernel(double[][] k) {

                        this.kernel = k;

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

                                for (int j = 0; j < kernel[0].length; j++)

                                        divisor = divisor + kernel[i][j];

                }

                public Kernel(double[][] k,double divisor) {

                        this.kernel = k;

                        this.divisor = divisor;

                }

                public double kernelOperation(Kernel k) {

                        double res = 0;

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

                                for (int j = 0; j < kernel[0].length; j++)

                                        res += kernel[i][j] * k.kernel[i][j];

                        return res;

                }

                public double convolution(Kernel k) {

                        double res = 0;

                        res = this.kernelOperation(k);

                        if (this.divisor != 0)

                                res = res / divisor;

                        return Math.abs(res);

                }

                public double getDivisor() {

                        return divisor;

                }

                public void setDivisor(double divisor) {

                        this.divisor = divisor;

                }

                public int getLado() {

                        return kernel.length;

                }

        }

        /**

         * Constructor

         */

        public RasterFilter() {

        }

        /**

         * Aplica el filtro sobre el raster pasado pixel a pixel

         * @throws InterruptedException

         */

        public void execute() throws InterruptedException {

                pre();

                percent = 0;

                if (exec) {

                        for (int row = 0; row < height; row ++) {

                                for (int col = 0; col < width; col ++)

                                        process(col, row);

                                if (Thread.currentThread().isInterrupted())

                                        throw new InterruptedException("Process execute Filter");

                                percent = (row * 100) / height;

                        }

                }

                if (isCanceled())

                        return;

                percent = 100;

                post();

        }

        /**

         * A?ade un par?metro al filtro

         *

         * @param name Clave del par?metro

         * @param param Objeto pasado como par?metro

         */

        public void addParam(String name, Object param) {

                if (param != null)

                        params.put(name, param);

                else

                        params.remove(name);

        }

        /**

         * Elimina un par?metro del filtro

         * @param name Clave del par?metro a eliminar

         */

        public void removeParam(String name) {

                params.remove(name);

        }

        /**

         * Obtiene un par?metro a partir de la clave

         * @param name Par?metro

         * @return Par?metro

         */

        public Object getParam(String name) {

                return params.get(name);

        }

                /**

         * @param extent The extent to set.

         */

        public void setExtent(Extent extent) {

                this.extent = extent;

        }

        /**

         * Obtiene true si el filtro va a ser ejecutado o false si no va a serlo

         * @return

         */

        public boolean isExec() {

                return exec;

        }

        /**

         * Asigna el valor a la variable exec. Esta estar? a true si el filtro se ejecutar? la pr?xima

         * vez que se repinte o false si no se ejecuta.

         * @param exec

         */

        public void setExec(boolean exec) {

                this.exec = exec;

        }

        /**

         * Establece si se ha de cancelar un proceso de filtrado o no.

         * @param value

         */

        public void setCanceled(boolean value) {

                canceled = value;

        }

        /**

         * Devuelve si se ha cancelado el proceso de filtrar.

         * @return

         */

        public boolean isCanceled() {

                return canceled;

        }

        /**

         * Pone a cero el contador del porcentaje del proceso de filtrado

         * @return

         */

        public void resetPercent() {

                percent = 0;

        }

        /**

         * Obtiene el porcentaje recorrido del proceso de filtrado

         * @return

         */

        public int getPercent() {

                return percent;

        }

        /**

         * Funci?n que contiene el c?digo a ejecutar antes de aplicar el filtro

         */

        abstract public void pre();

        /**

         * Funci?n que contiene el c?digo a ejecutar despues de aplicar el filtro

         */

        abstract public void post();

        /**

         * Ejecuci?n del filtro para un pixel de la imagen

         */

        abstract public void process(int x, int y);

        /**

         * Obtiene el tipo de datos del raster de entrada

         */

        abstract public int getInRasterDataType();

        /**

         * Obtiene el tipo de datos del raster de salida

         */

        abstract public int getOutRasterDataType();

        /**

         * Obtiene el resultado del filtro despues de su ejecuci?n a trav?s de una clave

         * @param name        clave para obtener un objeto resultado del filtro.

         */

        abstract public Object getResult(String name);

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.grid.filter.IRasterFilter#getGroup()

         */

        abstract public String getGroup();

        /**

         * Obtener que datos puede tratar una interfaz con sus valores

         * @param nameFilter. Cada tipo de filtro puede tener parametros distintos

         * @return

         */

        abstract public Params getUIParams(String nameFilter);

        /**

         * Obtener que las entradas que puede aperecer un filtro en el interfaz

         * @return

         */

        abstract public String[] getNames();

        /**

         * Devolver? un booleano indicando si es visible o no en el panel de filtros.

         * @return

         */

        public boolean isVisible() {

                return true;

        }

        /* (non-Javadoc)

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

         */

        public Object clone() throws CloneNotSupportedException {

                return super.clone();

        }

        /**

         * Devuelve el nombre interno del filtro

         * @return the fName

         */

        public String getName() {

                return fName;

        }

        /**

         * @param name the fName to set

         */

        public void setName(String name) {

                fName = name;

        }

}