| gvSIG desktop 1

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

*

* Copyright (C) 2004 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.cresques.filter.convolution;

import java.util.ArrayList;

import org.cresques.filter.IStackManager;

import org.cresques.filter.RasterFilter;

import org.cresques.filter.RasterFilterStack;

import org.cresques.filter.RasterFilterStackManager;

import org.cresques.filter.RasterFilter.Kernel;

import org.cresques.io.GeoRasterFile;

import org.cresques.io.data.RasterBuf;

/**

 * Gestor de la pila de filtros para el filtro de convoluci?n.

 *

 * @author Diego Guerrero Sevilla  <diego.guerrero@uclm.es>

 *

 */

public class ConvolutionStackManager implements IStackManager {

        public final static int                                convolution = 11;

        protected RasterFilterStack                 filterStack = null;

        private RasterFilterStackManager        filterStackManager = null;

        private GeoRasterFile[]                         grfList = null;

        public ConvolutionStackManager(RasterFilterStackManager filterStackManager){

                this.filterStackManager = filterStackManager;

                this.filterStack = filterStackManager.getFilterStack();

                filterStackManager.addTypeFilter("convolution", ConvolutionStackManager.convolution, 8);

        }

        /**

         * Obtiene el valor entero que corresponde al tipo de filtro.

         * @param rasterFilter

         * @return

         */

        public int getType(RasterFilter rasterFilter){

                if(rasterFilter instanceof ConvolutionFilter)

                        return ConvolutionStackManager.convolution;

                return -1;

        }

        /**

         * A?ade un filtro de convoluci?n a la pila de filtros.

         * @param kernel Kernel usado en la convoluci?n

         * @param umbral Umbral aplicado al resultado de la convoluci?n. Si 0, no umbraliza.

         * @param filterName Nombre del filtro.

         */

        public void addConvolutionFilter(RasterFilter.Kernel kernel, int umbral, String filterName){

                RasterFilter filtro = null;

                switch(filterStack.getDataTypeInFilter(((Integer)this.filterStackManager.getTypeFilters().get("convolution")).intValue())){

                case RasterBuf.TYPE_IMAGE:

                        filtro = new ConvolutionImageFilter(filterName);

                        break;

                case RasterBuf.TYPE_SHORT:

                        filtro = new ConvolutionShortFilter(filterName);

                        break;

                case RasterBuf.TYPE_USHORT:

                        filtro = new ConvolutionShortFilter(filterName);

                        break;

                case RasterBuf.TYPE_INT:

                        filtro = new ConvolutionIntegerFilter(filterName);

                        break;

                case RasterBuf.TYPE_FLOAT:

                        filtro = new ConvolutionFloatFilter(filterName);

                        break;

                case RasterBuf.TYPE_DOUBLE:

                        filtro = new ConvolutionDoubleFilter(filterName);

                        break;

                }

                //Cuando el filtro esta creado, tomamos los valores y lo a?adimos a la pila

                if(filtro != null){

                        filtro.addParam("kernel", kernel);

                        filtro.addParam("umbral",new Integer(umbral));

                        filterStack.addFilter(((Integer) filterStackManager.getTypeFilters().get("convolution")).intValue(), filtro);

                        filterStackManager.controlTypes();

                }

        }

        public ArrayList getStringsFromStack() {

                // TODO Auto-generated method stub

                return null;

        }

        public ArrayList getStringsFromStack(ArrayList filterList, RasterFilter cf) {

                        if(cf instanceof ConvolutionFilter){

                                filterList.add("filter.convolution.active=true");

                                Kernel ker =((ConvolutionFilter)cf).kernel;

                                ConvolutionFilter convolution = (ConvolutionFilter)cf;

                                String listValues = "";

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

                                        for(int fila = 0; fila < ker.kernel[col].length; fila++)

                                                listValues += ker.kernel[col][fila]+ " ";

                                filterList.add("filter.convolution.divisor="+ker.getDivisor());

                                filterList.add("filter.convolution.filterName="+convolution.getFilterName());

                                filterList.add("filter.convolution.umbral="+convolution.umbral);

                                filterList.add("filter.convolution.kernel="+listValues);

                        }

                        return filterList;

        }

        public void createStackFromStrings(ArrayList f, Integer pos) {

                // TODO Auto-generated method stub

        }

        /**

     * 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 int createStackFromStrings(ArrayList filters, String fil,

                        GeoRasterFile[] grfList, int filteri) {

                this.grfList = grfList;

                if((fil.startsWith("filter.convolution.active"))&&

                                (RasterFilterStackManager.getValue(fil).equals("true"))){

                        RasterFilter.Kernel kernel = null;

                        String filterName = null;

                        int umbral = 0;

                        double divisor = 0;

                        double k[][] = null;

                        filters.remove(0);

                        for(int prop = 0; prop < filters.size() ; prop++){

                                String elem = (String) filters.get(prop);

                                if(elem.startsWith("filter.convolution.filterName")){

                                        filterName = RasterFilterStackManager.getValue(elem);

                                        filters.remove(prop);

                                        prop--;

                                }

                                if(elem.startsWith("filter.convolution.divisor")){

                                        divisor = Double.parseDouble(RasterFilterStackManager.getValue(elem));

                                        filters.remove(prop);

                                        prop--;

                                }

                                if(elem.startsWith("filter.convolution.umbral")){

                                        umbral = Integer.parseInt(RasterFilterStackManager.getValue(elem));

                                        filters.remove(prop);

                                        prop--;

                                }

                                if(elem.startsWith("filter.convolution.kernel")){

                                        String listValues = RasterFilterStackManager.getValue(elem);

                                        String stringArray[] = listValues.split(" ");

                                        int ladoVentana =  (int)Math.sqrt(stringArray.length);

                                        k = new double[ladoVentana][ladoVentana];

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

                                                for(int fila = 0; fila < ladoVentana; fila++)

                                                        k[col][fila]=Double.parseDouble(stringArray[col*fila]);

                                        kernel = new Kernel(k,divisor);

                                        filters.remove(prop);

                                        prop--;

                                }

                        }

                        addConvolutionFilter(kernel,umbral,filterName);

                }

        //return filteri;

                return -1;

        }

}