Application: gvSIG desktop

package org.gvsig.rasterTools.pansharpening.filter;

import java.util.ArrayList;

import org.cresques.io.GeoRasterFile;

import org.cresques.io.raster.IStackManager;

import org.cresques.io.raster.RasterBuf;

import org.cresques.io.raster.RasterFilter;

import org.cresques.io.raster.RasterFilterStack;

import org.cresques.io.raster.RasterFilterStackManager;

/**

 * Gestor de pila para el filtro de panshapening. 

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

 */

public class PanSharpeningStackManager implements IStackManager{

        //public static String                                 defaultClass = "org.gvsig.rasterTools.pansharpening.filter.PanSharpeningStackManager";

        public final static int                                sharpening = 5;

        protected RasterFilterStack                 filterStack = null;

        private GeoRasterFile[]                         grfList = null;

        private RasterFilterStackManager        filterStackManager = null;

        public PanSharpeningStackManager(RasterFilterStackManager filterStackManager){

                this.filterStackManager = filterStackManager;

                this.filterStack = filterStackManager.getFilterStack();

                filterStackManager.addTypeFilter("sharpening", PanSharpeningStackManager.sharpening, 0);

                filterStackManager.register(this);

        }

        /**

     * A?ade un filtro ComputeMinMax

     * @param files Ficheros que componen la imagen

     * @param i        Posici?n de la imagen de refinado dentro de la lista de GeoRasterFile

     * @param order        Orden de visualizado de las bandas RGB

     * @param alpha        Alpha aplicado a toda la imagen

     * @param method M?todo de calculo del refinado

     * @param coef        Coeficiente

     */

    public void addSharpeningFilter(GeoRasterFile[] files, int i, int[] order, int alpha, String method, double coef, int coefBrovey) {

            //Si ya hay un filtro de sharpening nos lo cargamos

            if (filterStack.isActive(((Integer)filterStackManager.getTypeFilters().get("sharpening")).intValue())) {

            filterStack.removeFilter(((Integer) filterStackManager.getTypeFilters().get("sharpening")).intValue());

        }

        RasterFilter filtro = null;

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

            case RasterBuf.TYPE_IMAGE:

                filtro = new PanSharpeningImageFilter();

                break;

            case RasterBuf.TYPE_SHORT:

            case RasterBuf.TYPE_USHORT:

            case RasterBuf.TYPE_INT:

                //filtro = new SharpeningShortFilter();

                break;

            }

        if(filtro != null){

                filtro.addParam("stats", filterStack.getStats());

                filtro.addParam("pancromatica", new Integer(i));

                filtro.addParam("files", files);

                filtro.addParam("order", order);

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

                filtro.addParam("method", method);

                filtro.addParam("coef", new Double(coef));

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

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

                filterStackManager.controlTypes();

        }

    }

    /**

     * Obtiene el valor entero que corresponde al tipo de filtro del filtro pasado por par?metro.

     * @param rasterFilter 

     * @return Entero que representa el tipo de filtro

     */

    public int getType(RasterFilter rasterFilter){

                if(rasterFilter instanceof PanSharpeningFilter)

                        return PanSharpeningStackManager.sharpening;

                return filterStackManager.getType(rasterFilter);

        }

    public ArrayList getStringsFromStack(ArrayList filterList, RasterFilter rf){

            if (rf instanceof PanSharpeningFilter) {

                    PanSharpeningFilter sharp = ((PanSharpeningFilter) rf);

//                    filterList.add("filter.className="+PanSharpeningStackManager.defaultClass);

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

            filterList.add("filter.pansharpening.posPancromatica="+sharp.posPancromatica);

            filterList.add("filter.pansharpening.bandOrder="+sharp.bandOrder[0]+","+sharp.bandOrder[1]+","+sharp.bandOrder[2]);

            for(int file=0;file<sharp.files.length;file++)

                    filterList.add("filter.pansharpening.file"+file+"="+sharp.files[file].getName());

            filterList.add("filter.pansharpening.method="+sharp.method);

            filterList.add("filter.pansharpening.coefHSL="+sharp.coef);

            filterList.add("filter.pansharpening.coefBrovey="+sharp.coefBrovey);

            filterList.add("filter.pansharpening.alpha="+sharp.alpha);

        }

            return filterList;

        }

    /**

     * 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 void createStackFromStrings(ArrayList f, GeoRasterFile[] grfList) {

            this.grfList = grfList;

        this.createStackFromStrings(f, new Integer(0));

    }

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

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

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

             filters.remove(filteri);

             int posPancromatica = 0;

             int[] bandOrder = {0, 1, 2};

             ArrayList files = new ArrayList();

             int alpha = 0;

             String method = "";

             double coef = 0D;

             int coefBrovey = 0;

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

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

                 if (elem.startsWith("filter.pansharpening.posPancromatica")) {

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

                     filters.remove(propFilter);

                     propFilter--;

                 }

                 if (elem.startsWith("filter.pansharpening.bandOrder")) {

                         String rango = RasterFilterStackManager.getValue(elem);

                     bandOrder[0] = Integer.parseInt(rango.substring(0, rango.indexOf(",")));

                     bandOrder[1] = Integer.parseInt(rango.substring(rango.indexOf(",") + 1, rango.lastIndexOf(",")));

                     bandOrder[2] = Integer.parseInt(rango.substring(rango.lastIndexOf(",") + 1, rango.length()));

                     filters.remove(propFilter);

                     propFilter--;

                 }

                 if (elem.startsWith("filter.pansharpening.file")) {

                     files.add(RasterFilterStackManager.getValue(elem));

                     filters.remove(propFilter);

                     propFilter--;

                 }

                 if (elem.startsWith("filter.pansharpening.alpha")) {

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

                     filters.remove(propFilter);

                     propFilter--;

                 }

                 if (elem.startsWith("filter.pansharpening.method")) {

                     method = RasterFilterStackManager.getValue(elem);

                     filters.remove(propFilter);

                     propFilter--;

                 }

                 if (elem.startsWith("filter.pansharpening.coefHSL")) {

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

                     filters.remove(propFilter);

                     propFilter--;

                 }

                                        if (elem.startsWith("filter.pansharpening.coefBrovey")) {

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

                                                //filters.remove(propFilter);

                                                //propFilter--;

                                        }

             }

             addSharpeningFilter(this.grfList, posPancromatica, bandOrder, alpha, method, coef, coefBrovey);

             filteri = -1;

         }

                 return filteri;

        }

        public void createStackFromStrings(ArrayList f, Integer pos) {

                // TODO Auto-generated method stub

        }

        public ArrayList getStringsFromStack() {

                // TODO Auto-generated method stub

                return null;

        }

}