/ - Diff - gvSIG raster - gvSIG

     /* 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.tile;
     import java.io.File;
     import org.gvsig.raster.cache.tile.exception.TileGettingException;
     import org.gvsig.raster.cache.tile.pool.ThreadPool;
     import org.gvsig.raster.cache.tile.provider.Downloader;
     import org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase;
     /**
+     *
      * @author Nacho Brodin (nachobrodin@gmail.com)
      */
     public class TestThreadPool extends AbstractLibraryAutoInitTestCase {
     	private static final int  WIDTH           = 3;
     	private static final int  HEIGHT          = 3;
     	private static final int  DOWNLOAD_TIME   = 500;
     	public class MyDownloader implements Downloader {
     		public Tile downloadTile(Tile tile) {
     			//tile.getFile() -> Aqui se guarda el fichero descargado
     			try {
     				Thread.sleep(DOWNLOAD_TIME);
     			} catch (InterruptedException e) {
     				e.printStackTrace();
+    			}
     			return tile;
+    		}
     		public Tile readTileFromDisk(Tile tile) throws TileGettingException {
     			// TODO Auto-generated method stub
     			return null;
+    		}
     		/*
     		 * (non-Javadoc)
     		 * @see org.gvsig.raster.cache.tile.provider.Downloader#cancelDownloading(boolean)
     		 */
     		public void cancelDownloading(boolean cancel) {
+    		}
     		public Object[] getCrashImage(int w, int h) {
     			// TODO Auto-generated method stub
     			return null;
+    		}
     		public Object[] getDownloadingImage(int w, int h) {
     			// TODO Auto-generated method stub
     			return null;
+    		}
+    	}
     	public void start() {
     		try {
     			this.doSetUp();
     		} catch (Exception e) {
     			e.printStackTrace();
+    		}
     		this.testStack();
+    	}
     	@Override
     	protected void doSetUp() throws Exception {
     		System.err.println("TestThreadPool running...");
+    	}
     	public void testStack() {
     		ThreadPool pool = TileCacheLocator.getManager().createThreadPool(false);
     		MyDownloader d = new MyDownloader();
     		for (int x = 0; x < HEIGHT; x++) {
     			for (int y = 0; y < WIDTH; y++) {
     				Tile t = TileCacheLocator.getManager().createTile(0, x, y);
     				t.setSharedPipe(pool.getTilePipe());
     				t.setDownloader(d);
     				t.setFile(new File(""));
     				pool.addTask(t);
+    			}
+    		}
     		int nCollected = 0;
     		while (nCollected < (WIDTH * HEIGHT)) {
     			Tile tile = (Tile)pool.getTilePipe().getAtomicTask();
     			System.out.println("Getting " + tile.getRow() + " " + tile.getCol() + " P:" + tile.getPriority());
     			nCollected ++;
+    		}
     		if(pool != null)
     			pool.destroyPool();
+    	}
+    }

     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 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);
+    	}
+    }

     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);
