Revision 11386

View differences:

trunk/libraries/libRaster/src-test/org/gvsig/raster/buffer/cache/AllTestsCache.java
13 13 
		suite.addTestSuite(TestStructCache.class);
14 14 
		suite.addTestSuite(TestWorldCoordHDDPages.class);
15 15 
		suite.addTestSuite(TestAssignInterchangeBandsCache.class);
16 
		suite.addTestSuite(TestRasterReadOnlyHugeBuffer.class);
16 17 
		//suite.addTestSuite(TestReadOnlyCache.class);
17 18 
		//$JUnit-END$
18 19 
		return suite;
trunk/libraries/libRaster/src-test/org/gvsig/raster/buffer/cache/TestRasterReadOnlyHugeBuffer.java
94 94 
	public void testStack(){
95 95 
		for (int iBand = 0; iBand < buf.getBandCount(); iBand++)
96 96 
			for (int iRow = 0; iRow < buf.getHeight(); iRow++)
97 
				for (int iCol = 0; iCol < buf.getWidth(); iCol++)
98 
					assertEquals(buf.getElemByte(iRow, iCol, iBand), bufCache.getElemByte(iRow, iCol, iBand));
97 
				for (int iCol = 0; iCol < buf.getWidth(); iCol++) {
98 
					byte a = buf.getElemByte(iRow, iCol, iBand);
99 
					byte b = bufCache.getElemByte(iRow, iCol, iBand);
100 
					//if(a != b)
101 
						//System.out.println(iRow + " " + iCol + " " + a + " " + b);
102 
					assertEquals(a, b);
103 
				}
99 104 
	}
100 105 

  		




  101
  106
  
    
}


  		












  

    
      trunk/libraries/libRaster/src-test/org/gvsig/raster/AllTests.java
    
  





  30
  30
  
    
import org.gvsig.raster.buffer.TestGdalByteHistogram;


  		




  31
  31
  
    
import org.gvsig.raster.buffer.cache.TestAssignInterchangeBandsCache;


  		




  32
  32
  
    
import org.gvsig.raster.buffer.cache.TestRasterCache;


  		




  
  33
  
    
import org.gvsig.raster.buffer.cache.TestRasterReadOnlyHugeBuffer;


  		




  33
  34
  
    
import org.gvsig.raster.buffer.cache.TestSaveAndLoadPages;


  		




  34
  35
  
    
import org.gvsig.raster.buffer.cache.TestStructCache;


  		




  35
  36
  
    
import org.gvsig.raster.buffer.cache.TestWorldCoordHDDPages;


  		




  ......




  69
  70
  
    
		new TestHistogramSerializer().start();


  		




  70
  71
  
    
		new TestRmfRead().start();


  		




  71
  72
  
    
		new TestRmfWrite().start();


  		




  
  73
  
    
		new TestRasterReadOnlyHugeBuffer().start();


  		




  72
  74
  
    
		//new TestGdalByteMultiBandHistogram().start();


  		




  73
  75
  
    
		//new TestGdalFloatHistogram().start();


  		




  74
  76
  
    
		


  		












  

    
      trunk/libraries/libRaster/doc/Notas.txt
    
  





  23
  23
  
    
Implementar deshacer para filtrado y operaciones raster a nivel de librer?a.


  		




  24
  24
  
    
Imagenes de pruebas de distintos formatos:


  		




  25
  25
  
    
	netCDF, HDF, SRF, 


  		




  26
  
  
    
		


  		




  
  26
  
    
	


  		




  
  27
  
    
Cuadro de configuraci?n:


  		




  
  28
  
    
	Check - Generar estadisticas al cargar un raster (OFF)


  		




  
  29
  
    
	RadioButton - Al cargar imagen != 8 bits aplicar (paleta, filtro de realce)


  		




  
  30
  
    
	TextBox incrementable - N?mero de clases por defecto a aplicar a rasters		


  		




  
  31
  
    
	Combo - N?mero de bloques para procesos de recorrido de rasters


  		




  
  32
  
    
	Cachesize, pagspergroup, pagesize


  		




  
  33
  
    
	Directorio de temporales


  		












  

    
      trunk/libraries/libRaster/src/org/gvsig/raster/RasterLibrary.java
    
  





  34
  34
  
    
	 * Tama?o de bloque en los procesos que recorren un raster completo a base de ventanas con recorrido 


  		




  35
  35
  
    
	 * descendente. Esta variable indica la altura de dicho bloque. Por lo tanto cada bloque ser? de 


  		




  36
  36
  
    
	 * raster.width X blockHeight. Tipicamente recorridos de este tipo se usan para el calculo de estad?sticas, 


  		




  37
  
  
    
	 * histogramas, salvado a raster, etc...


  		




  
  37
  
    
	 * histogramas, salvado a raster, etc... Es importante para el buen funcionamiento que este bloque sea 


  		




  
  38
  
    
	 * potencia de dos.


  		




  38
  39
  
    
	 */


  		




  39
  40
  
    
	public static int blockHeight = 512;


  		




  40
  41
  
    
	


  		












  

    
      trunk/libraries/libRaster/src/org/gvsig/raster/buffer/cache/RasterReadOnlyHugeBuffer.java
    
  





  1
  1
  
    
