Application: gvSIG desktop » gvSIG raster

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();

}