| 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.segmentation;

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.io.GeoRasterFile;

import org.cresques.io.data.RasterBuf;

/**

 * Gestor de la pila de filtros para el filtro de Sobel.

 * 

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

 *

 */

public class FirstDerivativeStackManager implements IStackManager {

        public final static int                                firstDerivative = 12;

        protected RasterFilterStack                 filterStack = null;

        private RasterFilterStackManager        filterStackManager = null;

        private GeoRasterFile[]                         grfList = null;

        public FirstDerivativeStackManager(RasterFilterStackManager filterStackManager) {

                this.filterStackManager = filterStackManager;

                this.filterStack = filterStackManager.getFilterStack();

                filterStackManager.addTypeFilter("firstDerivative", FirstDerivativeStackManager.firstDerivative, 8);

        }

        /**

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

         * @param kernel

         */

        public void addFirstDerivativeFilter(int umbral,int operator,boolean compare,String Name){

                RasterFilter filtro = null;

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

                case RasterBuf.TYPE_IMAGE:

                        filtro = new FirstDerivativeImageFilter(Name);

                        break;

                case RasterBuf.TYPE_SHORT:

                        filtro = new FirstDerivativeShortFilter(Name);

                        break;

                case RasterBuf.TYPE_USHORT:

                        filtro = new FirstDerivativeShortFilter(Name);

                        break;

                case RasterBuf.TYPE_INT:

                        filtro = new FirstDerivativeIntegerFilter(Name);

                        break;

                case RasterBuf.TYPE_FLOAT:

                        filtro = new FirstDerivativeFloatFilter(Name);

                        break;

                case RasterBuf.TYPE_DOUBLE:

                        filtro = new FirstDerivativeDoubleFilter(Name);

                        break;

                }

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

                if(filtro != null){

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

                        filtro.addParam("compare",new Boolean(compare));

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

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

                        filterStackManager.controlTypes();

                }

        }

        public ArrayList getStringsFromStack() {

                // TODO Auto-generated method stub

                return null;

        }

        public ArrayList getStringsFromStack(ArrayList filterList, RasterFilter rf) {

                if(rf instanceof FirstDerivativeFilter){

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

                        FirstDerivativeFilter firstDerivative = (FirstDerivativeFilter) rf;

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

                        filterList.add("filter.firstDerivative.operartor="+firstDerivative.operator);

                        filterList.add("filter.firstDerivative.compare="+firstDerivative.compare);

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

        }

                return filterList;

        }

        public void createStackFromStrings(ArrayList f, Integer pos) {

                // TODO Auto-generated method stub

        }

        public int createStackFromStrings(ArrayList filters, String fil,

                        GeoRasterFile[] grfList, int filteri) {

                this.grfList = grfList;

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

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

                        int umbral = 0;

                        boolean compare = false;

                        int operator = 0;

                        String name="";

                        filters.remove(0);

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

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

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

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

                                        filters.remove(prop);

                                        prop--;

                                }

                                if(elem.startsWith("filter.firstDerivative.compare")){

                                        compare = Boolean.getBoolean(RasterFilterStackManager.getValue(elem));

                                        filters.remove(prop);

                                        prop--;

                                }

                                if(elem.startsWith("filter.firstDerivative.operartor")){

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

                                        filters.remove(prop);

                                        prop--;

                                }

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

                                        name = RasterFilterStackManager.getValue(elem);

                                        filters.remove(prop);

                                        prop--;

                                }

                        }

                        addFirstDerivativeFilter(umbral,operator,compare,name);

                }

        //return filteri;

                return -1;

        }

        /**

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

         * @param rasterFilter

         * @return

         */

        public int getType(RasterFilter rasterFilter){

                if(rasterFilter instanceof FirstDerivativeFilter)

                        return FirstDerivativeStackManager.firstDerivative;

                return -1;

        }

}