package org.gvsig.raster.buffer.cache;


  		




  2
  2
  
    

  		




  
  3
  
    
import java.io.File;


  		




  3
  4
  
    
import java.io.FileNotFoundException;


  		




  4
  5
  
    

  		




  
  6
  
    
import org.gvsig.raster.RasterLibrary;


  		




  5
  7
  
    
import org.gvsig.raster.buffer.IBand;


  		




  6
  8
  
    
import org.gvsig.raster.buffer.RasterBuffer;


  		




  
  9
  
    
import org.gvsig.raster.buffer.RasterMemoryBuffer;


  		




  
  10
  
    
import org.gvsig.raster.dataset.Band;


  		




  
  11
  
    
import org.gvsig.raster.dataset.BandFoundInListException;


  		




  
  12
  
    
import org.gvsig.raster.dataset.BandList;


  		




  7
  13
  
    
import org.gvsig.raster.dataset.IBuffer;


  		




  8
  14
  
    
import org.gvsig.raster.dataset.NotSupportedExtensionException;


  		




  
  15
  
    
import org.gvsig.raster.dataset.RasterDataset;


  		




  9
  16
  
    
import org.gvsig.raster.dataset.RasterDriverException;


  		




  
  17
  
    
import org.gvsig.raster.shared.Extent;


  		




  10
  18
  
    

  		




  11
  19
  
    
/**


  		




  12
  20
  
    
 * 


  		




  ......




  14
  22
  
    
 *


  		




  15
  23
  
    
 */


  		




  16
  24
  
    
public class RasterReadOnlyHugeBuffer extends RasterBuffer {


  		




  17
  
  
    
	private Cache 			cache = null;


  		




  18
  
  
    
	private LRUAlgorithm  	lru = null; 


  		




  
  25
  
    
	/**


  		




  
  26
  
    
	 * Nombre de fichero de raster en disco


  		




  
  27
  
    
	 */


  		




  
  28
  
    
	private String fileName = null;


  		




  
  29
  
    
	/**


  		




  
  30
  
    
	 * Pagina cargada


  		




  
  31
  
    
	 */


  		




  
  32
  
    
	private IBuffer page = null;


  		




  
  33
  
    
	/**


  		




  
  34
  
    
	 * N?mero de p?gina cargada en IBuffer


  		




  
  35
  
    
	 */


  		




  
  36
  
    
	private int loadPage = -1;


  		




  
  37
  
    
	/**


  		




  
  38
  
    
	 * Lista de extents de cada p?gina


  		




  
  39
  
    
	 */


  		




  
  40
  
    
	//private Extent[]	extentList = null;


  		




  
  41
  
    
	private int		heightLastPage = 0;


  		




  
  42
  
    
	


  		




  
  43
  
    
	private RasterDataset dataset = null;


  		




  
  44
  
    
	


  		




  
  45
  
    
	private int			bitsPag = 0;


  		




  
  46
  
    
	/**


  		




  
  47
  
    
	 * N?mero de p?ginas


  		




  
  48
  
    
	 */


  		




  
  49
  
    
	private int 		nPages = 0;


  		




  
  50
  
    
	/**


  		




  
  51
  
    
	 * Lista de bandas


  		




  
  52
  
    
	 */


  		




  
  53
  
    
	private BandList bandList = null;


  		




  
  54
  
    
	private int[] drawableBands = null;


  		




  
  55
  
    
	


  		




  
  56
  
    
	/**


  		




  
  57
  
    
	 * Para extraer el desplazamiento de una direcci?n (l?nea de raster) hay que hacer una operaci?n And con 


  		




  
  58
  
    
	 * con la altura de la p?gina -1. Por ejemplo, una p?gina de 16 l?neas de altura el desplazamiento ser?


  		




  
  59
  
    
	 * 16 - 1 = 15 porque 15 en binario es 1111.


  		




  
  60
  
    
	 * 


  		




  
  61
  
    
	 * Si queremos acceder a la linea del raster n?mero 83 (1010011) realizando la operaci?n And con el valor del


  		




  
  62
  
    
	 * desplazamiento obtenemos (0001111 & 1010011 = 0000011), es decir el valor 3 en decimal. Esto quiere decir


  		




  
  63
  
    
	 * que la l?nea 83 del raster es la 3 de su p?gina. 


  		




  
  64
  
    
	 */


  		




  
  65
  
    
	private int offset = 1;


  		




  19
  66
  
    
	 


  		




  20
  67
  
    
    /**


  		




  21
  68
  
    
     * Constructor. Asigna las variables de inicializaci?n y crea la estructura de 


  		




  ......




  31
  78
  
    
     */


  		




  32
  79
  
    
	public RasterReadOnlyHugeBuffer(int dataType, int width, int height, int nBand, String fileName) 


  		