+    	}
+    }

     <?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>

     /* 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;
     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();
+    }

     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;
+    }

     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);
+    	}
+    }

     /* 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
     	 */
     	public void setPath(String[] path);
     	/**
     	 * Set the path to image file
     	 * @param  path
     	 *         path to the file
     	 */
     	public void setPath(String path);
     	/**
     	 * Get the band selected to read for loadSelectedBand method
     	 * @return
     	 */
     	public int getSelectedBand();
     	/**
     	 * Set the band selected to read for loadSelectedBand method
     	 * @param  band
     	 *         band to the file
     	 */
     	public void setSelectedBand(int path);
     	/**
     	 * Get the width of the data source
     	 * @return
     	 */
     	public int getWidth();
     	/**
     	 * Get the height of the data source
     	 * @return
     	 */
     	public int getHeight();
     	/**
     	 * Get de number of bands
     	 * @return
     	 */
     	public int getBandCount();
     	/**
     	 * Get the data type
     	 * @return
     	 */
     	public int getDataType();
     	/**
     	 * Load a page with data.
     	 * @param  rb
     	 *         Page
     	 * @param  stripe
     	 *         Object with the information about data read. This contains positional information.
     	 * @throws IOException
     	 * @throws InterruptedException
     	 * @throws OperationNotSupportedException
     	 */
     	public void loadPage(Buffer rb, PxTile stripe) throws IOException, ProcessInterruptedException, OperationNotSupportedException;
     	/**
     	 * Load a one banded page with data.
     	 * @param  rb
     	 *         Page
     	 * @param  stripe
     	 *         Object with the information about data read. This contains positional information.
     	 * @param  iBand
     	 *         Band to load
     	 * @throws IOException
     	 * @throws InterruptedException
     	 * @throws OperationNotSupportedException
     	 */
     	public void loadPage(Buffer rb, PxTile stripe, int iBand) throws IOException, ProcessInterruptedException, OperationNotSupportedException;
     	/**
     	 * Load a page with data. Only is loaded the band selected in the variable "selectedBand"
     	 * @param  rb
     	 *         Page
     	 * @param  stripe
     	 *         Object with the information about data read. This contains positional information.
     	 * @throws IOException
     	 * @throws OperationNotSupportedException
     	 * @throws ProcessInterruptedException
     	 */
     	public void loadSelectedBand(Buffer rb, PxTile stripe) throws IOException, OperationNotSupportedException, ProcessInterruptedException;
     	/**
     	 * Load a page of cache from the hard disk
     	 * @param RasterMemoryBuffer Data buffer to load in memory
     	 * @param String File name
     	 */
     	public void loadPage(Buffer buf, String file) throws InterruptedException;
     	/**
     	 * Save a page of cache to the hard disk
     	 * @param RasterMemoryBuffer Data buffer to load in memory
     	 * @param String File name
     	 * @throws IOException
     	 */
     	public void savePage(Buffer buf, String file)throws IOException;
     	/**
     	 * Save a band of cache to the hard disk
     	 * @param RasterMemoryBuffer Data buffer to load in memory
     	 * @param String File name
     	 * @throws IOException
     	 */
     	public void saveBand(Band buf, String file)throws IOException;
     	/**
     	 * Elimina la fuente de datos de disco
     	 * @throws IOException
     	 */
     	public void delete(String file)throws IOException;
     	/**
     	 * Close the data source
     	 */
     	public void close() throws IOException;
     	/**
     	 * Change the name of a file
     	 * @param oldName
     	 * @param newName
     	 */
     	public void changeFileName(String oldName, String newName);
     	/**
     	 * Clone the datasource to be assigned to each band
     	 * @return
     	 */
     	public BufferDataSource clone();
