/tags/gvSIGv0_6_1RELEASE/libraries/libCq CMS for java.old/src/org/cresques/io/raster/RasterFilterStack.java - Application: gvSIG desktop - gvSIG

svn-gvsig-desktop / tags / gvSIGv0_6_1RELEASE / libraries / libCq CMS for java.old / src / org / cresques / io / raster / RasterFilterStack.java @ 5222

History | View | Annotate | Download (12.5 KB)

       /*
        * 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.io.raster;
       import java.awt.Image;
       import java.util.Vector;
       import org.cresques.geo.ViewPortData;
       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 RasterStats         stats = null;
           private Vector                        stack = new Vector();
           private int                         typeFilter = -1;
           private ViewPortData        viewPortData = null;
           private Extent                        extent = null;
           /**
            * Constructor
            * @param stats
            */
           public RasterFilterStack(RasterStats 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
            */
           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 RasterStats
            * @return
            */
           public RasterStats 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.execute();
                   if (filter.getResult("stats") != null) {
                       this.stats = (RasterStats) 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 void execute(RasterBuf rasterBuf) {
               this.rasterBuf = rasterBuf;
               executeFilterByDataType(RasterBuf.TYPE_SHORT);
+          }
           /**
            *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;
+              }
+      }