/ - Diff - gvSIG raster - gvSIG

org.gvsig.raster.cache/tags/org.gvsig.raster.cache-2.2.74/org.gvsig.raster.cache.lib.api/src/main/resources/META-INF/services/org.gvsig.tools.library.Library
	1	org.gvsig.raster.cache.tile.TileCacheLibrary

     /* gvSIG. Geographic Information System of the Valencian Government
+     *
      * Copyright (C) 2007-2008 Infrastructures and Transports Department
      * of the Valencian Government (CIT)
+     *
      * 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., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      */
     package org.gvsig.raster.cache.buffer.histogram;
     import org.gvsig.raster.cache.buffer.exception.HistogramException;
     import org.gvsig.raster.cache.buffer.exception.ProcessInterruptedException;
     /**
      * This interface should be implemented for every class that is capable to
      * provide an object to compute its histogram.
+     *
      * @version 27/03/2007
      * @author Nacho Brodin (nachobrodin@gmail.com)
+     *
      */
     public interface Histogramable {
     	/**
     	 * Gets the object which computes the histogram
     	 * @return Histograma
     	 */
     	public HistogramComputer getHistogramComputer() throws HistogramException, ProcessInterruptedException;
+    }

     /* gvSIG. Geographic Information System of the Valencian Government
+     *
      * Copyright (C) 2007-2008 Infrastructures and Transports Department
      * of the Valencian Government (CIT)
+     *
      * 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., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      */
     package org.gvsig.raster.cache.buffer.histogram;
     /**
      * Clase que define un intervalo de datos. Es util para cosas como el calculo de histogramas
      * con tipo de datos en coma flotante en el cual hay que dividir los intervalos en
      * clases. Las clases se tendr?n en cuenta como un intervalo el cual el menor es cerrado y el
      * mayor abierto, es decir
      * <PRE>
      * En las clases:
      * 0-1000
      * 1000-2000
      * los intervalos son
      * [0, 1000 [  de 0-999.9p
      * [1000, 2000[ de 1000-1999.9p
      * </PRE>
+     *
      * @author Nacho Brodin (nachobrodin@gmail.com)
+     *
      */
     public interface HistogramClass {
     	/**
     	 * Comprueba si el valor pasado por par?metro est? dentro del intervalo
     	 * @param value Valor a comprobar
     	 * @return true si est? dentro del intervalo y false si no lo est?
     	 */
     	public boolean isIn(double value);
     	/**
     	 * Obtiene el valor m?ximo de la clase
     	 * @return Entero que representa al valor m?ximo de la clase
     	 */
     	public double getMax();
     	/**
     	 * Asigna el valor m?ximo de la clase
     	 * @param max Entero que representa al valor m?ximo de la clase
     	 */
     	public void setMax(double max);
     	/**
     	 * Obtiene el valor m?nimo de la clase
     	 * @return Entero que representa al valor m?nimo de la clase
     	 */
     	public double getMin();
     	/**
     	 * ASigna el valor m?nimo de la clase
     	 * @param min Entero que representa al valor m?nimo de la clase
     	 */
     	public void setMin(double min);
     	/**
     	 * Obtiene el valor de la clase
     	 * @return double con el valor
     	 */
     	public double getValue();
     	/**
     	 * Asigna el valor de la clase
     	 * @param double con el valor
     	 */
     	public void setValue(double value);
     	/**
     	 * Incrementa en n el valor especificado
     	 * @param double n
     	 */
     	public void increment(double n);
+    }

     /* gvSIG. Geographic Information System of the Valencian Government
+     *
      * Copyright (C) 2007-2008 Infrastructures and Transports Department
      * of the Valencian Government (CIT)
+     *
      * 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., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      */
     package org.gvsig.raster.cache.buffer.histogram;
     import org.gvsig.raster.cache.buffer.BufferNoData;
     /**
      * Interfaz que representa un histograma.
+     *
      * @author Nacho Brodin (nachobrodin@gmail.com)
      */
     public interface BufferHistogram {
     	/**
     	 * Obtiene el n?mero de bandas del histograma
     	 * @return entero que representa el n?mero de bandas
     	 */
     	public int getNumBands();
     	/**
     	 * Obtiene la longitud (n?mero de valores) de una banda determinada
     	 * @param band Banda o obtener la longitud
     	 * @return entero con la longitud de la banda
     	 * rangos de valores y DataclassList.
     	 */
     	public int getBandLenght(int band);
     	/**
     	 * Obtiene el tipo de datos del histograma original
     	 * @return
     	 */
     	public int getDataType();
     	/**
     	 * Asigna un valor para una posici?n del histograma segun la posicion en las
     	 * clases
     	 * @param band Valor del pixel o clase a asignar
     	 * @param pos Posicion dentro de la clase. Ejemplo 0..63
     	 * @param value Valor a asignar
     	 */
     	public void setHistogramValueByPos(int band, int pos, long value);
     	/**
     	 * Obtiene un valor del histograma segun la posicion dentro de las clases
     	 * @param band N?mero de banda del valor a recuperar
     	 * @param px Pixel o valor de la clase del valor a recuperar
     	 * @return valor
     	 */
     	public double getHistogramValueByPos(int band, int pos);
     	/**
     	 * Obtiene un valor del histograma
     	 * @param band N?mero de banda del valor a recuperar
     	 * @param px Pixel o valor de la clase del valor a recuperar
     	 * @return valor
     	 */
     	public double getHistogramValue(int band, double px);
     	/**
     	 * Realiza la uni?n entre el histograma actual y el pasado
     	 * por par?metro.
     	 * @param hist
     	 */
     	public boolean union(BufferHistogram hist);
     	/**
     	 * Obtiene la tabla de valores
     	 * @return
     	 */
     	public long[][] getTable();
     	/**
     	 * Asigna la tabla
     	 * @param t
     	 */
     	public void setTable(long[][] t);
     	/**
     	 * Obtiene el histograma sin modificar
     	 * @return array bidimensional donde el primer elemento es el valor del pixel
     	 * o rango y el segundo el n?mero de elementos que aparecen.
     	 */
     	public HistogramClass[][] getHistogram();
     	/**
     	 * Obtiene el histograma de la imagen negativa.
     	 * @return long[][]
     	 */
     	public long[][] getNegativeTable();
     	/**
     	 * Devuelve el minimo valor del histograma
     	 * @return
     	 */
     	public double getMin(int band);
     	/**
     	 * Devuelve el maximo valor del histograma
     	 * @return
     	 */
     	public double getMax(int band);
     	/**
     	 * Obtiene el n?mero de valores o clases del histograma
     	 * @return entero que representa el n?mero de valores o clases del histograma
     	 */
     	public int getNumValues();
     	/**
     	 * Devuelve si un histograma esta en un rango RGB aceptable
     	 * @return
     	 */
     	public boolean isInRangeRGB();
     	/**
     	 * Calculo de estad?sticas a partir de un histograma. El resultado de la funci?n es un array
     	 * bidimensional donde el primer ?ndice inndica la estadistica y el segundo el n?mero de banda.
+    	 *
     	 * <UL>
     	 * <LI>m?nimo</LI>
     	 * <LI>m?ximo</LI>
     	 * <LI>media</LI>
     	 * <LI>mediana</LI>
     	 * <LI>N?mero de pixels</LI>
     	 * </UL>
     	 * @param histogram
     	 * @param beginPos Posici?n de inicio del histograma para contabilizar estadisticas
     	 * @param endPos Posici?n de fin del histograma para contabilizar estadisticas
     	 * @param bandas solicitadas. Cada elemento del vector representa una banda. Si est? a true se calcula la
     	 * estadistica para esa banda y si est? a false no se calcular?.
     	 * @return
     	 */
     	public double[][] getBasicStats(double beginPos2, double endPos2, boolean[] bands);
     	/**
     	 * Calculo de estad?sticas a partir de un histograma. El resultado de la funci?n es un array
     	 * bidimensional donde el primer ?ndice inndica la estadistica y el segundo el n?mero de banda.
+    	 *
     	 * <UL>
     	 * <LI>m?nimo</LI>
     	 * <LI>m?ximo</LI>
     	 * <LI>media</LI>
     	 * <LI>mediana</LI>
     	 * <LI>N?mero de pixels</LI>
     	 * </UL>
     	 * @param histogram
     	 * @param bandas solicitadas. Cada elemento del vector representa una banda. Si est? a true se calcula la
     	 * estadistica para esa banda y si est? a false no se calcular?.
     	 * @return
     	 */
     	public double[][] getBasicStats(boolean[] bands);
     	/**
     	 * Adds a new table
     	 * @param table
     	 */
     	public void addTable(long[][] table);
     	/**
     	 * Incrementa un valor de una posici?n del histograma
     	 * @param band N?mero de banda
     	 * @param px Pixel o valor de la clase
     	 */
     	public void incrementPxValue(int band, double px);
     	/**
     	 * @param noDataValue the noDataValue to set
     	 */
     	public void setNoDataValue(BufferNoData noDataValue);
+    }

     /* gvSIG. Geographic Information System of the Valencian Government
+     *
      * Copyright (C) 2007-2008 Infrastructures and Transports Department
      * of the Valencian Government (CIT)
+     *
      * 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., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      */
     package org.gvsig.raster.cache.buffer.histogram;
     import org.gvsig.raster.cache.buffer.exception.HistogramException;
     import org.gvsig.raster.cache.buffer.exception.ProcessInterruptedException;
     /**
+     *
      * @author Nacho Brodin (nachobrodin@gmail.com)
      */
     public interface HistogramComputer {
     	/**
     	 * Obtiene el minimo valor de las estadisticas de un histograma.
     	 * @return double
     	 */
     	public double getMinimum();
     	/**
     	 * Obtiene el maximo valor de las estadisticas de un histograma.
     	 * @return double
     	 */
     	public double getMaximum();
     	/**
     	 * Obtiene el histograma.
     	 * @return histograma
     	 */
     	public BufferHistogram getBufferHistogram(int numberOfClasses) throws HistogramException, ProcessInterruptedException;
     	/**
     	 * Pone a cero el porcentaje de progreso del proceso de calculo de histograma
     	 */
     	public void resetPercent();
     	/**
     	 * Obtiene el porcentaje de progreso del proceso de calculo de histograma
     	 * @return porcentaje de progreso
     	 */
     	public int getPercent();
     	/**
     	 * Force to recalculate the histogram next time that the method getBufferHistogram
     	 * be called
     	 */
     	public void refreshHistogram();
+    }

     <?xml version="1.0" encoding="UTF-8" ?>
     <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
     <html xmlns="http://www.w3.org/1999/xhtml">
     <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
     <title>org.gvsig.raster.cache.buffer.histogram package documentation</title>
     </head>
     <body>
     	<p>Classes to get a buffer histogram</p>
     	<p>
     	</p>
     </body>
     </html>

     package org.gvsig.raster.cache.buffer;
     /**
      * Interface implemented by a raster band with statistics
      * capabilities.
+     *
      * @author Nacho Brodin (nachobrodin@gmail.com)
+     *
      */
     public interface StatsValues {
     	/**
     	 * Get the maximun value
     	 * @return double
     	 */
     	public double getMax();
     	/**
     	 * Set the maximun value
     	 * @param max
     	 */
     	public void setMax(double max);
     	/**
     	 * Get the minimun value
     	 * @return double
     	 */
     	public double getMin();
     	/**
     	 * Set the minimun value
     	 * @param max
     	 */
     	public void setMin(double min);
     	/**
     	 * Get the second maximun value
     	 * @return double
     	 */
     	public double getSecondMax();
     	/**
     	 * Set the second maximun value
     	 * @param max
     	 */
     	public void setSecondMax(double secondMax);
     	/**
     	 * Get the second minimun value
     	 * @return double
     	 */
     	public double getSecondMin();
     	/**
     	 * Set the second minimun value
     	 * @param max
     	 */
     	public void setSecondMin(double secondMin);
     	/**
     	 * Get the maximun value in a eight bits band.
     	 * A value of eight bits has a range betwen -127 and 128.
     	 * The maximun is readed in a range betwen 0 and 255.
     	 * @return
     	 */
     	public double getMaxRGB();
     	/**
     	 * Set the maximun value in a eight bits band.
     	 * A value of eight bits has a range betwen -127 and 128.
     	 * The maximun is writed in a range betwen 0 and 255.
     	 * @return
     	 */
     	public void setMaxRGB(double maxRGB);
     	/**
     	 * Get the minimun value in a eight bits band.
     	 * A value of eight bits has a range betwen -127 and 128.
     	 * The minimun is readed in a range betwen 0 and 255.
     	 * @return
     	 */
     	public double getMinRGB();
     	/**
     	 * Set the minimun value in a eight bits band.
     	 * A value of eight bits has a range betwen -127 and 128.
     	 * The minimun is readed in a range betwen 0 and 255.
     	 * @param  minRGB
     	 */
     	public void setMinRGB(double minRGB);
     	/**
     	 * Get the second maximun value in a eight bits band.
     	 * A value of eight bits has a range betwen -127 and 128.
     	 * The second maximun is readed in a range betwen 0 and 255.
     	 * @return
     	 */
     	public double getSecondMaxRGB();
     	/**
     	 * Set the second maximun value in a eight bits band.
     	 * A value of eight bits has a range betwen -127 and 128.
     	 * The second maximun is writed in a range betwen 0 and 255.
     	 * @return
     	 */
     	public void setSecondMaxRGB(double secondMaxRGB);
     	/**
     	 * Get the second minimun value in a eight bits band.
     	 * A value of eight bits has a range betwen -127 and 128.
     	 * The second minimun is readed in a range betwen 0 and 255.
     	 * @return
     	 */
     	public double getSecondMinRGB();
     	/**
     	 * Set the second minimun value in a eight bits band.
     	 * A value of eight bits has a range betwen -127 and 128.
     	 * The second minimun is readed in a range betwen 0 and 255.
     	 * @param  minRGB
     	 */
     	public void setSecondMinRGB(double secondMinRGB);
     	/**
     	 * Get the mean value in this band
     	 * @return
     	 */
     	public double getMean();
     	/**
     	 * Get the mean value in this band
     	 * @param mean
     	 */
     	public void setMean(double mean);
+    }

     package org.gvsig.raster.cache.buffer.exception;
     /**
      * Excepci?n lanzada cuando el n?mero de p?gina al que se intenta acceder no es valido.
      * @author Nacho Brodin (nachobrodin@gmail.com)
+     *
      */
     public class InvalidPageNumberException extends Exception {
     	private static final long serialVersionUID = -4312548276663417111L;
     	public InvalidPageNumberException(String msg){
     		super(msg);
+    	}
+    }

     /* gvSIG. Geographic Information System of the Valencian Government
+     *
      * Copyright (C) 2007-2008 Infrastructures and Transports Department
      * of the Valencian Government (CIT)
+     *
      * 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., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      */
     package org.gvsig.raster.cache.buffer.exception;
     /**
      * Excepci?n lanzada por errores en el calculo de histogramas.
+     *
      * @author Nacho Brodin (nachobrodin@gmail.com)
      */
     public class HistogramException extends Exception {
     	private static final long serialVersionUID = 666908550965442025L;
     	public HistogramException(String msg, Throwable e) {
     		super(msg, e);
+    	}
     	public HistogramException(String msg){
     		super(msg);
+    	}
+    }

     package org.gvsig.raster.cache.buffer.exception;
     /**
      * This exception is throwed when a parameter of a function is wrong.
+     *
      * 24/10/2008
      * @author Nacho Brodin nachobrodin@gmail.com
      */
     public class WrongParameterException  extends Exception {
     	private static final long serialVersionUID = -4312548276663417111L;
     	public WrongParameterException(String msg) {
     		super(msg);
+    	}
+    }

     <?xml version="1.0" encoding="UTF-8" ?>
     <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
     <html xmlns="http://www.w3.org/1999/xhtml">
     <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
     <title>org.gvsig.raster.cache.buffer.exception package documentation</title>
     </head>
     <body>
     	<p>Exceptions which are thrown by a wrong buffer access</p>
     	<p>
     	</p>
     </body>
     </html>

     package org.gvsig.raster.cache.buffer.exception;
     /**
      * Excepci?n lanzada cuando se detecta que un buffer de raster es incorrecto.
      * @author Nacho Brodin (nachobrodin@gmail.com)
+     *
      */
     public class BufferInvalidException extends Exception{
     	private static final long serialVersionUID = -1566113755637911586L;
     	public BufferInvalidException(String msg){
     		super(msg);
+    	}
+    }

     package org.gvsig.raster.cache.buffer.exception;
     /**
      * Excepci?n lanzada cuando se detecta un acceso a un tipo de datos incorrecto
      * en un RasterBuffer.
      * @author Nacho Brodin (nachobrodin@gmail.com)
+     *
      */
     public class BufferInvalidAccessException extends Exception{
     	private static final long serialVersionUID = -3065331336250589153L;
     	public BufferInvalidAccessException(String msg){
     		super(msg);
+    	}
+    }

     /* gvSIG. Geographic Information System of the Valencian Government
+     *
      * Copyright (C) 2007-2008 Infrastructures and Transports Department
      * of the Valencian Government (CIT)
+     *
      * 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., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      */
     package org.gvsig.raster.cache.buffer.exception;
     import org.gvsig.tools.exception.BaseException;
     /**
      * Excepci?n lanzada cuando se interrumpe un proceso
+     *
      * @author Nacho Brodin (nachobrodin@gmail.com)
      */
     public class ProcessInterruptedException extends BaseException {
     	private static final long serialVersionUID = 666908550965442025L;
     	public ProcessInterruptedException(Throwable e){
     		super(e.getMessage(), e, "", 0);
+    	}
     	public ProcessInterruptedException(String msg){
     		super(msg, "", 0);
+    	}
+    }

     package org.gvsig.raster.cache.buffer.exception;
     /**
      * This exception is throwed when a selected band is not compatible with other or
      * with a databuffer.
+     *
      * 24/10/2008
      * @author Nacho Brodin nachobrodin@gmail.com
      */
     public class BandNotCompatibleException  extends Exception {
     	private static final long serialVersionUID = -4312548276663417111L;
     	public BandNotCompatibleException(String msg) {
     		super(msg);
+    	}
+    }

     package org.gvsig.raster.cache.buffer.exception;
     /**
      * This exception is throwed when a selected operation is not compatible with
      * the buffer
+     *
      * 24/10/2008
      * @author Nacho Brodin nachobrodin@gmail.com
      */
     public class OperationNotSupportedException  extends Exception {
     	private static final long serialVersionUID = -4312548276663417111L;
     	public OperationNotSupportedException(String message, Throwable cause) {
            super(message, cause);
+        }
     	public OperationNotSupportedException(String msg) {
     		super(msg);
+    	}
+    }

     <?xml version="1.0" encoding="UTF-8" ?>
     <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
     <html xmlns="http://www.w3.org/1999/xhtml">
     <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
     <title>org.gvsig.raster.cache.buffer package documentation</title>
     </head>
     <body>
     	<p>Basic API to access a buffer of raster data</p>
     	<p>
     	</p>
     </body>
     </html>

     package org.gvsig.raster.cache.buffer;
     import org.gvsig.raster.cache.buffer.exception.ProcessInterruptedException;
     import org.gvsig.raster.cache.buffer.task.IncrementableTask;
     /**
      * Interface implemented by a buffer interpolation object
+     *
      * @author Nacho Brodin (nachobrodin@gmail.com)
      */
     public interface BufferInterpolation extends IncrementableTask {
     	public final static int INTERPOLATION_Undefined        = 0;
     	public final static int INTERPOLATION_NearestNeighbour = 1;
     	public final static int INTERPOLATION_Bilinear         = 2;
     	public final static int INTERPOLATION_InverseDistance  = 3;
     	public final static int INTERPOLATION_Bicubic          = 4;
     	public final static int INTERPOLATION_BSpline          = 5;
     	/**
     	 * Get the supersampled buffer on a IRasterBuffer
     	 * @return
     	 * @throws ProcessInterruptedException
     	 */
     	public Buffer getSupersampledScrolledNearestNeighbour(double[] superSampStep, int w, int h) throws ProcessInterruptedException;
     	public Buffer getSupersampledScrolledBilinearInterpolation(double[] superSampStep, int w, int h) throws ProcessInterruptedException;
     	/**
     	 * Ajusta el raster al ancho y alto solicitado por el vecino m?s cercano. Promedia el valor de dos
     	 * pixeles contiguos.
     	 * @param w Nuevo ancho
     	 * @param h Nuevo alto
     	 */
     	public Buffer adjustRasterNearestNeighbourInterpolation(int w, int h) throws ProcessInterruptedException;
     	/**
     	 * Ajusta el raster al ancho y alto solicitado ajustando con una interpolaci?n bilineal. Promedia
     	 * el valor de cuatro pixeles adyacentes.
     	 * <P>
     	 * Para cada pixel del raster A:(x, y) obtiene el B:(x + 1, y), C:(x, y + 1), D:(x + 1, y + 1)
     	 * Para cada valor del kernel se calcula un valor 'd' que es un peso dependiendo de su posici?n.
     	 * Este peso depende de la posici?n del pixel destino dentro del origen. La posici?n del pixel destino
     	 * en el origen es un valor decimal que puede ir de 0 a 1. Si est? muy pegado a la esquina superior
     	 * izquierda estar? cercano a 0 y si est? muy pegado a la esquina inferior derecha estar? cercano a 1.
     	 * Este valor est? representado por 'dx' y 'dy'.
     	 * </P>
     	 * <P>
     	 * Los pesos aplicados son a
     	 * <UL>
     	 * <LI>A (1-dx) * (1-dy)</LI>
     	 * <LI>B dx * (1-dy)</LI>
     	 * <LI>C (1-dx) * dy</LI>
     	 * <LI>D dx * dy</LI>
     	 * </UL>
     	 * La variable 'z' contiene el valor acumulado de cada peso por el valor del pixel.
     	 * La variable 'n' contiene el valor acumulado de los pesos de los cuatro pixeles.
     	 * El valor final del pixel ser? 'z/n', es decir un promedio del valor de los cuatro teniendo
     	 * en cuenta el peso de cada uno.
     	 * </P>
     	 * @param w Nuevo ancho del buffer de salida
     	 * @param h Nuevo alto del buffer de salida
     	 */
     	public Buffer adjustRasterBilinearInterpolation(int w, int h) throws ProcessInterruptedException;
     	/**
     	 * Ajusta el raster al ancho y alto solicitado ajustando con una interpolaci?n de distancia inversa.
     	 * Asigna el valor de un pixel en funci?n inversa de la distancia.
     	 * <P>
     	 * Para cada pixel del raster A:(x, y) obtiene el B:(x + 1, y), C:(x, y + 1), D:(x + 1, y + 1)
     	 * Para cada valor del kernel se calcula un valor 'd' que es un peso dependiendo de su posici?n.
     	 * Este peso ser? dependiente de la posici?n del pixel destino dentro del origen. La posici?n del pixel destino
     	 * en el origen es un valor decimal que puede ir de 0 a 1. Si est? muy pegado a la esquina superior
     	 * izquierda estar? cercano a 0 y si est? muy pegado a la esquina inferior derecha estar? cercano a 1.
     	 * Este valor est? representado por 'dx' y 'dy'. En este caso, y a diferencia del m?todo
     	 * bilinear el peso vendr? representado por la inversa de la distancia entre la posici?n
     	 * dentro del pixel y el origen del mismo.
     	 * </P>
     	 * <P>
     	 * Los pesos aplicados son a
     	 * <UL>
     	 * <LI>A  1 / sqrt((1-dx) * (1-dy))</LI>
     	 * <LI>B  1 / sqrt(dx * (1-dy))</LI>
     	 * <LI>C  1 / sqrt((1-dx) * dy)</LI>
     	 * <LI>D  1 / sqrt(dx * dy)</LI>
     	 * </UL>
     	 * La variable 'z' contiene el valor acumulado de cada peso por el valor del pixel.
     	 * La variable 'n' contiene el valor acumulado de los pesos de los cuatro pixeles.
     	 * El valor final del pixel ser? 'z/n', es decir un promedio del valor de los cuatro teniendo
     	 * en cuenta el peso de cada uno.
     	 * </P>
     	 * @param w Nuevo ancho del buffer de salida
     	 * @param h Nuevo alto del buffer de salida
     	 */
     	public Buffer adjustRasterInverseDistanceInterpolation(int w, int h) throws ProcessInterruptedException;
     	/**
     	 * Ajusta el raster al ancho y alto solicitado ajustando con una interpolaci?n BSpline. Promedia
     	 * el valor de cuatro pixeles adyacentes.
     	 * @param w Nuevo ancho
     	 * @param h Nuevo alto
     	 */
     	public Buffer adjustRasterBSplineInterpolation(int w, int h) throws ProcessInterruptedException;
     	/**
     	 * Ajusta el raster al ancho y alto solicitado ajustando con una interpolaci?n de spline bicubica.
     	 * @param w Nuevo ancho
     	 * @param h Nuevo alto
     	 */
     	public Buffer adjustRasterBicubicSplineInterpolation(int w, int h) throws ProcessInterruptedException;
     	/**
     	 * Obtiene el porcentaje del proceso de interpolacion
     	 * @return
     	 */
     	public int getPercent();
+    }

     /* gvSIG. Geographic Information System of the Valencian Government
+     *
      * Copyright (C) 2007-2008 Infrastructures and Transports Department
      * of the Valencian Government (CIT)
+     *
      * 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., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      */
     package org.gvsig.raster.cache.buffer;
     import org.gvsig.tools.locator.BaseLocator;
     import org.gvsig.tools.locator.Locator;
     import org.gvsig.tools.locator.LocatorException;
     /**
      * This locator is the entry point for the Raster library, providing
      * access to all Raster services through the {@link BufferCacheManager}
      * .
+     *
      * @author gvSIG team
      * @version $Id$
      */
     public class BufferCacheLocator extends BaseLocator {
         public static final String               MANAGER_NAME            = "BufferCache.manager";
         public static final String               MANAGER_DESCRIPTION     = "BufferCache Manager";
         private static final String              LOCATOR_NAME            = "BufferCache.locator";
         private static final BufferCacheLocator  INSTANCE                = new BufferCacheLocator();
         /**
          * Return the singleton instance.
+         *
          * @return the singleton instance
          */
         public static BufferCacheLocator getInstance() {
             return INSTANCE;
+        }
         /**
          * Return the Locator's name.
+         *
          * @return a String with the Locator's name
          */
         public final String getLocatorName() {
             return LOCATOR_NAME;
+        }
         /**
          * Return a reference to the RasterManager.
+         *
          * @return a reference to the RasterManager
          * @throws LocatorException
          *             if there is no access to the class or the class cannot be
          *             instantiated
          * @see Locator#get(String)
          */
         public static BufferCacheManager getManager() throws LocatorException {
             return (BufferCacheManager) getInstance().get(MANAGER_NAME);
+        }
         /**
          * Registers the Class implementing the RasterManager interface.
+         *
          * @param clazz
          *            implementing the RasterManager interface
          */
         public static void registerManager(
             Class<? extends BufferCacheManager> clazz) {
             getInstance().register(MANAGER_NAME, MANAGER_DESCRIPTION, clazz);
+        }
+    }

     package org.gvsig.raster.cache.buffer.task;
     /**
      * Base class for incrementable tasks
      * @author Nacho Brodin (nachobrodin@gmail.com)
      */
     public interface BaseIncrementableTask {
     	/**
     	 * Gets the increment
     	 * @return int
     	 */
     	public int getPercent();
     	/**
     	 * Sets the increment of this task
     	 */
     	public void setPercent(int value);
+    }

     package org.gvsig.raster.cache.buffer.task;
     import java.util.EventObject;
     /**
      * Evento de cancelaci?n a los procesos registrados en RasterTaskQueue.
+     *
      * @version 17/09/2007
      * @author Nacho Brodin (nachobrodin@gmail.com)
+     *
      */
     public class CancelEvent extends EventObject {
     	private static final long serialVersionUID = 7564626429497930401L;
     	/**
     	 * Construye un CancelEvent
     	 * @param source
     	 */
     	public CancelEvent(Object source) {
     		super(source);
+    	}
+    }

     package org.gvsig.raster.cache.buffer.task;
     /**
      * This interface defines methods for common tasks
+     *
      * @version 07/05/2007
      * @author Nacho Brodin (nachobrodin@gmail.com)
+     *
      */
     public interface IncrementableTask extends BaseIncrementableTask {
     	/**
     	 * Devuelve el contenido del log del IncrementableTask
     	 * @return String
     	 */
     	public String getLog();
     	/**
     	 * <p>Determines if this process can be canceled.</p>
+    	 *
     	 * @return <code>true</code> if this process can be canceled, otherwise <code>false</code>
     	 */
     	public boolean isCancelable();
     	/**
     	 * <p>Determines if this process can be paused.</p>
+    	 *
     	 * @return <code>true</code> if this process can be paused, otherwise <code>false</code>
     	 */
     	public boolean isPausable();
+    }

     <?xml version="1.0" encoding="UTF-8" ?>
     <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
     <html xmlns="http://www.w3.org/1999/xhtml">
     <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
     <title>org.gvsig.raster.cache.buffer.task package documentation</title>
     </head>
     <body>
     	<p>Buffer tasks</p>
     	<p>
     	</p>
     </body>
     </html>

     package org.gvsig.raster.cache.buffer.task;
     import java.util.EventObject;
     import org.gvsig.raster.cache.buffer.exception.ProcessInterruptedException;
     /**
      * Service to send events to a task. To register a new event you have to
      * use the RasterManager
      * <code>TaskEventManager task = manager.createRasterTask(this);</code>
      * You can send events to the task
      * <code>task.sendEvent(new CancelEvent(this));</code>
      * If you want recover a registered task to send it a event you'll have
      * to use the RasterManager again. To get the task it will use the current
      * thread ID.
      * <code>TaskEventManager task = manager.getRasterTask()</code>
+     *
      * @author Nacho Brodin (nachobrodin@gmail.com)
      */
     public interface TaskEventManager {
     	/**
     	 * Removes this task from the repository
     	 * @param
     	 */
     	public void removeTask();
     	/**
     	 * Sets a event.
     	 * @param ev EventObject
     	 */
     	public void setEvent(EventObject ev);
     	/**
     	 * Obtiene el evento
     	 * @return EventObject
     	 */
     	public EventObject getEvent();
     	/**
     	 * Gesti?n de las se?ales. Este m?todo define las acciones por defecto para
     	 * cada se?al. No es necesario utilizar estas. Se puede en cada caso, hacer un m?todo
     	 * manageEvent en el que se gestione las acciones concretas de una se?al.
+    	 *
     	 * @param ev Evento a gestionar
     	 */
     	public void manageEvent(EventObject ev) throws ProcessInterruptedException;
+    }

     package org.gvsig.raster.cache.buffer.task;
     import java.util.EventObject;
     /**
      * A process have to contain a {@link Task} object. A process should be
      * registered when this starts and removed from the register when this finishes or
      * is canceled. This process has to do these actions.
+     *
      * @author Nacho Brodin (nachobrodin@gmail.com)
      */
     public interface Task {
     	/**
     	 * Asigna el evento
     	 * @param ev EventObject
     	 */
     	public void setEvent(EventObject ev);
     	/**
     	 * Obtiene el evento
     	 * @return EventObject
     	 */
     	public EventObject getEvent();
     	/**
     	 * Obtiene el identificador ?nico del proceso.
     	 * @return Identificador del proceso
     	 */
     	public String getID();
     	/**
     	 * Gesti?n de las se?ales. Este m?todo define las acciones por defecto para
     	 * cada se?al. No es necesario utilizar estas. Se puede en cada caso, hacer un m?todo
     	 * manageEvent en el que se gestione las acciones concretas de una se?al.
+    	 *
     	 * @param ev Evento a gestionar
     	 */
     	public  void manageEvent(EventObject ev) throws InterruptedException;
+    }

     /* gvSIG. Geographic Information System of the Valencian Government
+     *
      * Copyright (C) 2007-2008 Infrastructures and Transports Department
      * of the Valencian Government (CIT)
+     *
      * 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., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      */
     package org.gvsig.raster.cache.buffer;
     import org.gvsig.tools.library.AbstractLibrary;
     import org.gvsig.tools.library.LibraryException;
     import org.gvsig.tools.locator.ReferenceNotRegisteredException;
     /**
+     *
      * @author Nacho Brodin (nachobrodin@gmail.com)
      */
     public class BufferCacheLibrary extends AbstractLibrary {
     	public BufferCacheLibrary() {
             registerAsAPI(BufferCacheLibrary.class);
+    	}
     	@Override
         protected void doInitialize() throws LibraryException {
+        }
         @Override
         protected void doPostInitialize() throws LibraryException {
             BufferCacheManager manager = BufferCacheLocator.getManager();
             if (manager == null) {
                 throw new ReferenceNotRegisteredException(
                     BufferCacheLocator.MANAGER_NAME, BufferCacheLocator
                         .getInstance());
+            }
+        }
+    }

     package org.gvsig.raster.cache.buffer;
     import java.io.IOException;
     import org.gvsig.raster.cache.buffer.exception.OperationNotSupportedException;
     import org.gvsig.raster.cache.buffer.exception.ProcessInterruptedException;
     /**
      * Data Server for read only buffers.
      * 02/11/2008
      * @author Nacho Brodin (nachobrodin@gmail.com)
      */
     public interface BufferDataSource {
     	/**
     	 * Get the path to image file
     	 * @return
     	 */
     	public String[] getPath();
     	/**
     	 * Set the path to image file
     	 * @param  path
     	 *         path to the file
     	 */

Application: gvSIG desktop » gvSIG raster

Revision 21032