+    }

     /* 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 java.io.IOException;
     import org.gvsig.raster.cache.buffer.histogram.BufferHistogram;
     import org.gvsig.raster.cache.buffer.task.TaskEventManager;
     /**
      * This class is responsible of the management of the library's business logic.
      * It is the library's main entry point, and provides all the services to manage
      * {@link BufferCacheService}s.
+     *
      * @author Nacho Brodin (nachobrodin@gmail.com)
      * @version $Id$
      */
     public interface BufferCacheManager {
     	public static int		      DONT_FORCE                 = 0;
     	public static int		      MEMORY_BUFFER              = 1;
     	public static int		      BAND_CACHE                 = 2;
     	public static int		      BAND_VERT_CACHE            = 3;
     	public static int		      READ_ONLY_CACHE            = 4;
     	/**
     	 * Valor noData por defecto para la librer?a. En caso de no tener un valor asociado
     	 * al raster se usar? este.
     	 */
     	public static double            defaultNoDataValue       = -99999;
     	public static boolean           noDataValueEnable        = false;
     	//*****************************************************
     	//BUFFER API
     	//*****************************************************
     	/**
     	 * Genera instancias del buffer de datos adecuado al tama?o del raster. Si no hay muchos datos
     	 * (menos de cacheMemorySize) crear? un buffer en memoria. Si hay m?s de esta cantidad
     	 * entonces crearemos un buffer cacheado (RasterCache). A partir de la cantidad se?alada
     	 * por multicacheMemorySize haremos un buffer cacheado donde cada p?gina no ocupa todo
     	 * el ancho del raster ya que este ser? muy grande. La gesti?n de una cache donde cada
     	 * pagina ha de partir una l?nea lleva una complejidad a?adida.
+    	 *
     	 * @param params Par?metros de la carga
     	 * @return Objeto RasterBuffer
     	 */
     	public Buffer createBuffer(BufferParam params);
     	/**
     	 * Genera una instancia del buffer de solo lectura. Este buffer consta de una cache y unos apuntadores
     	 * a las p?ginas en disco. Cuando se accede a los datos se carga en memoria la p?gina pedida.
+    	 *
     	 * @param  file
     	 *         File to read data
     	 */
     	public Buffer createReadOnlyBuffer(String file);
     	/**
     	 * Creates an instance of a memory buffer
+    	 *
     	 * @param dataType Tipo de dato
     	 * @param width Ancho
     	 * @param height Alto
     	 * @param bandNr Banda
     	 * @param flag En caso de buffers de memoria este flag a true significa que se reserva la memoria
     	 * para el buffer de forma normal y si est? a false no se reserva por lo que la reserva deber? ser
     	 * posterior.
     	 */
     	public Buffer createMemoryBuffer(int dataType, int width, int height, int bandNr, boolean malloc);
     	/**
     	 * Creates an instance of a memory buffer
+    	 *
     	 * @param params
     	 *        Parameters to instantiate this buffer
     	 */
     	public Buffer createMemoryBuffer(BufferParam params);
     	/**
     	 * Creates a new instance of an interpolation object.
     	 * @param buf IRasterBuffer
     	 * @return IBufferInterpolation
     	 */
     	public BufferInterpolation createInterpolation(Buffer buf);
     	/**
     	 * Builds a new parameter object
     	 * @param  x
     	 *         Upper left X position
     	 * @param  y
     	 *         Upper left X position
     	 * @param  w
     	 *         Width
     	 * @param  h
     	 *         Height
     	 */
     	public BufferParam createBufferParams(int w, int h);
     	/**
     	 * Creates a parameter object for building a buffer. The buffer type is read-write.
     	 * This type could be changed after the creation of a {@link BufferParam} object.
     	 * @param  w
     	 *         Width
     	 * @param  h
     	 *         Height
     	 * @param  bandCount
     	 * 		   Number of bands
     	 * @param  dataType
     	 *         Type of data
     	 */
     	public BufferParam createBufferParams(int w, int h, int bandCount, int dataType);
     	/**
     	 * Creates a parameter object for building a buffer. For this call the buffer type
     	 * is read-only and the source will be a multifile.
     	 * @param files
     	 *        File list in disk
     	 * @param x
     	 *        initial pixel
     	 * @param y
     	 *        initial pixel
     	 * @param w
     	 *        Width in pixels
     	 * @param h
     	 *        Height in pixels
     	 * @param bands
     	 *        bands to render
     	 * @return {@link BufferParam}
     	 * @throws IOException
     	 */
     	public BufferParam createBufferParams(String[] files, int x, int y, int w, int h, int[] bands) throws IOException;
     	/**
     	 * Creates a parameter object for building a buffer. For this call the buffer type
     	 * is read-only.
     	 * @param file
     	 *        File in disk
     	 * @param x
     	 *        initial pixel
     	 * @param y
     	 *        initial pixel
     	 * @param w
     	 *        Width in pixels
     	 * @param h
     	 *        Height in pixels
     	 * @param bands
     	 *        bands to render
     	 * @return {@link BufferParam}
     	 * @throws IOException
     	 */
     	public BufferParam createBufferParams(String file, int x, int y, int w, int h, int[] bands) throws IOException;
     	/**
     	 * Creates a parameter object for building a buffer. For this call the buffer type
     	 * is read-only.
     	 * @param file
     	 *        File in disk
     	 * @param x
     	 *        initial pixel
     	 * @param y
     	 *        initial pixel
     	 * @param w
     	 *        Width in pixels
     	 * @param h
     	 *        Height in pixels
     	 * @param bands
     	 *        bands to render
     	 * @return {@link BufferParam}
     	 * @throws IOException
     	 */
     	public BufferParam createBufferParams(String file, int x, int y, int w, int h) throws IOException;
     	//*****************************************************
     	//NODATA API
     	//*****************************************************
     	/**
     	 * Builds a new NoData object
     	 * @param noData

Application: gvSIG desktop » gvSIG raster

Revision 1437