  33
  80
  
    
		throws FileNotFoundException, NotSupportedExtensionException, RasterDriverException {


  		




  34
  
  
    
		cache = new Cache(nBand, dataType, width, height, fileName);


  		




  35
  
  
    
		lru = new LRUAlgorithm(cache);


  		




  
  81
  
    
		this.fileName = fileName;


  		




  36
  82
  
    
		


  		




  
  83
  
    
		File file = new File(fileName);


  		




  
  84
  
    
		if(!file.exists())


  		




  
  85
  
    
			throw new FileNotFoundException("I can't make read only cache structure.");


  		




  
  86
  
    
				


  		




  
  87
  
    
		dataset = RasterDataset.open(null, fileName);


  		




  
  88
  
    
		


  		




  
  89
  
    
		page = new RasterMemoryBuffer(dataType, width, RasterLibrary.blockHeight, dataset.getBandCount(), true);


  		




  
  90
  
    
		


  		




  
  91
  
    
		//Calculo de los bits por p?gina


  		




  
  92
  
    
		int h = RasterLibrary.blockHeight; 


  		




  
  93
  
    
		while(h > 1) {


  		




  
  94
  
    
			h >>= 1;


  		




  
  95
  
    
			bitsPag ++;


  		




  
  96
  
    
		}


  		




  
  97
  
    
		offset = RasterLibrary.blockHeight - 1;


  		




  
  98
  
    
		


  		




  
  99
  
    
		nPages = (int)Math.ceil((double)dataset.getHeight() / (double)RasterLibrary.blockHeight);


  		




  
  100
  
    
		//extentList = calcExtentPages(dataset, nPages);


  		




  
  101
  
    
		double aux = ((double)dataset.getHeight() / (double)RasterLibrary.blockHeight);


  		




  
  102
  
    
		heightLastPage = (int)((aux - (int)aux) * RasterLibrary.blockHeight);


  		




  
  103
  
    
		


  		




  
  104
  
    
		drawableBands = new int[dataset.getBandCount()];


  		




  
  105
  
    
    	for (int i = 0; i < drawableBands.length; i++) 


  		




  
  106
  
    
			drawableBands[i] = i;


  		




  
  107
  
    

  		




  
  108
  
    
    	bandList = new BandList();


  		




  
  109
  
    
		for(int i = 0; i < dataset.getBandCount();i++){


  		




  
  110
  
    
			try{


  		




  
  111
  
    
				Band band = new Band(dataset.getFName(), i, dataset.getDataType());


  		




  
  112
  
    
				band.setPositionToDrawInBuffer(i);


  		




  
  113
  
    
				bandList.addBand(band, i);


  		




  
  114
  
    
			}catch(BandFoundInListException ex){


  		




  
  115
  
    
				//No a?adimos la banda


  		




  
  116
  
    
			}


  		




  
  117
  
    
		}


  		




  
  118
  
    
		


  		




  37
  119
  
    
    	this.dataType = dataType;


  		




  38
  120
  
    
        this.width = width;


  		




  39
  121
  
    
        this.height = height;


  		




  40
  122
  
    
        this.nBands = nBand;


  		




  41
  123
  
    
	}


  		




  42
  124
  
    
			


  		




  
  125
  
    
	/**


  		




  
  126
  
    
	 * Calcula la extensi?n de las p?ginas en coordenadas del mundo real


  		




  
  127
  
    
	 * @param dataset Dataset


  		




  
  128
  
    
	 * @param nPages N?mero de p?ginas en que se divide el raster


  		




  
  129
  
    
	 * @return Extensi?n de cada p?gina


  		




  
  130
  
    
	 */


  		




  
  131
  
    
	private Extent[] calcExtentPages(RasterDataset dataset, int nPages) {


  		




  
  132
  
    
		Extent datasetExtent = dataset.getExtent();


  		




  
  133
  
    
		double h = (RasterLibrary.blockHeight * dataset.getExtent().height()) / dataset.getHeight();


  		




  
  134
  
    
		Extent[] ext = new Extent[nPages];


  		




  
  135
  
    
		


  		




  
  136
  
    
		double minX = datasetExtent.getMin().getX();


  		




  
  137
  
    
		double maxX = datasetExtent.getMax().getX();


  		




  
  138
  
    
		double maxY = datasetExtent.getMax().getY();


  		




  
  139
  
    
		double minY = maxY - h;


  		




  
  140
  
    
		for (int i = 0; i < ext.length; i++) {


  		




  
  141
  
    
			ext[i] = new Extent(minX, maxY, maxX, minY);


  		




  
  142
  
    
			maxY = minY;


  		




  
  143
  
    
			minY -= h;


  		




  
  144
  
    
			if(minY < datasetExtent.minY())


  		




  
  145
  
    
				minY = datasetExtent.minY();


  		




  
  146
  
    
		}


  		




  
  147
  
    
		return ext;


  		




  
  148
  
    
	}


  		




  
  149
  
    
	


  		




  43
  150
  
    
	public void malloc(int dataType, int width, int height, int bandNr) {


  		




  44
  151
  
    
	}


  		




  45
  152
  
    

  		




  ......




  51
  158
  
    
    	return false;


  		




  52
  159
  
    
    }


  		




  53
  160
  
    
    


  		




  54
  
  
    
	/**


  		




  55
  
  
    
	 * Obtiene la cach?


  		




  56
  
  
    
	 * @return


  		




  57
  
  
    
	 */


  		




  58
  
  
    
	public Cache getCache() {


  		




  59
  
  
    
		return cache;


  		




  60
  
  
    
	}


  		




  
  161
  
    
    private void loadPage(int pag) {


  		




  
  162
  
    
    	if(pag == nPages - 1) { 


  		




  
  163
  
    
    		page = new RasterMemoryBuffer(dataType, width, heightLastPage, dataset.getBandCount(), true);


  		




  
  164
  
    
    		dataset.getWindowRaster(0, RasterLibrary.blockHeight * pag, dataset.getWidth(), heightLastPage, bandList, page);


  		




  
  165
  
    
    	} else {


  		




  
  166
  
    
    		page = new RasterMemoryBuffer(dataType, width, RasterLibrary.blockHeight, dataset.getBandCount(), true);


  		




  
  167
  
    
    		dataset.getWindowRaster(0, RasterLibrary.blockHeight * pag, dataset.getWidth(), RasterLibrary.blockHeight, bandList, page);


  		




  
  168
  
    
    	}


  		




  
  169
  
    
    	


  		




  
  170
  
    
    	loadPage = pag;


  		




  
  171
  
    
    }


  		




  
  172
  
    
    


  		




  61
  173
  
    
	//*********************************************************


  		




  62
  174
  
    
	


  		




  63
  175
  
    
	public byte[][] getLineByte(int line) {


  		




  64
  
  
    
		try {


  		




  65
  
  
    
			lru.cacheAccess(line, true);


  		




  66
  
  
    
		} catch (InvalidPageNumberException e) {return null;}


  		




  67
  
  
    
		return cache.getAccessPage().getLineByte((line & cache.getOffset()));


  		




  
  176
  
    
		int pag = line >> bitsPag;


  		




  
  177
  
    
		if(pag != loadPage)


  		




  
  178
  
    
			loadPage(pag);


  		




  
  179
  
    
		return page.getLineByte(line & offset);


  		




  68
  180
  
    
	}


  		




  69
  181
  
    

  		




  70
  182
  
    
	public short[][] getLineShort(int line) {


  		




  71
  
  
    
		try {


  		




  72
  
  
    
			lru.cacheAccess(line, true);


  		




  73
  
  
    
		} catch (InvalidPageNumberException e) {return null;}


  		




  74
  
  
    
		return cache.getAccessPage().getLineShort((line & cache.getOffset()));


  		




  
  183
  
    
		int pag = line >> bitsPag;


  		




  
  184
  
    
		if(pag != loadPage)


  		




  
  185
  
    
			loadPage(pag);


  		




  
  186
  
    
		return page.getLineShort(line & offset);


  		




  75
  187
  
    
	}


  		




  76
  188
  
    

  		




  77
  189
  
    
	public int[][] getLineInt(int line) {


  		




  78
  
  
    
		try {


  		




  79
  
  
    
			lru.cacheAccess(line, true);


  		




  80
  
  
    
		} catch (InvalidPageNumberException e) {return null;}


  		




  81
  
  
    
		return cache.getAccessPage().getLineInt((line & cache.getOffset()));


  		




  
  190
  
    
		int pag = line >> bitsPag;


  		




  
  191
  
    
		if(pag != loadPage)


  		




  
  192
  
    
			loadPage(pag);


  		




  
  193
  
    
		return page.getLineInt(line & offset);


  		




  82
  194
  
    
	}


  		




  83
  195
  
    

  		




  84
  196
  
    
	public float[][] getLineFloat(int line) {


  		




  85
  
  
    
		try {


  		




  86
  
  
    
			lru.cacheAccess(line, true);


  		




  87
  
  
    
		} catch (InvalidPageNumberException e) {return null;}


  		




  88
  
  
    
		return cache.getAccessPage().getLineFloat((line & cache.getOffset()));


  		




  
  197
  
    
		int pag = line >> bitsPag;


  		




  
  198
  
    
		if(pag != loadPage)


  		




  
  199
  
    
			loadPage(pag);


  		




  
  200
  
    
		return page.getLineFloat(line & offset);


  		




  89
  201
  
    
	}


  		




  90
  202
  
    

  		




  91
  203
  
    
	public double[][] getLineDouble(int line) {


  		




  92
  
  
    
		try {


  		




  93
  
  
    
			lru.cacheAccess(line, true);


  		




  94
  
  
    
		} catch (InvalidPageNumberException e) {return null;}


  		




  95
  
  
    
		return cache.getAccessPage().getLineDouble((line & cache.getOffset()));


  		




  
  204
  
    
		int pag = line >> bitsPag;


  		




  
  205
  
    
		if(pag != loadPage)


  		




  
  206
  
    
			loadPage(pag);


  		




  
  207
  
    
		return page.getLineDouble(line & offset);


  		




  96
  208
  
    
	}


  		




  97
  209
  
    

  		




  98
  210
  
    
	//*********************************************************


  		




  99
  211
  
    
	


  		




  100
  
  
    
	public void setLineByte(byte[][] data, int line) {}


  		




  101
  
  
    

  		




  102
  
  
    
	public void setLineShort(short[][] data, int line) {}


  		




  103
  
  
    

  		




  104
  
  
    
	public void setLineInt(int[][] data, int line) {}


  		




  105
  
  
    

  		




  106
  
  
    
	public void setLineFloat(float[][] data, int line) {}


  		




  107
  
  
    

  		




  108
  
  
    
	public void setLineDouble(double[][] data, int line) {}


  		




  109
  
  
    

  		




  110
  
  
    
	//*********************************************************


  		




  111
  
  
    
	


  		




  112
  212
  
    
	public byte[] getLineFromBandByte(int line, int band) {


  		




  113
  
  
    
		try {


  		




  114
  
  
    
			lru.cacheAccess(line, true);


  		




  115
  
  
    
		} catch (InvalidPageNumberException e) {return null;}


  		




  116
  
  
    
		return cache.getAccessPage().getLineFromBandByte((line & cache.getOffset()), band);


  		




  
  213
  
    
		int pag = line >> bitsPag;


  		




  
  214
  
    
		if(pag != loadPage)


  		




  
  215
  
    
			loadPage(pag);


  		




  
  216
  
    
		return page.getLineFromBandByte(line & offset, band);


  		




  117
  217
  
    
	}


  		




  118
  218
  
    

  		




  119
  219
  
    
	public short[] getLineFromBandShort(int line, int band) {


  		




  120
  
  
    
		try {


  		




  121
  
  
    
			lru.cacheAccess(line, true);


  		




  122
  
  
    
		} catch (InvalidPageNumberException e) {return null;}


  		




  123
  
  
    
		return cache.getAccessPage().getLineFromBandShort((line & cache.getOffset()), band);


  		




  
  220
  
    
		int pag = line >> bitsPag;


  		




  
  221
  
    
		if(pag != loadPage)


  		




  
  222
  
    
			loadPage(pag);


  		




  
  223
  
    
		return page.getLineFromBandShort(line & offset, band);


  		




  124
  224
  
    
	}


  		




  125
  225
  
    

  		




  126
  226
  
    
	public int[] getLineFromBandInt(int line, int band) {


  		




  127
  
  
    
		try {


  		




  128
  
  
    
			lru.cacheAccess(line, true);


  		




  129
  
  
    
		} catch (InvalidPageNumberException e) {return null;}


  		




  130
  
  
    
		return cache.getAccessPage().getLineFromBandInt((line & cache.getOffset()), band);


  		




  
  227
  
    
		int pag = line >> bitsPag;


  		




  
  228
  
    
		if(pag != loadPage)


  		




  
  229
  
    
			loadPage(pag);


  		




  
  230
  
    
		return page.getLineFromBandInt(line & offset, band);


  		




  131
  231
  
    
	}


  		




  132
  232
  
    

  		




  133
  233
  
    
	public float[] getLineFromBandFloat(int line, int band) {


  		




  134
  
  
    
		try {


  		




  135
  
  
    
			lru.cacheAccess(line, true);


  		




  136
  
  
    
		} catch (InvalidPageNumberException e) {return null;}


  		




  137
  
  
    
		return cache.getAccessPage().getLineFromBandFloat((line & cache.getOffset()), band);


  		




  
  234
  
    
		int pag = line >> bitsPag;


  		




  
  235
  
    
		if(pag != loadPage)


  		




  
  236
  
    
			loadPage(pag);


  		




  
  237
  
    
		return page.getLineFromBandFloat(line & offset, band);


  		




  138
  238
  
    
	}


  		




  139
  239
  
    

  		




  140
  240
  
    
	public double[] getLineFromBandDouble(int line, int band) {


  		




  141
  
  
    
		try {


  		




  142
  
  
    
			lru.cacheAccess(line, true);


  		




  143
  
  
    
		} catch (InvalidPageNumberException e) {return null;}


  		




  144
  
  
    
		return cache.getAccessPage().getLineFromBandDouble((line & cache.getOffset()), band);


  		




  
  241
  
    
		int pag = line >> bitsPag;


  		




  
  242
  
    
		if(pag != loadPage)


  		




  
  243
  
    
			loadPage(pag);


  		




  
  244
  
    
		return page.getLineFromBandDouble(line & offset, band);


  		




  145
  245
  
    
	}


  		




  146
  246
  
    

  		




  147
  247
  
    
	//*********************************************************


  		




  148
  248
  
    
	


  		




  149
  
  
    
	public void setLineInBandByte(byte[] data, int line, int band) {}


  		




  150
  
  
    

  		




  151
  
  
    
	public void setLineInBandShort(short[] data, int line, int band) {}


  		




  152
  
  
    

  		




  153
  
  
    
	public void setLineInBandInt(int[] data, int line, int band) {}


  		




  154
  
  
    

  		




  155
  
  
    
	public void setLineInBandFloat(float[] data, int line, int band) {}


  		




  156
  
  
    

  		




  157
  
  
    
	public void setLineInBandDouble(double[] data, int line, int band) {}


  		




  158
  
  
    

  		




  159
  
  
    
	//*********************************************************


  		




  160
  
  
    
	


  		




  161
  249
  
    
	public byte getElemByte(int line, int col, int band) {


  		




  162
  
  
    
		try {


  		




  163
  
  
    
			lru.cacheAccess(line, true);


  		




  164
  
  
    
		} catch (InvalidPageNumberException e) {


  		




  165
  
  
    
			return (byte)getNoDataValue(); //No leemos el dato


  		




  166
  
  
    
		}


  		




  167
  
  
    
		return cache.getAccessPage().getElemByte((line & cache.getOffset()), col, band);


  		




  
  250
  
    
		int pag = line >> bitsPag;


  		




  
  251
  
    
		if(pag != loadPage)


  		




  
  252
  
    
			loadPage(pag);


  		




  
  253
  
    
		return page.getElemByte(line & offset, col, band);


  		




  168
  254
  
    
	}


  		




  169
  255
  
    

  		




  170
  256
  
    
	public short getElemShort(int line, int col, int band) {


  		




  171
  
  
    
		try {


  		




  172
  
  
    
			lru.cacheAccess(line, true);


  		




  173
  
  
    
		} catch (InvalidPageNumberException e) {


  		




  174
  
  
    
			return (short)getNoDataValue(); //No leemos el dato


  		




  175
  
  
    
		}


  		




  176
  
  
    
		return cache.getAccessPage().getElemShort((line & cache.getOffset()), col, band);


  		




  
  257
  
    
		int pag = line >> bitsPag;


  		




  
  258
  
    
		if(pag != loadPage)


  		




  
  259
  
    
			loadPage(pag);


  		




  
  260
  
    
		return page.getElemShort(line & offset, col, band);


  		




  177
  261
  
    
	}


  		




  178
  262
  
    

  		




  179
  263
  
    
	public int getElemInt(int line, int col, int band) {


  		




  180
  
  
    
		try {


  		




  181
  
  
    
			lru.cacheAccess(line, true);


  		




  182
  
  
    
		} catch (InvalidPageNumberException e) {


  		




  183
  
  
    
			return (int)getNoDataValue(); //No leemos el dato


  		




  184
  
  
    
		}


  		




  185
  
  
    
		return cache.getAccessPage().getElemInt((line & cache.getOffset()), col, band);


  		




  
  264
  
    
		int pag = line >> bitsPag;


  		




  
  265
  
    
		if(pag != loadPage)


  		




  
  266
  
    
			loadPage(pag);


  		




  
  267
  
    
		return page.getElemInt(line & offset, col, band);


  		




  186
  268
  
    
	}


  		




  187
  269
  
    

  		




  188
  270
  
    
	public float getElemFloat(int line, int col, int band) {


  		




  189
  
  
    
		try {


  		




  190
  
  
    
			lru.cacheAccess(line, true);


  		




  191
  
  
    
		} catch (InvalidPageNumberException e) {


  		




  192
  
  
    
			return (float)getNoDataValue(); //No leemos el dato


  		




  193
  
  
    
		}


  		




  194
  
  
    
		return cache.getAccessPage().getElemFloat((line & cache.getOffset()), col, band);


  		




  
  271
  
    
		int pag = line >> bitsPag;


  		




  
  272
  
    
		if(pag != loadPage)


  		




  
  273
  
    
			loadPage(pag);


  		




  
  274
  
    
		return page.getElemFloat(line & offset, col, band);


  		




  195
  275
  
    
	}


  		




  196
  276
  
    

  		




  197
  277
  
    
	public double getElemDouble(int line, int col, int band) {


  		




  198
  
  
    
		try {


  		




  199
  
  
    
			lru.cacheAccess(line, true);


  		




  200
  
  
    
		} catch (InvalidPageNumberException e) {


  		




  201
  
  
    
			return (double)getNoDataValue(); //No leemos el dato


  		




  202
  
  
    
		}


  		




  203
  
  
    
		return cache.getAccessPage().getElemDouble((line & cache.getOffset()), col, band);


  		




  
  278
  
    
		int pag = line >> bitsPag;


  		




  
  279
  
    
		if(pag != loadPage)


  		




  
  280
  
    
			loadPage(pag);


  		




  
  281
  
    
		return page.getElemDouble(line & offset, col, band);


  		




  204
  282
  
    
	}


  		




  205
  
  
    

  		




  206
  
  
    
	//*********************************************************


  		




  207
  283
  
    
	


  		




  208
  
  
    
	public void setElem(int line, int col, int band, byte data) {}


  		




  209
  
  
    

  		




  210
  
  
    
	public void setElem(int line, int col, int band, short data) {}


  		




  211
  
  
    

  		




  212
  
  
    
	public void setElem(int line, int col, int band, int data) {}


  		




  213
  
  
    

  		




  214
  
  
    
	public void setElem(int line, int col, int band, float data) {}


  		




  215
  
  
    

  		




  216
  
  
    
	public void setElem(int line, int col, int band, double data) {}


  		




  217
  
  
    
	


  		




  218
  284
  
    
	//*********************************************************


  		




  219
  285
  
    

  		




  220
  286
  
    
	public void getElemByte(int line, int col, byte[] data) {


  		




  221
  
  
    
		try {


  		




  222
  
  
    
			lru.cacheAccess(line, true);


  		




  223
  
  
    
		} catch (InvalidPageNumberException e) {


  		




  224
  
  
    
			for (int iBand = 0; iBand < data.length; iBand++)


  		




  225
  
  
    
	            data[iBand] = (byte)getNoDataValue();


  		




  226
  
  
    
		}


  		




  227
  
  
    
		cache.getAccessPage().getElemByte((line & cache.getOffset()), col, data);


  		




  
  287
  
    
		int pag = line >> bitsPag;


  		




  
  288
  
    
		if(pag != loadPage)


  		




  
  289
  
    
			loadPage(pag);


  		




  
  290
  
    
		page.getElemByte(line & offset, col, data);


  		




  228
  291
  
    
	}


  		




  229
  292
  
    

  		




  230
  293
  
    
	public void getElemShort(int line, int col, short[] data) {


  		




  231
  
  
    
		try {


  		




  232
  
  
    
			lru.cacheAccess(line, true);


  		




  233
  
  
    
		} catch (InvalidPageNumberException e) {


  		




  234
  
  
    
			for (int iBand = 0; iBand < data.length; iBand++)


  		




  235
  
  
    
	            data[iBand] = (short)getNoDataValue();


  		




  236
  
  
    
		}


  		




  237
  
  
    
		cache.getAccessPage().getElemShort((line & cache.getOffset()), col, data);


  		




  
  294
  
    
		int pag = line >> bitsPag;


  		




  
  295
  
    
		if(pag != loadPage)


  		




  
  296
  
    
			loadPage(pag);


  		




  
  297
  
    
		page.getElemShort(line & offset, col, data);


  		




  238
  298
  
    
	}


  		




  239
  299
  
    

  		




  240
  300
  
    
	public void getElemInt(int line, int col, int[] data) {


  		




  241
  
  
    
		try {


  		




  242
  
  
    
			lru.cacheAccess(line, true);


  		




  243
  
  
    
		} catch (InvalidPageNumberException e) {


  		




  244
  
  
    
			for (int iBand = 0; iBand < data.length; iBand++)


  		




  245
  
  
    
	            data[iBand] = (int)getNoDataValue();


  		




  246
  
  
    
		}


  		




  247
  
  
    
		cache.getAccessPage().getElemInt((line & cache.getOffset()), col, data);


  		




  
  301
  
    
		int pag = line >> bitsPag;


  		




  
  302
  
    
		if(pag != loadPage)


  		




  
  303
  
    
			loadPage(pag);


  		




  
  304
  
    
		page.getElemInt(line & offset, col, data);


  		




  248
  305
  
    
	}


  		




  249
  306
  
    

  		




  250
  307
  
    
	public void getElemFloat(int line, int col, float[] data) {


  		




  251
  
  
    
		try {


  		




  252
  
  
    
			lru.cacheAccess(line, true);


  		




  253
  
  
    
		} catch (InvalidPageNumberException e) {


  		




  254
  
  
    
			for (int iBand = 0; iBand < data.length; iBand++)


  		




  255
  
  
    
	            data[iBand] = (float)getNoDataValue();


  		




  256
  
  
    
		}


  		




  257
  
  
    
		cache.getAccessPage().getElemFloat((line & cache.getOffset()), col, data);


  		




  
  308
  
    
		int pag = line >> bitsPag;


  		




  
  309
  
    
		if(pag != loadPage)


  		




  
  310
  
    
			loadPage(pag);


  		




  
  311
  
    
		page.getElemFloat(line & offset, col, data);


  		




  258
  312
  
    
	}


  		




  259
  313
  
    

  		




  260
  314
  
    
	public void getElemDouble(int line, int col, double[] data) {


  		




  261
  
  
    
		try {


  		




  262
  
  
    
			lru.cacheAccess(line, true);


  		




  263
  
  
    
		} catch (InvalidPageNumberException e) {


  		




  264
  
  
    
			for (int iBand = 0; iBand < data.length; iBand++)


  		




  265
  
  
    
	            data[iBand] = (double)getNoDataValue();


  		




  266
  
  
    
		}


  		




  267
  
  
    
		cache.getAccessPage().getElemDouble((line & cache.getOffset()), col, data);


  		




  
  315
  
    
		int pag = line >> bitsPag;


  		




  
  316
  
    
		if(pag != loadPage)


  		




  
  317
  
    
			loadPage(pag);


  		




  
  318
  
    
		page.getElemDouble(line & offset, col, data);


  		




  268
  319
  
    
	}


  		




  269
  320
  
    
	


  		




  270
  
  
    
	//*********************************************************


  		




  271
  
  
    
	


  		




  272
  
  
    
	public void setElemByte(int line, int col, byte[] data) {}


  		




  273
  
  
    

  		




  274
  
  
    
	public void setElemShort(int line, int col, short[] data) {}


  		




  275
  
  
    

  		




  276
  
  
    
	public void setElemInt(int line, int col, int[] data) {}


  		




  277
  
  
    

  		




  278
  
  
    
	public void setElemFloat(int line, int col, float[] data) {}


  		




  279
  
  
    

  		




  280
  
  
    
	public void setElemDouble(int line, int col, double[] data) {}


  		




  281
  
  
    

  		




  282
  321
  
    
	//***********************************************


  		




  283
  322
  
    
    //Obtiene una banda entera


  		




  284
  323
  
    
    


  		




  ......




  326
  365
  
    
	public RasterBuffer adjustRasterBSplineInterpolation(int w, int h, int[] bands) {


  		




  327
  366
  
    
		return null;


  		




  328
  367
  
    
	}


  		




  329
  
  
    

  		




  330
  
  
    
	//*********************************************************


  		




  331
  
  
    
	


  		




  332
  
  
    
	public void assign(int band, byte value) {}


  		




  333
  
  
    

  		




  334
  
  
    
	public void assign(int band, short value) {}


  		




  335
  
  
    

  		




  336
  
  
    
	public void assign(int band, int value) {}


  		




  337
  
  
    

  		




  338
  
  
    
	public void assign(int band, float value) {}


  		




  339
  
  
    

  		




  340
  
  
    
	public void assign(int band, double value) {}


  		




  341
  
  
    
	


  		




  342
  368
  
    
    


  		




  343
  369
  
    
    /*


  		




  344
  370
  
    
     *  (non-Javadoc)


  		




  ......




  347
  373
  
    
    public IBuffer cloneBuffer(){


  		




  348
  374
  
    
    	return null;


  		




  349
  375
  
    
    }


  		




  
  376
  
    

  		




  350
  377
  
    
    


  		




  351
  378
  
    
    /*


  		




  352
  
  
    
     * (non-Javadoc)


  		




  353
  
  
    
     * @see org.gvsig.fmap.driver.IBuffer#interchangeBands(int, int)


  		




  354
  
  
    
     */


  		




  355
  
  
    
	public void interchangeBands(int band1, int band2) {


  		




  356
  
  
    
	}


  		




  357
  
  
    
	


  		




  358
  
  
    
    /*


  		




  359
  
  
    
     * (non-Javadoc)


  		




  360
  
  
    
     * @see org.gvsig.fmap.driver.IBuffer#interchangeBands(int[])


  		




  361
  
  
    
     */


  		




  362
  
  
    
    public void interchangeBands(int[] bands){


  		




  363
  
  
    
    	


  		




  364
  
  
    
    }


  		




  365
  
  
    
    


  		




  366
  
  
    
    /*


  		




  367
  379
  
    
     *  (non-Javadoc)


  		




  368
  380
  
    
     * @see org.gvsig.fmap.driver.IBuffer#mallocOneBand(int, int, int, int)


  		




  369
  381
  
    
     */


  		




  ......




  396
  408
  
    
		return null;


  		




  397
  409
  
    
	}


  		




  398
  410
  
    

  		




  399
  
  
    
	/*


  		




  400
  
  
    
	 *  (non-Javadoc)


  		




  401
  
  
    
	 * @see org.gvsig.fmap.driver.IBuffer#assignBandToNotValid(int)


  		




  402
  
  
    
	 */


  		




  403
  
  
    
	public void assignBandToNotValid(int iBand) {


  		




  404
  
  
    
				


  		




  405
  
  
    
	}


  		




  
  411
  
    
	public void assignBandToNotValid(int iBand) {}


  		




  
  412
  
    
	public void assign(int band, byte value) {}


  		




  
  413
  
    
	public void assign(int band, short value) {}


  		




  
  414
  
    
	public void assign(int band, int value) {}


  		




  
  415
  
    
	public void assign(int band, float value) {}


  		




  
  416
  
    
	public void assign(int band, double value) {}


  		




  
  417
  
    
	public void interchangeBands(int band1, int band2) {}


  		




  
  418
  
    
	public void setElem(int line, int col, int band, byte data) {}


  		




  
  419
  
    
	public void setElem(int line, int col, int band, short data) {}


  		




  
  420
  
    
	public void setElem(int line, int col, int band, int data) {}


  		




  
  421
  
    
	public void setElem(int line, int col, int band, float data) {}


  		




  
  422
  
    
	public void setElem(int line, int col, int band, double data) {}


  		




  
  423
  
    
	public void setElemByte(int line, int col, byte[] data) {}


  		




  
  424
  
    
	public void setElemDouble(int line, int col, double[] data) {}


  		




  
  425
  
    
	public void setElemFloat(int line, int col, float[] data) {}


  		




  
  426
  
    
	public void setElemInt(int line, int col, int[] data) {}


  		




  
  427
  
    
	public void setElemShort(int line, int col, short[] data) {}


  		




  
  428
  
    
	public void setLineByte(byte[][] data, int line) {}


  		




  
  429
  
    
	public void setLineDouble(double[][] data, int line) {}


  		




  
  430
  
    
	public void setLineFloat(float[][] data, int line) {}


  		




  
  431
  
    
	public void setLineInBandByte(byte[] data, int line, int band) {}


  		




  
  432
  
    
	public void setLineInBandDouble(double[] data, int line, int band) {}


  		




  
  433
  
    
	public void setLineInBandFloat(float[] data, int line, int band) {}


  		




  
  434
  
    
	public void setLineInBandInt(int[] data, int line, int band) {}


  		




  
  435
  
    
	public void setLineInBandShort(short[] data, int line, int band) {}


  		




  
  436
  
    
	public void setLineInt(int[][] data, int line) {}


  		




  
  437
  
    
	public void setLineShort(short[][] data, int line) {}


  		




  406
  438
  
    

  		




  407
  439
  
    
}


  		












Also available in:  Unified diff