Revision 6385
| org.gvsig.raster/branches/org.gvsig.raster.2.4/org.gvsig.raster/org.gvsig.raster.lib/org.gvsig.raster.lib.buffer/org.gvsig.raster.lib.buffer.impl/src/main/java/org/gvsig/raster/lib/buffer/impl/AbstractTiledBand.java | ||
|---|---|---|
| 91 | 91 |
if(firstColumnOfTile + columnsPerTile > this.columns){
|
| 92 | 92 |
columnsInTile = this.columns - firstColumnOfTile; |
| 93 | 93 |
} |
| 94 |
this.tileManager.load(data, |
|
| 95 |
firstRowOfTile, rowsInTile, |
|
| 96 |
firstColumnOfTile, columnsInTile, |
|
| 94 |
Band loadedBand = this.tileManager.load(firstRowOfTile, |
|
| 95 |
firstColumnOfTile, |
|
| 97 | 96 |
this.getDataType()); |
| 97 |
|
|
| 98 |
|
|
| 99 |
Object rowBuffer = loadedBand.createRowBuffer(); |
|
| 100 |
for(int loadedRow=0; loadedRow<loadedBand.getRows(); loadedRow++){
|
|
| 101 |
loadedBand.fetchRow(loadedRow, rowBuffer); |
|
| 102 |
int pos = loadedRow*loadedBand.getColumns(); |
|
| 103 |
System.arraycopy(rowBuffer, 0, data.array(), pos, loadedBand.getColumns()); |
|
| 104 |
} |
|
| 98 | 105 |
loaded=true; |
| 99 | 106 |
} catch (IOException e) {
|
| 100 | 107 |
throw new RuntimeException("Can't save current tile", e);
|
| org.gvsig.raster/branches/org.gvsig.raster.2.4/org.gvsig.raster/org.gvsig.raster.lib/org.gvsig.raster.lib.buffer/org.gvsig.raster.lib.buffer.impl/src/main/java/org/gvsig/raster/lib/buffer/impl/SimpleBandTileManager.java | ||
|---|---|---|
| 10 | 10 |
import java.nio.IntBuffer; |
| 11 | 11 |
import java.nio.ShortBuffer; |
| 12 | 12 |
|
| 13 |
import org.gvsig.raster.lib.buffer.api.Band; |
|
| 13 | 14 |
import org.gvsig.raster.lib.buffer.api.BandInfo; |
| 14 | 15 |
import org.gvsig.raster.lib.buffer.api.BandTileManager; |
| 15 | 16 |
import org.gvsig.raster.lib.buffer.api.BufferLocator; |
| ... | ... | |
| 52 | 53 |
this.columnsPerTile=256; |
| 53 | 54 |
} |
| 54 | 55 |
|
| 55 |
public void load(Buffer buffer, int row, int rows, int col, int cols, int dataType) throws IOException {
|
|
| 56 |
//TODO review (un)used params |
|
| 57 |
int pos = row*this.columns+col; |
|
| 58 |
raf.seek(pos); |
|
| 59 |
BufferManager bufferManager = BufferLocator.getBufferManager(); |
|
| 60 |
int dataTypeSize = bufferManager.getDataTypeSize(dataType); |
|
| 61 |
byte[] byteArray = new byte[buffer.capacity() * dataTypeSize]; |
|
| 62 |
raf.read(byteArray); |
|
| 63 |
buffer.rewind(); |
|
| 56 |
public Band load(int row, int col, int dataType) throws IOException {
|
|
| 57 |
//FIXME: Comentarizado para que me deje compilar (no s? si es necesaria esta clase |
|
| 64 | 58 |
|
| 65 |
switch (dataType) {
|
|
| 66 |
case BufferManager.TYPE_BYTE: |
|
| 67 |
//FIXME: Elegir cual de las dos siguientes maneras de hacerlo es la id?nea |
|
| 59 |
// //TODO review (un)used params |
|
| 60 |
// int pos = row*this.columns+col; |
|
| 61 |
// raf.seek(pos); |
|
| 62 |
// BufferManager bufferManager = BufferLocator.getBufferManager(); |
|
| 63 |
// int dataTypeSize = bufferManager.getDataTypeSize(dataType); |
|
| 64 |
// byte[] byteArray = new byte[buffer.capacity() * dataTypeSize]; |
|
| 65 |
// raf.read(byteArray); |
|
| 66 |
// buffer.rewind(); |
|
| 67 |
// |
|
| 68 |
// switch (dataType) {
|
|
| 69 |
// case BufferManager.TYPE_BYTE: |
|
| 70 |
// //FIXME: Elegir cual de las dos siguientes maneras de hacerlo es la id?nea |
|
| 71 |
// |
|
| 72 |
// ((ByteBuffer) buffer).put(byteArray, 0, byteArray.length); |
|
| 73 |
//// System.arraycopy(byteArray, 0, ((ByteBuffer) buffer).array(), 0, byteArray.length); |
|
| 74 |
// break; |
|
| 75 |
// case BufferManager.TYPE_SHORT: |
|
| 76 |
// case BufferManager.TYPE_USHORT: |
|
| 77 |
// for( int cell =0 ; cell<byteArray.length ; cell++ ) {
|
|
| 78 |
// ((ShortBuffer) buffer).put((int)(cell/dataTypeSize), byteArray[cell]); |
|
| 79 |
// } |
|
| 80 |
// break; |
|
| 81 |
// case BufferManager.TYPE_INT: |
|
| 82 |
// for( int cell =0 ; cell<byteArray.length ; cell++ ) {
|
|
| 83 |
// ((IntBuffer) buffer).put((int)(cell/dataTypeSize), byteArray[cell]); |
|
| 84 |
// } |
|
| 85 |
// break; |
|
| 86 |
// case BufferManager.TYPE_FLOAT: |
|
| 87 |
// for( int cell =0 ; cell<byteArray.length ; cell++ ) {
|
|
| 88 |
// ((FloatBuffer) buffer).put((int)(cell/dataTypeSize), byteArray[cell]); |
|
| 89 |
// } |
|
| 90 |
// break; |
|
| 91 |
// |
|
| 92 |
// case BufferManager.TYPE_DOUBLE: |
|
| 93 |
// for( int cell =0 ; cell<byteArray.length ; cell++ ) {
|
|
| 94 |
// ((DoubleBuffer) buffer).put((int)(cell/dataTypeSize), byteArray[cell]); |
|
| 95 |
// } |
|
| 96 |
// break; |
|
| 97 |
// |
|
| 98 |
// default: |
|
| 99 |
// throw new IllegalArgumentException("Data Type " + dataType + " not supported.");
|
|
| 100 |
// } |
|
| 101 |
return null; |
|
| 68 | 102 |
|
| 69 |
((ByteBuffer) buffer).put(byteArray, 0, byteArray.length); |
|
| 70 |
// System.arraycopy(byteArray, 0, ((ByteBuffer) buffer).array(), 0, byteArray.length); |
|
| 71 |
break; |
|
| 72 |
case BufferManager.TYPE_SHORT: |
|
| 73 |
case BufferManager.TYPE_USHORT: |
|
| 74 |
for( int cell =0 ; cell<byteArray.length ; cell++ ) {
|
|
| 75 |
((ShortBuffer) buffer).put((int)(cell/dataTypeSize), byteArray[cell]); |
|
| 76 |
} |
|
| 77 |
break; |
|
| 78 |
case BufferManager.TYPE_INT: |
|
| 79 |
for( int cell =0 ; cell<byteArray.length ; cell++ ) {
|
|
| 80 |
((IntBuffer) buffer).put((int)(cell/dataTypeSize), byteArray[cell]); |
|
| 81 |
} |
|
| 82 |
break; |
|
| 83 |
case BufferManager.TYPE_FLOAT: |
|
| 84 |
for( int cell =0 ; cell<byteArray.length ; cell++ ) {
|
|
| 85 |
((FloatBuffer) buffer).put((int)(cell/dataTypeSize), byteArray[cell]); |
|
| 86 |
} |
|
| 87 |
break; |
|
| 88 |
|
|
| 89 |
case BufferManager.TYPE_DOUBLE: |
|
| 90 |
for( int cell =0 ; cell<byteArray.length ; cell++ ) {
|
|
| 91 |
((DoubleBuffer) buffer).put((int)(cell/dataTypeSize), byteArray[cell]); |
|
| 92 |
} |
|
| 93 |
break; |
|
| 94 |
|
|
| 95 |
default: |
|
| 96 |
throw new IllegalArgumentException("Data Type " + dataType + " not supported.");
|
|
| 97 |
} |
|
| 98 |
|
|
| 99 | 103 |
} |
| 100 | 104 |
|
| 101 | 105 |
public void save(Buffer buffer, int row, int rows, int col, int cols, int dataType) throws IOException {
|
| org.gvsig.raster/branches/org.gvsig.raster.2.4/org.gvsig.raster/org.gvsig.raster.lib/org.gvsig.raster.lib.buffer/org.gvsig.raster.lib.buffer.impl/src/main/java/org/gvsig/raster/lib/buffer/impl/DefaultBufferManager.java | ||
|---|---|---|
| 7 | 7 |
import java.util.Map.Entry; |
| 8 | 8 |
|
| 9 | 9 |
import org.cresques.cts.IProjection; |
| 10 |
|
|
| 10 | 11 |
import org.gvsig.fmap.geom.primitive.Envelope; |
| 11 | 12 |
import org.gvsig.raster.lib.buffer.api.Band; |
| 12 | 13 |
import org.gvsig.raster.lib.buffer.api.BandInfo; |
| ... | ... | |
| 16 | 17 |
import org.gvsig.raster.lib.buffer.api.BufferManager; |
| 17 | 18 |
import org.gvsig.raster.lib.buffer.api.NoData; |
| 18 | 19 |
import org.gvsig.raster.lib.buffer.api.PageManager; |
| 20 |
import org.gvsig.raster.lib.buffer.api.exceptions.BandException; |
|
| 19 | 21 |
import org.gvsig.raster.lib.buffer.api.exceptions.BufferException; |
| 20 | 22 |
import org.gvsig.raster.lib.buffer.impl.exceptions.CreateBandTypeException; |
| 21 | 23 |
import org.gvsig.raster.lib.buffer.impl.exceptions.CreateBufferException; |
| ... | ... | |
| 187 | 189 |
List<Entry<Object, Object>> values) {
|
| 188 | 190 |
return new DefaultBandInfo(band, name, description, dataType, values); |
| 189 | 191 |
} |
| 192 |
|
|
| 193 |
@Override |
|
| 194 |
public Buffer createBuffer(Buffer buffer, boolean paginated) throws BufferException {
|
|
| 195 |
List<PageManager> pageManagers = null; |
|
| 196 |
try {
|
|
| 197 |
if (paginated) {
|
|
| 198 |
pageManagers = new ArrayList<PageManager>(); |
|
| 199 |
File file; |
|
| 200 |
file = File.createTempFile("gvsig-raster-temp-file", "tmp");
|
|
| 201 |
for (int i = 0; i < buffer.getBandCount(); i++) {
|
|
| 202 |
PageManager pageManager = |
|
| 203 |
createSimpleBandPageManager(file, buffer.getRows(), buffer.getColumns(), |
|
| 204 |
buffer.getBandTypes()[i]); |
|
| 205 |
pageManagers.add(pageManager); |
|
| 206 |
} |
|
| 207 |
} |
|
| 208 |
Buffer newBuffer = |
|
| 209 |
createBuffer(buffer.getRows(), buffer.getColumns(), buffer.getBandTypes(), buffer.getBandNoData(), |
|
| 210 |
buffer.getProjection(), buffer.getEnvelope(), pageManagers); |
|
| 211 |
for (int i = 0; i < newBuffer.getBandCount(); i++) {
|
|
| 212 |
newBuffer.getBand(i).copyFrom(buffer.getBand(i)); |
|
| 213 |
} |
|
| 214 |
return newBuffer; |
|
| 215 |
} catch (IOException | BandException e) {
|
|
| 216 |
throw new CreateBufferException(e); |
|
| 217 |
} |
|
| 218 |
} |
|
| 190 | 219 |
} |
| org.gvsig.raster/branches/org.gvsig.raster.2.4/org.gvsig.raster/org.gvsig.raster.lib/org.gvsig.raster.lib.buffer/org.gvsig.raster.lib.buffer.impl/src/main/java/org/gvsig/raster/lib/buffer/impl/MemoryBandByte.java | ||
|---|---|---|
| 72 | 72 |
|
| 73 | 73 |
@Override |
| 74 | 74 |
protected void doCopyFrom(Band source) throws CopyFromBandException {
|
| 75 |
if (this.getColumns() != source.getColumns() || this.getRows() != source.getRows() |
|
| 76 |
|| !(source instanceof MemoryBandByte)) {
|
|
| 75 |
if (this.getColumns() == source.getColumns() && this.getRows() == source.getRows()){
|
|
| 76 |
if(source instanceof MemoryBandByte) {
|
|
| 77 |
System.arraycopy(((MemoryBandByte) source).getData(), 0, this.data, 0, this.getRows() |
|
| 78 |
* this.getColumns()); |
|
| 79 |
} else {
|
|
| 80 |
Object rowBuffer = source.createRowBuffer(); |
|
| 81 |
for(int row=0; row<source.getRows(); row++){
|
|
| 82 |
source.fetchRow(row, rowBuffer);; |
|
| 83 |
System.arraycopy(rowBuffer, 0, this.data, row*this.getColumns(), this.getColumns()); |
|
| 84 |
} |
|
| 85 |
} |
|
| 86 |
} else {
|
|
| 77 | 87 |
throw new CopyFromBandException(source, this); |
| 78 | 88 |
} |
| 79 |
System.arraycopy(((MemoryBandByte) source).getData(), 0, this.data, 0, this.getRows() |
|
| 80 |
* this.getColumns()); |
|
| 81 | 89 |
} |
| 82 | 90 |
|
| 83 | 91 |
@Override |
| org.gvsig.raster/branches/org.gvsig.raster.2.4/org.gvsig.raster/org.gvsig.raster.lib/org.gvsig.raster.lib.buffer/org.gvsig.raster.lib.buffer.api/src/main/java/org/gvsig/raster/lib/buffer/api/BandTileManager.java | ||
|---|---|---|
| 5 | 5 |
|
| 6 | 6 |
public interface BandTileManager extends PageManager{
|
| 7 | 7 |
|
| 8 |
public void load(Buffer buffer, int row, int rows, int col, int cols, int dataType) throws IOException;
|
|
| 8 |
public Band load(int row, int col, int dataType) throws IOException;
|
|
| 9 | 9 |
|
| 10 | 10 |
public void save(Buffer buffer, int row, int rows, int col, int cols, int dataType) throws IOException; |
| 11 | 11 |
|
| org.gvsig.raster/branches/org.gvsig.raster.2.4/org.gvsig.raster/org.gvsig.raster.lib/org.gvsig.raster.lib.buffer/org.gvsig.raster.lib.buffer.api/src/main/java/org/gvsig/raster/lib/buffer/api/BufferManager.java | ||
|---|---|---|
| 59 | 59 |
|
| 60 | 60 |
/** |
| 61 | 61 |
* Creates {@link BandInfo} with information about one band.
|
| 62 |
*
|
|
| 62 |
* |
|
| 63 | 63 |
* @param band |
| 64 | 64 |
* Band of this {@link BandInfo}
|
| 65 | 65 |
* @param name |
| ... | ... | |
| 209 | 209 |
throws BufferException; |
| 210 | 210 |
|
| 211 | 211 |
/** |
| 212 |
* Creates a buffer from another buffer. |
|
| 213 |
* If paginated parameter is false the buffer bands will be in memory. |
|
| 214 |
* If paginated parameter is true the buffer bands will be paginated using a simple band page manager. |
|
| 215 |
* |
|
| 216 |
* @param buffer |
|
| 217 |
* @param paginated |
|
| 218 |
* @return Buffer |
|
| 219 |
* @throws BufferException |
|
| 220 |
*/ |
|
| 221 |
public Buffer createBuffer(Buffer buffer, boolean paginated) throws BufferException; |
|
| 222 |
|
|
| 223 |
/** |
|
| 212 | 224 |
* Creates a clipping of a buffer. The returned clipping will be like a view |
| 213 | 225 |
* of the original buffer. It not reserve additional memory. It will only be |
| 214 | 226 |
* a walkway to access an area of the buffer. |
| org.gvsig.raster/branches/org.gvsig.raster.2.4/org.gvsig.raster/org.gvsig.raster.gdal/org.gvsig.raster.gdal.provider/src/main/java/org/gvsig/raster/gdal/provider/RasterGdalBandTileManager.java | ||
|---|---|---|
| 52 | 52 |
} |
| 53 | 53 |
|
| 54 | 54 |
@Override |
| 55 |
public void load(Buffer buffer, int row, int rows, int col, int cols, int dataType) throws IOException {
|
|
| 55 |
public org.gvsig.raster.lib.buffer.api.Band load(int row, int col, int dataType) throws IOException {
|
|
| 56 |
//FIXME: |
|
| 57 |
// Comentarizado para que me deje compilar. |
|
| 58 |
// Esta clase no va a ser necesaria porque gdal se va a a paginar a franjas en lugar de a tiles. |
|
| 56 | 59 |
|
| 57 |
int xOffset = col; |
|
| 58 |
int xSize = cols; |
|
| 59 |
int yOffset = row; |
|
| 60 |
int ySize = rows; |
|
| 61 |
buffer.rewind(); |
|
| 60 |
// int xOffset = col; |
|
| 61 |
// int xSize = cols; |
|
| 62 |
// int yOffset = row; |
|
| 63 |
// int ySize = rows; |
|
| 64 |
// buffer.rewind(); |
|
| 65 |
// |
|
| 66 |
// switch (dataType) {
|
|
| 67 |
// case BufferManager.TYPE_INT: |
|
| 68 |
// gdalBand.ReadRaster(xOffset, yOffset, xSize, ySize, ((IntBuffer) buffer).array()); |
|
| 69 |
// break; |
|
| 70 |
// case BufferManager.TYPE_BYTE: |
|
| 71 |
// gdalBand.ReadRaster(xOffset, yOffset, xSize, ySize, ((ByteBuffer) buffer).array()); |
|
| 72 |
// break; |
|
| 73 |
// case BufferManager.TYPE_DOUBLE: |
|
| 74 |
// gdalBand.ReadRaster(xOffset, yOffset, xSize, ySize, ((DoubleBuffer) buffer).array()); |
|
| 75 |
// break; |
|
| 76 |
// case BufferManager.TYPE_FLOAT: |
|
| 77 |
// gdalBand.ReadRaster(xOffset, yOffset, xSize, ySize, ((FloatBuffer) buffer).array()); |
|
| 78 |
// break; |
|
| 79 |
// case BufferManager.TYPE_SHORT: |
|
| 80 |
// case BufferManager.TYPE_USHORT: |
|
| 81 |
// gdalBand.ReadRaster(xOffset, yOffset, xSize, ySize, ((ShortBuffer) buffer).array()); |
|
| 82 |
// break; |
|
| 83 |
// } |
|
| 62 | 84 |
|
| 63 |
switch (dataType) {
|
|
| 64 |
case BufferManager.TYPE_INT: |
|
| 65 |
gdalBand.ReadRaster(xOffset, yOffset, xSize, ySize, ((IntBuffer) buffer).array()); |
|
| 66 |
break; |
|
| 67 |
case BufferManager.TYPE_BYTE: |
|
| 68 |
gdalBand.ReadRaster(xOffset, yOffset, xSize, ySize, ((ByteBuffer) buffer).array()); |
|
| 69 |
break; |
|
| 70 |
case BufferManager.TYPE_DOUBLE: |
|
| 71 |
gdalBand.ReadRaster(xOffset, yOffset, xSize, ySize, ((DoubleBuffer) buffer).array()); |
|
| 72 |
break; |
|
| 73 |
case BufferManager.TYPE_FLOAT: |
|
| 74 |
gdalBand.ReadRaster(xOffset, yOffset, xSize, ySize, ((FloatBuffer) buffer).array()); |
|
| 75 |
break; |
|
| 76 |
case BufferManager.TYPE_SHORT: |
|
| 77 |
case BufferManager.TYPE_USHORT: |
|
| 78 |
gdalBand.ReadRaster(xOffset, yOffset, xSize, ySize, ((ShortBuffer) buffer).array()); |
|
| 79 |
break; |
|
| 80 |
} |
|
| 85 |
return null; |
|
| 81 | 86 |
} |
| 82 | 87 |
|
| 83 | 88 |
@Override |
| org.gvsig.raster/branches/org.gvsig.raster.2.4/org.gvsig.raster/org.gvsig.raster.tilecache/org.gvsig.raster.tilecache.provider.legend/src/main/java/org/gvsig/raster/tilecache/provider/legend/TileCacheGetColorInterpretation.java | ||
|---|---|---|
| 1 | 1 |
package org.gvsig.raster.tilecache.provider.legend; |
| 2 | 2 |
|
| 3 |
import org.gvsig.fmap.dal.exception.InitializeException; |
|
| 4 |
import org.gvsig.fmap.dal.exception.ProviderNotRegisteredException; |
|
| 5 |
import org.gvsig.fmap.dal.exception.ValidateDataParametersException; |
|
| 3 | 6 |
import org.gvsig.fmap.dal.raster.api.RasterStore; |
| 4 | 7 |
import org.gvsig.raster.lib.buffer.api.Band; |
| 5 | 8 |
import org.gvsig.raster.lib.legend.api.ColorInterpretation; |
| ... | ... | |
| 14 | 17 |
import org.gvsig.tools.dynobject.DynObject; |
| 15 | 18 |
import org.gvsig.tools.dynobject.exception.DynMethodException; |
| 16 | 19 |
import org.gvsig.tools.dynobject.exception.DynMethodNotSupportedException; |
| 20 |
|
|
| 17 | 21 |
import org.slf4j.LoggerFactory; |
| 18 | 22 |
|
| 19 | 23 |
/** |
| ... | ... | |
| 60 | 64 |
|
| 61 | 65 |
RasterLegendManager legendManager = |
| 62 | 66 |
RasterLegendLocator.getRasterLegendManager(); |
| 67 |
|
|
| 68 |
// colorInterpretation = |
|
| 69 |
// legendManager.createColorInterpretation(ColorInterpretation.ARGB); |
|
| 70 |
|
|
| 63 | 71 |
TileStructImage tileStructImage = tileCacheStoreProvider.getTileStructImage(); |
| 64 |
RasterStore tileStore=tileStructImage.getTileStore(); |
|
| 72 |
|
|
| 73 |
RasterStore tileStore = null; |
|
| 65 | 74 |
try {
|
| 75 |
tileStore = tileStructImage.getDelegatedRasterStore(); |
|
| 66 | 76 |
colorInterpretation = (ColorInterpretation) tileStore |
| 67 | 77 |
.invokeDynMethod(RasterStore.DYNMETHOD_GETCOLORINTERPRETATION_NAME, null); |
| 68 | 78 |
} catch (DynMethodNotSupportedException e) {
|
| 69 |
logger.debug("This store {} does not provide a legend.",
|
|
| 79 |
logger.debug("This store {} does not provide a color interpretation.",
|
|
| 70 | 80 |
tileStore.getName()); |
| 71 | 81 |
} catch (DynMethodException e) {
|
| 72 | 82 |
logger.error( |
| 73 |
"Can't load the specific legend provided for the store {}.",
|
|
| 83 |
"Can't load the specific color interpretation provided for the store {}.",
|
|
| 74 | 84 |
tileStore.getName(), e); |
| 85 |
} catch (ValidateDataParametersException | InitializeException | ProviderNotRegisteredException e) {
|
|
| 86 |
logger.error( |
|
| 87 |
"Can't get delegated store {}.",
|
|
| 88 |
tileStructImage.getProviderName(), e); |
|
| 89 |
} finally {
|
|
| 90 |
if(tileStore!=null){
|
|
| 91 |
tileStore.dispose(); |
|
| 92 |
} |
|
| 75 | 93 |
} |
| 76 | 94 |
|
| 95 |
|
|
| 77 | 96 |
return colorInterpretation; |
| 78 | 97 |
} |
| 79 | 98 |
|
| org.gvsig.raster/branches/org.gvsig.raster.2.4/org.gvsig.raster/org.gvsig.raster.tilecache/org.gvsig.raster.tilecache.provider.legend/src/main/java/org/gvsig/raster/tilecache/provider/legend/TileCacheGetColorTable.java | ||
|---|---|---|
| 1 | 1 |
package org.gvsig.raster.tilecache.provider.legend; |
| 2 | 2 |
|
| 3 |
import org.gvsig.fmap.dal.exception.InitializeException; |
|
| 4 |
import org.gvsig.fmap.dal.exception.ProviderNotRegisteredException; |
|
| 5 |
import org.gvsig.fmap.dal.exception.ValidateDataParametersException; |
|
| 3 | 6 |
import org.gvsig.fmap.dal.raster.api.RasterStore; |
| 7 |
import org.gvsig.raster.lib.legend.api.ColorInterpretation; |
|
| 4 | 8 |
import org.gvsig.raster.lib.legend.api.ColorTable; |
| 5 | 9 |
import org.gvsig.raster.lib.legend.api.RasterLegendLocator; |
| 6 | 10 |
import org.gvsig.raster.lib.legend.api.RasterLegendManager; |
| ... | ... | |
| 12 | 16 |
import org.gvsig.tools.dynobject.DynObject; |
| 13 | 17 |
import org.gvsig.tools.dynobject.exception.DynMethodException; |
| 14 | 18 |
import org.gvsig.tools.dynobject.exception.DynMethodNotSupportedException; |
| 19 |
|
|
| 15 | 20 |
import org.slf4j.LoggerFactory; |
| 16 | 21 |
|
| 17 | 22 |
/** |
| ... | ... | |
| 60 | 65 |
RasterLegendManager legendManager = |
| 61 | 66 |
RasterLegendLocator.getRasterLegendManager(); |
| 62 | 67 |
TileStructImage tileStructImage = tileCacheStoreProvider.getTileStructImage(); |
| 63 |
RasterStore tileStore=tileStructImage.getTileStore(); |
|
| 68 |
|
|
| 69 |
RasterStore tileStore = null; |
|
| 64 | 70 |
try {
|
| 71 |
tileStore = tileStructImage.getDelegatedRasterStore(); |
|
| 65 | 72 |
colorTable = (ColorTable) tileStore |
| 66 | 73 |
.invokeDynMethod(RasterStore.DYNMETHOD_GETCOLORTABLE_NAME, null); |
| 67 | 74 |
} catch (DynMethodNotSupportedException e) {
|
| ... | ... | |
| 71 | 78 |
logger.error( |
| 72 | 79 |
"Can't load the specific color table provided for the store {}.",
|
| 73 | 80 |
tileStore.getName(), e); |
| 81 |
} catch (ValidateDataParametersException | InitializeException | ProviderNotRegisteredException e) {
|
|
| 82 |
logger.error( |
|
| 83 |
"Can't get delegated store {}.",
|
|
| 84 |
tileStructImage.getProviderName(), e); |
|
| 85 |
} finally {
|
|
| 86 |
if(tileStore!=null){
|
|
| 87 |
tileStore.dispose(); |
|
| 88 |
} |
|
| 74 | 89 |
} |
| 75 | 90 |
|
| 76 | 91 |
return colorTable; |
| org.gvsig.raster/branches/org.gvsig.raster.2.4/org.gvsig.raster/org.gvsig.raster.tilecache/org.gvsig.raster.tilecache.provider.legend/src/main/java/org/gvsig/raster/tilecache/provider/legend/TileCacheGetLegend.java | ||
|---|---|---|
| 1 | 1 |
package org.gvsig.raster.tilecache.provider.legend; |
| 2 | 2 |
|
| 3 |
import org.slf4j.LoggerFactory; |
|
| 4 |
|
|
| 5 |
import org.gvsig.fmap.dal.exception.InitializeException; |
|
| 6 |
import org.gvsig.fmap.dal.exception.ProviderNotRegisteredException; |
|
| 7 |
import org.gvsig.fmap.dal.exception.ValidateDataParametersException; |
|
| 3 | 8 |
import org.gvsig.fmap.dal.raster.api.RasterStore; |
| 4 | 9 |
import org.gvsig.raster.lib.legend.api.RasterLegend; |
| 5 | 10 |
import org.gvsig.raster.lib.legend.api.RasterLegendLocator; |
| ... | ... | |
| 12 | 17 |
import org.gvsig.tools.dynobject.DynObject; |
| 13 | 18 |
import org.gvsig.tools.dynobject.exception.DynMethodException; |
| 14 | 19 |
import org.gvsig.tools.dynobject.exception.DynMethodNotSupportedException; |
| 15 |
import org.slf4j.LoggerFactory; |
|
| 16 | 20 |
|
| 17 | 21 |
/** |
| 18 | 22 |
* Dynamic method to add a get Legend funcionality |
| ... | ... | |
| 60 | 64 |
|
| 61 | 65 |
RasterLegendManager legendManager = |
| 62 | 66 |
RasterLegendLocator.getRasterLegendManager(); |
| 67 |
|
|
| 68 |
|
|
| 69 |
// TileCacheStoreProvider provider=(TileCacheStoreProvider)self; |
|
| 70 |
// |
|
| 71 |
// ColorInterpretation colorInterpretation =(ColorInterpretation)provider. |
|
| 72 |
// invokeDynMethod(RasterStore.DYNMETHOD_GETCOLORINTERPRETATION_NAME, null); |
|
| 73 |
// |
|
| 74 |
// legend= legendManager.createLegend(colorInterpretation); |
|
| 75 |
// if ( !( colorInterpretation.isBGR() || colorInterpretation.isRGB() || colorInterpretation.isRGBA() ) ){
|
|
| 76 |
// ColorTable colorTable=(ColorTable)provider. |
|
| 77 |
// invokeDynMethod(RasterStore.DYNMETHOD_GETCOLORTABLE_NAME, null); |
|
| 78 |
// legend.setColorTable(colorTable); |
|
| 79 |
// } |
|
| 80 |
|
|
| 63 | 81 |
TileStructImage tileStructImage = tileCacheStoreProvider.getTileStructImage(); |
| 64 |
RasterStore tileStore=tileStructImage.getTileStore();
|
|
| 82 |
RasterStore tileStore = null;
|
|
| 65 | 83 |
try {
|
| 84 |
tileStore = tileStructImage.getDelegatedRasterStore(); |
|
| 66 | 85 |
legend = (RasterLegend) tileStore |
| 67 | 86 |
.invokeDynMethod(RasterStore.DYNMETHOD_GETLEGEND_NAME, null); |
| 68 | 87 |
} catch (DynMethodNotSupportedException e) {
|
| 69 |
logger.debug("This store {} does not provide a color table.",
|
|
| 88 |
logger.debug("This store {} does not provide a legend.",
|
|
| 70 | 89 |
tileStore.getName()); |
| 71 | 90 |
} catch (DynMethodException e) {
|
| 72 | 91 |
logger.error( |
| 73 |
"Can't load the specific color table provided for the store {}.",
|
|
| 92 |
"Can't load the specific legend provided for the store {}.",
|
|
| 74 | 93 |
tileStore.getName(), e); |
| 94 |
} catch (ValidateDataParametersException | InitializeException | ProviderNotRegisteredException e) {
|
|
| 95 |
logger.error( |
|
| 96 |
"Can't get delegated store {}.",
|
|
| 97 |
tileStructImage.getProviderName(), e); |
|
| 98 |
} finally {
|
|
| 99 |
if(tileStore!=null){
|
|
| 100 |
tileStore.dispose(); |
|
| 101 |
} |
|
| 75 | 102 |
} |
| 76 | 103 |
|
| 77 | 104 |
return legend; |
| org.gvsig.raster/branches/org.gvsig.raster.2.4/org.gvsig.raster/org.gvsig.raster.tilecache/org.gvsig.raster.tilecache.provider/pom.xml | ||
|---|---|---|
| 19 | 19 |
<artifactId>org.gvsig.tools.lib</artifactId> |
| 20 | 20 |
</dependency> |
| 21 | 21 |
|
| 22 |
</dependencies> |
|
| 22 |
<dependency> |
|
| 23 |
<groupId>org.gvsig</groupId> |
|
| 24 |
<artifactId>org.gvsig.fmap.dal.raster.api</artifactId> |
|
| 25 |
</dependency> |
|
| 26 |
|
|
| 27 |
<dependency> |
|
| 28 |
<groupId>com.sun</groupId> |
|
| 29 |
<artifactId>jimi</artifactId> |
|
| 30 |
</dependency> |
|
| 31 |
</dependencies> |
|
| 23 | 32 |
</project> |
| org.gvsig.raster/branches/org.gvsig.raster.2.4/org.gvsig.raster/org.gvsig.raster.tilecache/org.gvsig.raster.tilecache.provider/src/main/java/org/gvsig/raster/tilecache/provider/TileStructImage.java | ||
|---|---|---|
| 23 | 23 |
package org.gvsig.raster.tilecache.provider; |
| 24 | 24 |
|
| 25 | 25 |
import java.io.File; |
| 26 |
import java.nio.Buffer; |
|
| 27 |
import java.util.ArrayList; |
|
| 28 |
import java.util.Collections; |
|
| 29 |
import java.util.HashSet; |
|
| 26 |
import java.util.HashMap; |
|
| 30 | 27 |
import java.util.Iterator; |
| 31 |
import java.util.List; |
|
| 32 |
import java.util.Set; |
|
| 28 |
import java.util.Map; |
|
| 33 | 29 |
import java.util.SortedMap; |
| 34 | 30 |
import java.util.TreeMap; |
| 35 | 31 |
|
| 36 | 32 |
import javax.xml.parsers.DocumentBuilder; |
| 37 | 33 |
import javax.xml.parsers.DocumentBuilderFactory; |
| 38 | 34 |
|
| 39 |
import org.apache.commons.io.FileUtils; |
|
| 40 | 35 |
import org.apache.commons.io.FilenameUtils; |
| 41 | 36 |
import org.cresques.cts.IProjection; |
| 37 |
import org.slf4j.Logger; |
|
| 38 |
import org.slf4j.LoggerFactory; |
|
| 39 |
import org.w3c.dom.Document; |
|
| 40 |
import org.w3c.dom.Element; |
|
| 41 |
import org.w3c.dom.NamedNodeMap; |
|
| 42 |
import org.w3c.dom.Node; |
|
| 43 |
import org.w3c.dom.NodeList; |
|
| 42 | 44 |
|
| 43 | 45 |
import org.gvsig.fmap.dal.DALFileLocator; |
| 44 | 46 |
import org.gvsig.fmap.dal.DataStoreProviderFactory; |
| 45 | 47 |
import org.gvsig.fmap.dal.exception.DataException; |
| 48 |
import org.gvsig.fmap.dal.exception.InitializeException; |
|
| 49 |
import org.gvsig.fmap.dal.exception.ProviderNotRegisteredException; |
|
| 46 | 50 |
import org.gvsig.fmap.dal.exception.ValidateDataParametersException; |
| 47 | 51 |
import org.gvsig.fmap.dal.raster.api.RasterStore; |
| 48 | 52 |
import org.gvsig.fmap.dal.serverexplorer.filesystem.spi.FilesystemServerExplorerManager; |
| ... | ... | |
| 53 | 57 |
import org.gvsig.fmap.geom.Geometry.SUBTYPES; |
| 54 | 58 |
import org.gvsig.fmap.geom.GeometryLocator; |
| 55 | 59 |
import org.gvsig.fmap.geom.GeometryManager; |
| 56 |
import org.gvsig.fmap.geom.exception.CreateEnvelopeException; |
|
| 57 | 60 |
import org.gvsig.fmap.geom.primitive.Envelope; |
| 58 | 61 |
import org.gvsig.raster.lib.buffer.api.Band; |
| 62 |
import org.gvsig.raster.lib.buffer.api.Buffer; |
|
| 63 |
import org.gvsig.raster.lib.buffer.api.BufferLocator; |
|
| 64 |
import org.gvsig.raster.lib.buffer.api.BufferManager; |
|
| 65 |
import org.gvsig.raster.lib.buffer.api.exceptions.BufferException; |
|
| 59 | 66 |
import org.gvsig.tools.dynobject.DynObject; |
| 60 | 67 |
import org.gvsig.tools.extensionpoint.ExtensionPoint.Extension; |
| 68 |
import org.gvsig.tools.task.SimpleTaskStatus; |
|
| 61 | 69 |
|
| 62 |
import org.slf4j.Logger; |
|
| 63 |
import org.slf4j.LoggerFactory; |
|
| 64 |
import org.w3c.dom.Document; |
|
| 65 |
import org.w3c.dom.Element; |
|
| 66 |
import org.w3c.dom.NamedNodeMap; |
|
| 67 |
import org.w3c.dom.Node; |
|
| 68 |
import org.w3c.dom.NodeList; |
|
| 69 |
|
|
| 70 | 70 |
/** |
| 71 | 71 |
* Represents a tiled image |
| 72 | 72 |
* @author dmartinezizquierdo |
| 73 | 73 |
* |
| 74 | 74 |
*/ |
| 75 |
public class TileStructImage{
|
|
| 75 |
public class TileStructImage {
|
|
| 76 | 76 |
|
| 77 | 77 |
private static final Logger logger = LoggerFactory.getLogger(TileStructImage.class); |
| 78 |
private static final int MAX_RECENT_ACCEDED_TILES_NUMBER = 200; |
|
| 78 | 79 |
|
| 79 | 80 |
private int rowsPerTile; |
| 80 | 81 |
private int columnsPerTile; |
| ... | ... | |
| 82 | 83 |
private String providerName; |
| 83 | 84 |
private String extension; |
| 84 | 85 |
private SortedMap<Integer,Double> pixelSizePerZoomLevel; |
| 85 |
private SortedMap<Integer,List<Integer>> rowsInZoomLevel; |
|
| 86 |
private SortedMap<Integer,List<Integer>> columnsInZoomLevel; |
|
| 87 | 86 |
private SortedMap<Integer,Envelope> envelopePerZoomLevel; |
| 88 | 87 |
private File tilesFolder; |
| 88 |
private Map<String, Tile> recentAccededTiles; |
|
| 89 | 89 |
|
| 90 |
private int bandNumber;
|
|
| 90 |
private Integer bandNumber=null;
|
|
| 91 | 91 |
|
| 92 | 92 |
private int[] dataTypes; |
| 93 | 93 |
|
| 94 |
private RasterStore tileStore; |
|
| 95 | 94 |
private IProjection crs; |
| 95 |
private SimpleTaskStatus taskStatus; |
|
| 96 |
private Envelope structExtent; |
|
| 97 |
//Este envelope sirve para calcular el nombre de las fila y columna del tile en la estructura de cach? |
|
| 96 | 98 |
|
| 97 | 99 |
/** |
| 98 | 100 |
* @param folder |
| 99 | 101 |
* @param crs |
| 100 | 102 |
*/ |
| 101 | 103 |
public TileStructImage(File folder, IProjection crs){
|
| 104 |
// builder = new StringBuilder(); |
|
| 105 |
// builder.append("*********************");
|
|
| 102 | 106 |
|
| 107 |
GeometryManager geoManager=GeometryLocator.getGeometryManager(); |
|
| 108 |
|
|
| 103 | 109 |
this.crs=crs; |
| 104 | 110 |
|
| 105 |
rowsInZoomLevel=new TreeMap<Integer,List<Integer>>(); |
|
| 106 |
columnsInZoomLevel=new TreeMap<Integer,List<Integer>>(); |
|
| 107 | 111 |
envelopePerZoomLevel=new TreeMap<Integer,Envelope>(); |
| 108 | 112 |
pixelSizePerZoomLevel=new TreeMap<Integer,Double>(); |
| 113 |
recentAccededTiles = new HashMap<String, Tile>(); |
|
| 109 | 114 |
|
| 115 |
|
|
| 110 | 116 |
//FIXME |
| 111 | 117 |
File tilePropertiesFile=new File(folder, "tileCacheStruct.xml"); |
| 112 | 118 |
tilesFolder=new File (folder,"V"+File.separatorChar+"Z"+File.separatorChar+"T"); |
| ... | ... | |
| 134 | 140 |
NodeList elementsByTagName = eElement.getElementsByTagName("format");
|
| 135 | 141 |
providerName=elementsByTagName.item(0).getTextContent(); |
| 136 | 142 |
|
| 143 |
NodeList structExtentList = eElement.getElementsByTagName("structExtent");
|
|
| 144 |
if(structExtentList.getLength()>0){
|
|
| 145 |
Element structExtentNode=(Element) structExtentList.item(0); |
|
| 146 |
if(structExtentNode!=null){
|
|
| 147 |
Double minX = Double.valueOf(structExtentNode.getElementsByTagName("minX").item(0).getTextContent());
|
|
| 148 |
Double minY = Double.valueOf(structExtentNode.getElementsByTagName("minY").item(0).getTextContent());
|
|
| 149 |
Double maxX = Double.valueOf(structExtentNode.getElementsByTagName("maxX").item(0).getTextContent());
|
|
| 150 |
Double maxY = Double.valueOf(structExtentNode.getElementsByTagName("maxY").item(0).getTextContent());
|
|
| 151 |
structExtent = geoManager.createEnvelope( |
|
| 152 |
minX, |
|
| 153 |
minY, |
|
| 154 |
maxX, |
|
| 155 |
maxY, |
|
| 156 |
SUBTYPES.GEOM2D); |
|
| 157 |
} |
|
| 158 |
} |
|
| 159 |
|
|
| 137 | 160 |
FilesystemServerExplorerManager explorerManager = DALFileLocator.getFilesystemServerExplorerManager(); |
| 138 | 161 |
@SuppressWarnings("unchecked")
|
| 139 | 162 |
Iterator<Extension> it = explorerManager.getRegisteredProviders(); |
| ... | ... | |
| 157 | 180 |
NodeList levelList=levels.getElementsByTagName("level");
|
| 158 | 181 |
for (int i = 0; i < levelList.getLength(); i++) {
|
| 159 | 182 |
Element level = (Element)levelList.item(i); |
| 160 |
int zoomLevel=Integer.valueOf(level.getElementsByTagName("index").item(0).getTextContent());
|
|
| 161 |
double pixelSize=Double.valueOf(level.getElementsByTagName("pixelSize").item(0).getTextContent());
|
|
| 183 |
|
|
| 184 |
NamedNodeMap levelAttributes = level.getAttributes(); |
|
| 185 |
int zoomLevel=Integer.valueOf(levelAttributes.getNamedItem("index").getNodeValue());
|
|
| 186 |
double pixelSize=Double.valueOf(levelAttributes.getNamedItem("pixelSize").getNodeValue());
|
|
| 187 |
|
|
| 162 | 188 |
pixelSizePerZoomLevel.put(zoomLevel, pixelSize); |
| 163 |
readFolderTileStructure(zoomLevel); |
|
| 189 |
|
|
| 190 |
NodeList extentList = level.getElementsByTagName("extent");
|
|
| 191 |
if(extentList.getLength()>0){
|
|
| 192 |
Element extentNode=(Element) extentList.item(0); |
|
| 193 |
if(extentNode!=null){
|
|
| 194 |
Double minX = Double.valueOf(extentNode.getElementsByTagName("minX").item(0).getTextContent());
|
|
| 195 |
Double minY = Double.valueOf(extentNode.getElementsByTagName("minY").item(0).getTextContent());
|
|
| 196 |
Double maxX = Double.valueOf(extentNode.getElementsByTagName("maxX").item(0).getTextContent());
|
|
| 197 |
Double maxY = Double.valueOf(extentNode.getElementsByTagName("maxY").item(0).getTextContent());
|
|
| 198 |
Envelope extent = geoManager.createEnvelope( |
|
| 199 |
minX, |
|
| 200 |
minY, |
|
| 201 |
maxX, |
|
| 202 |
maxY, |
|
| 203 |
SUBTYPES.GEOM2D); |
|
| 204 |
envelopePerZoomLevel.put(zoomLevel, extent); |
|
| 205 |
} |
|
| 206 |
} |
|
| 164 | 207 |
} |
| 165 | 208 |
|
| 166 | 209 |
} |
| 167 | 210 |
} |
| 168 | 211 |
|
| 212 |
// this.extension="tif"; |
|
| 213 |
|
|
| 169 | 214 |
} catch (Exception e) {
|
| 170 | 215 |
throw new RuntimeException(); |
| 171 | 216 |
} |
| 217 |
// System.out.println(builder.toString()); |
|
| 218 |
// builder.append("*********************");
|
|
| 172 | 219 |
|
| 220 |
|
|
| 173 | 221 |
} |
| 174 | 222 |
|
| 175 |
/** |
|
| 176 |
* @param zoomLevel |
|
| 177 |
*/ |
|
| 178 |
private void readFolderTileStructure(int zoomLevel){
|
|
| 179 |
File zoomFolder=new File(tilesFolder,String.valueOf(zoomLevel)); |
|
| 180 |
String[] columnsNames = zoomFolder.list(); |
|
| 181 |
Set<Integer> columns = new HashSet<Integer>(); |
|
| 182 |
for (int i = 0; i < columnsNames.length; i++) {
|
|
| 183 |
columns.add(Integer.valueOf(FilenameUtils.getBaseName(columnsNames[i]))); |
|
| 184 |
} |
|
| 185 |
ArrayList<Integer> columnsList = new ArrayList<Integer>(); |
|
| 186 |
columnsList.addAll(columns); |
|
| 187 |
Collections.sort(columnsList); |
|
| 188 |
this.columnsInZoomLevel.put(zoomLevel, columnsList); |
|
| 223 |
// /** |
|
| 224 |
// * @param zoomLevel |
|
| 225 |
// */ |
|
| 226 |
// private void readFolderTileStructure(int zoomLevel){
|
|
| 227 |
// File zoomFolder=new File(tilesFolder,String.valueOf(zoomLevel)); |
|
| 228 |
// String[] columnsNames = zoomFolder.list(); |
|
| 229 |
// Set<Integer> columns = new HashSet<Integer>(); |
|
| 230 |
// for (int i = 0; i < columnsNames.length; i++) {
|
|
| 231 |
// columns.add(Integer.valueOf(FilenameUtils.getBaseName(columnsNames[i]))); |
|
| 232 |
// } |
|
| 233 |
// ArrayList<Integer> columnsList = new ArrayList<Integer>(); |
|
| 234 |
// columnsList.addAll(columns); |
|
| 235 |
// Collections.sort(columnsList); |
|
| 236 |
// this.columnsInZoomLevel.put(zoomLevel, columnsList); |
|
| 237 |
// |
|
| 238 |
// int maxRows=0; |
|
| 239 |
// Integer firstColumn=columnsList.get(0); |
|
| 240 |
// Integer firstRow=null; |
|
| 241 |
// for (String columnName:columnsNames){
|
|
| 242 |
// File columnFolder=new File(zoomFolder,columnName); |
|
| 243 |
// String[] filenames = columnFolder.list(); |
|
| 244 |
// Set<Integer> rows = new HashSet<Integer>(); |
|
| 245 |
// for (int i = 0; i < filenames.length; i++) {
|
|
| 246 |
// rows.add(Integer.valueOf(FilenameUtils.getBaseName(filenames[i]))); |
|
| 247 |
// } |
|
| 248 |
// if (rows.size()>maxRows){
|
|
| 249 |
// maxRows=rows.size(); |
|
| 250 |
// } |
|
| 251 |
// if (firstRow==null){
|
|
| 252 |
// ArrayList<Integer> rowsList = new ArrayList<Integer>(); |
|
| 253 |
// rowsList.addAll(rows); |
|
| 254 |
// Collections.sort(rowsList); |
|
| 255 |
// this.rowsInZoomLevel.put(zoomLevel, rowsList); |
|
| 256 |
// firstRow=rowsList.get(0); |
|
| 257 |
// } |
|
| 258 |
// } |
|
| 259 |
// |
|
| 260 |
// //Leemos el primer tile para obtener el upperLeftPoint |
|
| 261 |
// File firstRowFile=null; |
|
| 262 |
// File firstColumnFolder=new File(zoomFolder,String.valueOf(firstColumn)); |
|
| 263 |
// String rowBaseName = String.valueOf(firstRow); |
|
| 264 |
// File[] providerAcceptedFiles = firstColumnFolder.listFiles(factory); |
|
| 265 |
// for (int i = 0; i < providerAcceptedFiles.length; i++) {
|
|
| 266 |
// File providerAcceptedFile = providerAcceptedFiles[i]; |
|
| 267 |
// if(FilenameUtils.getBaseName(providerAcceptedFile.getAbsolutePath()).equalsIgnoreCase(rowBaseName)){
|
|
| 268 |
// firstRowFile = providerAcceptedFile; |
|
| 269 |
// } |
|
| 270 |
// } |
|
| 271 |
// if ( firstRowFile!=null ){
|
|
| 272 |
// DataManagerProviderServices manager = DALSPILocator.getDataManagerProviderServices(); |
|
| 273 |
// DataStoreProviderFactory providerFactory = manager.getStoreProviderFactory(providerName); |
|
| 274 |
// DynObject params = providerFactory.createParameters(); |
|
| 275 |
// if (params.getDynClass().getDynField("file")!=null){
|
|
| 276 |
// params.setDynValue("file", firstRowFile);
|
|
| 277 |
// } |
|
| 278 |
// if (params.getDynClass().getDynField("crs")!=null){
|
|
| 279 |
// params.setDynValue("crs", this.crs);
|
|
| 280 |
// } |
|
| 281 |
// try {
|
|
| 282 |
// if(this.tileStore!=null){
|
|
| 283 |
// this.tileStore.dispose(); |
|
| 284 |
// } |
|
| 285 |
// this.tileStore = (RasterStore) manager.openStore(providerName,params); |
|
| 286 |
// this.bandNumber=this.tileStore.getBands(); |
|
| 287 |
// this.dataTypes=new int[this.bandNumber]; |
|
| 288 |
// for (int i=0;i<this.bandNumber;i++){
|
|
| 289 |
// dataTypes[i]=this.tileStore.getBandInfo(i).getDataType(); |
|
| 290 |
// } |
|
| 291 |
// Envelope firstTileEnvelope=this.tileStore.getEnvelope(); |
|
| 292 |
// GeometryManager geoManager=GeometryLocator.getGeometryManager(); |
|
| 293 |
// double minX = firstTileEnvelope.getMinimum(DIMENSIONS.X); |
|
| 294 |
// double maxY = firstTileEnvelope.getMaximum(DIMENSIONS.Y); |
|
| 295 |
// Envelope levelEnvelope=geoManager.createEnvelope( |
|
| 296 |
// minX, |
|
| 297 |
// maxY - ( getRows(zoomLevel)*pixelSizePerZoomLevel.get(zoomLevel) ), |
|
| 298 |
// minX + ( getColumns(zoomLevel)*pixelSizePerZoomLevel.get(zoomLevel) ), |
|
| 299 |
// maxY, |
|
| 300 |
// SUBTYPES.GEOM2D); |
|
| 301 |
//// builder.append("<level>\n");
|
|
| 302 |
//// builder.append("<index>");
|
|
| 303 |
//// builder.append(zoomLevel); |
|
| 304 |
//// builder.append("</index>\n");
|
|
| 305 |
//// builder.append("<pixelSize>");
|
|
| 306 |
//// builder.append(pixelSizePerZoomLevel.get(zoomLevel)); |
|
| 307 |
//// builder.append("</pixelSize>\n");
|
|
| 308 |
//// builder.append("<extent>\n");
|
|
| 309 |
//// builder.append("<minX>");
|
|
| 310 |
//// builder.append(minX); |
|
| 311 |
//// builder.append("</minX>\n");
|
|
| 312 |
//// builder.append("<minY>");
|
|
| 313 |
//// builder.append(maxY - ( getRows(zoomLevel)*pixelSizePerZoomLevel.get(zoomLevel) )); |
|
| 314 |
//// builder.append("</minY>\n");
|
|
| 315 |
//// builder.append("<maxX>");
|
|
| 316 |
//// builder.append(minX + ( getColumns(zoomLevel)*pixelSizePerZoomLevel.get(zoomLevel) )); |
|
| 317 |
//// builder.append("</maxX>\n");
|
|
| 318 |
//// builder.append("<maxY>");
|
|
| 319 |
//// builder.append(maxY); |
|
| 320 |
//// builder.append("</maxY>\n");
|
|
| 321 |
//// builder.append("</extent>\n");
|
|
| 322 |
//// builder.append("</level>\n");
|
|
| 323 |
// |
|
| 324 |
// envelopePerZoomLevel.put(zoomLevel, levelEnvelope); |
|
| 325 |
// |
|
| 326 |
// |
|
| 327 |
// } catch (ValidateDataParametersException | |
|
| 328 |
// CreateEnvelopeException | DataException e) {
|
|
| 329 |
// logger.info("Can't read tile", e);
|
|
| 330 |
// // TODO exception |
|
| 331 |
// |
|
| 332 |
// } |
|
| 333 |
// this.extension = FilenameUtils.getExtension(firstRowFile.getAbsolutePath()); |
|
| 334 |
// }else{
|
|
| 335 |
// logger.info("Can't read tile structure");
|
|
| 336 |
// |
|
| 337 |
// } |
|
| 338 |
// } |
|
| 189 | 339 |
|
| 190 |
int maxRows=0; |
|
| 191 |
Integer firstColumn=columnsList.get(0); |
|
| 192 |
Integer firstRow=null; |
|
| 193 |
for (String columnName:columnsNames){
|
|
| 194 |
File columnFolder=new File(zoomFolder,columnName); |
|
| 195 |
String[] filenames = columnFolder.list(); |
|
| 196 |
Set<Integer> rows = new HashSet<Integer>(); |
|
| 197 |
for (int i = 0; i < filenames.length; i++) {
|
|
| 198 |
rows.add(Integer.valueOf(FilenameUtils.getBaseName(filenames[i]))); |
|
| 199 |
} |
|
| 200 |
if (rows.size()>maxRows){
|
|
| 201 |
maxRows=rows.size(); |
|
| 202 |
} |
|
| 203 |
if (firstRow==null){
|
|
| 204 |
ArrayList<Integer> rowsList = new ArrayList<Integer>(); |
|
| 205 |
rowsList.addAll(rows); |
|
| 206 |
Collections.sort(rowsList); |
|
| 207 |
this.rowsInZoomLevel.put(zoomLevel, rowsList); |
|
| 208 |
firstRow=rowsList.get(0); |
|
| 209 |
} |
|
| 210 |
} |
|
| 211 |
|
|
| 212 |
//Leemos el primer tile para obtener el upperLeftPoint |
|
| 213 |
File firstRowFile=null; |
|
| 214 |
File firstColumnFolder=new File(zoomFolder,String.valueOf(firstColumn)); |
|
| 215 |
String rowBaseName = String.valueOf(firstRow); |
|
| 216 |
File[] providerAcceptedFiles = firstColumnFolder.listFiles(factory); |
|
| 217 |
for (int i = 0; i < providerAcceptedFiles.length; i++) {
|
|
| 218 |
File providerAcceptedFile = providerAcceptedFiles[i]; |
|
| 219 |
if(FilenameUtils.getBaseName(providerAcceptedFile.getAbsolutePath()).equalsIgnoreCase(rowBaseName)){
|
|
| 220 |
firstRowFile = providerAcceptedFile; |
|
| 221 |
} |
|
| 222 |
} |
|
| 223 |
if ( firstRowFile!=null ){
|
|
| 224 |
DataManagerProviderServices manager = DALSPILocator.getDataManagerProviderServices(); |
|
| 225 |
DataStoreProviderFactory providerFactory = manager.getStoreProviderFactory(providerName); |
|
| 226 |
DynObject params = providerFactory.createParameters(); |
|
| 227 |
if (params.getDynClass().getDynField("file")!=null){
|
|
| 228 |
params.setDynValue("file", firstRowFile);
|
|
| 229 |
} |
|
| 230 |
if (params.getDynClass().getDynField("crs")!=null){
|
|
| 231 |
params.setDynValue("crs", this.crs);
|
|
| 232 |
} |
|
| 233 |
try {
|
|
| 234 |
this.tileStore = (RasterStore) manager.openStore(providerName,params); |
|
| 235 |
this.bandNumber=this.tileStore.getBands(); |
|
| 236 |
this.dataTypes=new int[this.bandNumber]; |
|
| 237 |
for (int i=0;i<this.bandNumber;i++){
|
|
| 238 |
dataTypes[i]=this.tileStore.getBandInfo(i).getDataType(); |
|
| 239 |
} |
|
| 240 |
Envelope firstTileEnvelope=this.tileStore.getEnvelope(); |
|
| 241 |
GeometryManager geoManager=GeometryLocator.getGeometryManager(); |
|
| 242 |
double minX = firstTileEnvelope.getMinimum(DIMENSIONS.X); |
|
| 243 |
double maxY = firstTileEnvelope.getMaximum(DIMENSIONS.Y); |
|
| 244 |
Envelope levelEnvelope=geoManager.createEnvelope( |
|
| 245 |
minX, |
|
| 246 |
maxY - ( getRows(zoomLevel)*pixelSizePerZoomLevel.get(zoomLevel) ), |
|
| 247 |
minX + ( getColumns(zoomLevel)*pixelSizePerZoomLevel.get(zoomLevel) ), |
|
| 248 |
maxY, |
|
| 249 |
SUBTYPES.GEOM2D); |
|
| 250 |
|
|
| 251 |
envelopePerZoomLevel.put(zoomLevel, levelEnvelope); |
|
| 252 |
|
|
| 253 |
|
|
| 254 |
} catch (ValidateDataParametersException | |
|
| 255 |
CreateEnvelopeException | DataException e) {
|
|
| 256 |
logger.info("Can't read tile", e);
|
|
| 257 |
// TODO exception |
|
| 258 |
|
|
| 259 |
} |
|
| 260 |
this.extension = FilenameUtils.getExtension(firstRowFile.getAbsolutePath()); |
|
| 261 |
}else{
|
|
| 262 |
logger.info("Can't read tile structure");
|
|
| 263 |
|
|
| 264 |
} |
|
| 265 |
} |
|
| 266 |
|
|
| 267 | 340 |
/** |
| 268 | 341 |
* @param pixelSize |
| 269 | 342 |
* @return The appropiate zoom level for the pizelSize |
| ... | ... | |
| 280 | 353 |
return zoom; |
| 281 | 354 |
} |
| 282 | 355 |
|
| 356 |
private int[] calculateStructRowCol(int zoomLevel, int tileRow, int tileCol){
|
|
| 357 |
//index 0 structRow, index 1 structCol |
|
| 358 |
int[] structRowCol = new int[2]; |
|
| 359 |
|
|
| 360 |
if(envelopePerZoomLevel.isEmpty()){
|
|
| 361 |
structRowCol[0] = tileRow; |
|
| 362 |
structRowCol[1] = tileCol; |
|
| 363 |
} else {
|
|
| 364 |
Envelope envelopeInZoomLevel = envelopePerZoomLevel.get(zoomLevel); |
|
| 365 |
structRowCol[0] = (int)(-(envelopeInZoomLevel.getMaximum(DIMENSIONS.Y)-structExtent.getMaximum(DIMENSIONS.Y))/(pixelSizePerZoomLevel.get(zoomLevel)*rowsPerTile))+tileRow; |
|
| 366 |
structRowCol[1] = (int)((envelopeInZoomLevel.getMinimum(DIMENSIONS.X)-structExtent.getMinimum(DIMENSIONS.X))/(pixelSizePerZoomLevel.get(zoomLevel)*columnsPerTile))+tileCol; |
|
| 367 |
} |
|
| 368 |
|
|
| 369 |
return structRowCol; |
|
| 370 |
|
|
| 371 |
} |
|
| 372 |
|
|
| 283 | 373 |
/** |
| 284 | 374 |
* @param buffer |
| 285 | 375 |
* @param band |
| 286 | 376 |
* @param zoomLevel |
| 287 | 377 |
* @param tileRow |
| 288 | 378 |
* @param tileCol |
| 379 |
* @return Band |
|
| 289 | 380 |
*/ |
| 290 |
public void fetchTile(Buffer buffer, int band, int zoomLevel, int tileRow, int tileCol){
|
|
| 381 |
public Band fetchTile(int band, int zoomLevel, int tileRow, int tileCol) {
|
|
| 291 | 382 |
|
| 292 |
Integer structCol = columnsInZoomLevel.get(zoomLevel).get(tileCol); |
|
| 293 |
Integer structRow = rowsInZoomLevel.get(zoomLevel).get(tileRow); |
|
| 383 |
BufferManager bufferManager = BufferLocator.getBufferManager(); |
|
| 384 |
int[] structRowCol = calculateStructRowCol(zoomLevel, tileRow, tileCol); |
|
| 385 |
int structRow = structRowCol[0]; |
|
| 386 |
int structCol = structRowCol[1]; |
|
| 294 | 387 |
|
| 295 |
File tileFile=null; |
|
| 388 |
String keyTile = composeKeyForRecentTiles(zoomLevel, structRow, structCol); |
|
| 389 |
Tile tile = recentAccededTiles.get(keyTile); |
|
| 296 | 390 |
|
| 297 |
File zoomFolder=new File(tilesFolder,String.valueOf(zoomLevel)); |
|
| 298 |
File firstColumnFolder=new File(zoomFolder,String.valueOf(structCol)); |
|
| 299 |
String rowBaseName = String.valueOf(structRow); |
|
| 300 |
tileFile = new File(firstColumnFolder.getAbsolutePath()+File.separatorChar+rowBaseName+"."+this.extension); |
|
| 391 |
if (tile != null) {
|
|
| 392 |
// Devolver la banda del buffer del tile |
|
| 393 |
return tile.getBuffer().getBand(band); |
|
| 394 |
} else {
|
|
| 395 |
// Cargar un tile nuevo |
|
| 396 |
Buffer rasterSet = null; |
|
| 397 |
File tileFile = null; |
|
| 398 |
RasterStore tileStore = null; |
|
| 399 |
try {
|
|
| 400 |
tileStore = createTileStore(zoomLevel, structRow, structCol); |
|
| 401 |
rasterSet = bufferManager.createBuffer(tileStore.getRasterSet(),false); |
|
| 301 | 402 |
|
| 302 |
if ( tileFile!=null ){
|
|
| 303 |
try {
|
|
| 304 |
File fileParam = (File) tileStore.getParameters().getDynValue("file");
|
|
| 305 |
if (tileStore == null || (tileStore != null && (fileParam.compareTo(tileFile)!=0))) {
|
|
| 306 |
DataManagerProviderServices manager = DALSPILocator.getDataManagerProviderServices(); |
|
| 307 |
DataStoreProviderFactory providerFactory = manager.getStoreProviderFactory(providerName); |
|
| 308 |
DynObject params = providerFactory.createParameters(); |
|
| 309 |
if (params.getDynClass().getDynField("file") != null) {
|
|
| 310 |
params.setDynValue("file", tileFile);
|
|
| 403 |
if (recentAccededTiles.size() > MAX_RECENT_ACCEDED_TILES_NUMBER) {
|
|
| 404 |
removeOlderTile(); |
|
| 405 |
} |
|
| 406 |
recentAccededTiles.put(keyTile, new Tile(rasterSet, keyTile)); |
|
| 407 |
|
|
| 408 |
return rasterSet.getBand(band); |
|
| 409 |
} catch (DataException | ValidateDataParametersException | BufferException e) {
|
|
| 410 |
logger.warn("Can't fetch tile: zoomLevel = " + zoomLevel + ", tileRow = " + tileRow + ", tileColumn = "
|
|
| 411 |
+ tileCol + ", band = " + band + ".", e); |
|
| 412 |
return null; |
|
| 413 |
} finally {
|
|
| 414 |
if (tileStore != null) {
|
|
| 415 |
tileStore.dispose(); |
|
| 416 |
} |
|
| 417 |
} |
|
| 418 |
} |
|
| 419 |
} |
|
| 420 |
|
|
| 421 |
private RasterStore createTileStore(int zoomLevel, int structRow, int structCol) throws ValidateDataParametersException, InitializeException, ProviderNotRegisteredException{
|
|
| 422 |
|
|
| 423 |
File tileFile = null; |
|
| 424 |
File zoomFolder = new File(tilesFolder, String.valueOf(zoomLevel)); |
|
| 425 |
if (zoomFolder.exists()) {
|
|
| 426 |
File firstColumnFolder = new File(zoomFolder, String.valueOf(structCol)); |
|
| 427 |
if (firstColumnFolder.exists()) {
|
|
| 428 |
String rowBaseName = String.valueOf(structRow); |
|
| 429 |
|
|
| 430 |
if (this.extension == null) {
|
|
| 431 |
File[] providerAcceptedFiles = firstColumnFolder.listFiles(factory); |
|
| 432 |
for (int i = 0; i < providerAcceptedFiles.length; i++) {
|
|
| 433 |
File providerAcceptedFile = providerAcceptedFiles[i]; |
|
| 434 |
if (FilenameUtils.getBaseName(providerAcceptedFile.getAbsolutePath()).equalsIgnoreCase( |
|
| 435 |
rowBaseName)) {
|
|
| 436 |
tileFile = providerAcceptedFile; |
|
| 437 |
} |
|
| 311 | 438 |
} |
| 312 |
if (params.getDynClass().getDynField("crs") != null) {
|
|
| 313 |
params.setDynValue("crs", this.crs);
|
|
| 314 |
} |
|
| 315 |
if(tileStore!=null){
|
|
| 316 |
// RasterStore store; |
|
| 317 |
tileStore.dispose(); |
|
| 318 |
} |
|
| 319 |
this.tileStore = (RasterStore) manager.openStore(providerName, params); |
|
| 439 |
this.extension = FilenameUtils.getExtension(tileFile.getAbsolutePath()); |
|
| 440 |
} else {
|
|
| 441 |
|
|
| 442 |
tileFile = |
|
| 443 |
new File(firstColumnFolder.getAbsolutePath() + File.separatorChar + rowBaseName + "." |
|
| 444 |
+ this.extension); |
|
| 320 | 445 |
} |
| 321 |
Band tileBand = tileStore.getRasterSet().getBand(band); |
|
| 322 |
Object rowBuffer = tileBand.createRowBuffer(); |
|
| 323 |
for (int r = 0; r < tileBand.getRows(); r++) {
|
|
| 324 |
tileBand.fetchRow(r, rowBuffer); |
|
| 325 |
System.arraycopy(rowBuffer, 0, buffer.array(), r * tileBand.getColumns(), tileBand.getColumns()); |
|
| 446 |
if (tileFile.exists()) {
|
|
| 447 |
RasterStore tileStore = null; |
|
| 448 |
DataManagerProviderServices manager = DALSPILocator.getDataManagerProviderServices(); |
|
| 449 |
DataStoreProviderFactory providerFactory = manager.getStoreProviderFactory(providerName); |
|
| 450 |
|
|
| 451 |
DynObject params = providerFactory.createParameters(); |
|
| 452 |
if (params.getDynClass().getDynField("file") != null) {
|
|
| 453 |
params.setDynValue("file", tileFile);
|
|
| 454 |
} |
|
| 455 |
if (params.getDynClass().getDynField("crs") != null) {
|
|
| 456 |
params.setDynValue("crs", this.crs);
|
|
| 457 |
} |
|
| 458 |
|
|
| 459 |
tileStore = (RasterStore) manager.openStore(providerName, params); |
|
| 460 |
return tileStore; |
|
| 326 | 461 |
} |
| 327 |
} catch (ValidateDataParametersException | DataException e) {
|
|
| 328 |
logger.warn("Can't fetch tile: zoomLevel = "+zoomLevel+", tileRow = "+tileRow+", tileColumn = "+tileCol+", band = "+band+".", e);
|
|
| 329 | 462 |
} |
| 330 | 463 |
} |
| 464 |
return null; |
|
| 331 | 465 |
} |
| 332 | 466 |
|
| 333 | 467 |
/** |
| 468 |
* @return delegatedRasterStore |
|
| 469 |
* @throws ProviderNotRegisteredException |
|
| 470 |
* @throws InitializeException |
|
| 471 |
* @throws ValidateDataParametersException |
|
| 472 |
*/ |
|
| 473 |
public RasterStore getDelegatedRasterStore() throws ValidateDataParametersException, InitializeException, ProviderNotRegisteredException{
|
|
| 474 |
int[] structRowCol = calculateStructRowCol(0, 0, 0); |
|
| 475 |
return createTileStore(0, structRowCol[0], structRowCol[1]); |
|
| 476 |
} |
|
| 477 |
|
|
| 478 |
|
|
| 479 |
/** |
|
| 334 | 480 |
* @return the band number |
| 335 | 481 |
*/ |
| 336 | 482 |
public int getBandNumber(){
|
| 483 |
if(this.bandNumber == null){
|
|
| 484 |
fillBandsInfo(); |
|
| 485 |
} |
|
| 337 | 486 |
return this.bandNumber; |
| 338 | 487 |
} |
| 339 | 488 |
|
| ... | ... | |
| 341 | 490 |
* @return the data types |
| 342 | 491 |
*/ |
| 343 | 492 |
public int[] getDataTypes(){
|
| 493 |
if(this.dataTypes == null){
|
|
| 494 |
fillBandsInfo(); |
|
| 495 |
} |
|
| 344 | 496 |
return this.dataTypes; |
| 345 | 497 |
} |
| 346 | 498 |
|
| 347 | 499 |
/** |
| 500 |
* |
|
| 501 |
*/ |
|
| 502 |
private void fillBandsInfo() {
|
|
| 503 |
RasterStore rasterStore = null; |
|
| 504 |
try {
|
|
| 505 |
rasterStore = getDelegatedRasterStore(); |
|
| 506 |
this.bandNumber = rasterStore.getBands(); |
|
| 507 |
this.dataTypes=new int[this.bandNumber]; |
|
| 508 |
for (int i=0;i<this.bandNumber;i++){
|
|
| 509 |
dataTypes[i]=rasterStore.getBandInfo(i).getDataType(); |
|
| 510 |
} |
|
| 511 |
} catch (ValidateDataParametersException | InitializeException | ProviderNotRegisteredException e) {
|
|
| 512 |
logger.warn("Can't get the delegated raster store", e);
|
|
| 513 |
} finally {
|
|
| 514 |
if(rasterStore != null){
|
|
| 515 |
rasterStore.dispose(); |
|
| 516 |
} |
|
| 517 |
} |
|
| 518 |
} |
|
| 519 |
|
|
| 520 |
|
|
| 521 |
/** |
|
| 348 | 522 |
* @param zoomLevel |
| 349 | 523 |
* @return rows per zoom level |
| 350 | 524 |
*/ |
| 351 | 525 |
public int getRows(int zoomLevel){
|
| 352 |
return rowsInZoomLevel.get(zoomLevel).size()*rowsPerTile; |
|
| 353 |
//rowsPerZoomLevel.get(zoomLevel); |
|
| 526 |
return (int)(getEnvelopePerZoomLevel(zoomLevel).getLength(DIMENSIONS.Y)/pixelSizePerZoomLevel.get(zoomLevel)); |
|
| 354 | 527 |
} |
| 355 | 528 |
|
| 356 | 529 |
/** |
| ... | ... | |
| 358 | 531 |
* @return columns per zoom level |
| 359 | 532 |
*/ |
| 360 | 533 |
public int getColumns(int zoomLevel){
|
| 361 |
return columnsInZoomLevel.get(zoomLevel).size()*columnsPerTile;
|
|
| 534 |
return (int)(getEnvelopePerZoomLevel(zoomLevel).getLength(DIMENSIONS.X)/pixelSizePerZoomLevel.get(zoomLevel));
|
|
| 362 | 535 |
} |
| 363 | 536 |
|
| 364 | 537 |
/** |
| ... | ... | |
| 366 | 539 |
* @return envelope por zoom level |
| 367 | 540 |
*/ |
| 368 | 541 |
public Envelope getEnvelopePerZoomLevel(int zoomLevel){
|
| 542 |
if(envelopePerZoomLevel.isEmpty()){
|
|
| 543 |
return structExtent; |
|
| 544 |
} |
|
| 369 | 545 |
return envelopePerZoomLevel.get(zoomLevel); |
| 370 | 546 |
} |
| 371 | 547 |
|
| ... | ... | |
| 390 | 566 |
return providerName; |
| 391 | 567 |
} |
| 392 | 568 |
|
| 569 |
private String composeKeyForRecentTiles(int zoomLevel, int structRow, int structCol){
|
|
| 570 |
StringBuilder builder = new StringBuilder(); |
|
| 571 |
builder.append(zoomLevel); |
|
| 572 |
builder.append(":");
|
|
| 573 |
builder.append(structRow); |
|
| 574 |
builder.append(":");
|
|
| 575 |
builder.append(structCol); |
|
| 576 |
return builder.toString(); |
|
| 577 |
} |
|
| 393 | 578 |
|
| 394 |
/** |
|
| 395 |
* @return the store of the loaded tile |
|
| 396 |
*/ |
|
| 397 |
public RasterStore getTileStore() {
|
|
| 398 |
return tileStore; |
|
| 579 |
private void removeOlderTile(){
|
|
| 580 |
|
|
| 581 |
Tile olderTile = null; |
|
| 582 |
for (Iterator iterator = recentAccededTiles.values().iterator(); iterator.hasNext();) {
|
|
| 583 |
Tile tile = (Tile) iterator.next(); |
|
| 584 |
if(olderTile == null || tile.getLastAccess()<olderTile.getLastAccess()){
|
|
| 585 |
olderTile = tile; |
|
| 586 |
} |
|
| 587 |
} |
|
| 588 |
if(olderTile!=null){
|
|
| 589 |
recentAccededTiles.remove(olderTile.getKey()); |
|
| 590 |
} |
|
| 399 | 591 |
} |
| 592 |
|
|
| 593 |
private class Tile {
|
|
| 594 |
|
|
| 595 |
org.gvsig.raster.lib.buffer.api.Buffer buffer; |
|
| 596 |
long lastAccess; |
|
| 597 |
String key; |
|
| 598 |
|
|
| 599 |
public Tile(org.gvsig.raster.lib.buffer.api.Buffer buffer, String key) {
|
|
| 600 |
this.buffer = buffer; |
|
| 601 |
this.key = key; |
|
| 602 |
lastAccess = System.currentTimeMillis(); |
|
| 603 |
} |
|
| 604 |
|
|
| 605 |
public String getKey() {
|
|
| 606 |
return key; |
|
| 607 |
} |
|
| 608 |
|
|
| 609 |
public org.gvsig.raster.lib.buffer.api.Buffer getBuffer(){
|
|
| 610 |
lastAccess = System.currentTimeMillis(); |
|
| 611 |
return buffer; |
|
| 612 |
} |
|
| 613 |
|
|
| 614 |
public long getLastAccess() {
|
|
| 615 |
return lastAccess; |
|
| 616 |
} |
|
| 617 |
} |
|
| 618 |
|
|
| 400 | 619 |
} |
| 401 | 620 |
|
| org.gvsig.raster/branches/org.gvsig.raster.2.4/org.gvsig.raster/org.gvsig.raster.tilecache/org.gvsig.raster.tilecache.provider/src/main/java/org/gvsig/raster/tilecache/provider/TileCacheStoreProvider.java | ||
|---|---|---|
| 135 | 135 |
throw new InitializeException( |
| 136 | 136 |
new NullPointerException("params is null"));
|
| 137 | 137 |
} |
| 138 |
// File file = getTileCacheParameters().getFile(); |
|
| 139 |
// if (file == null) {
|
|
| 140 |
// throw new InitializeException( |
|
| 141 |
// new NullPointerException("Jimi file is null"));
|
|
| 142 |
// } |
|
| 143 |
// |
|
| 138 |
|
|
| 144 | 139 |
this.projection=params.getCRS(); |
| 145 | 140 |
|
| 146 |
//FIXME |
|
| 147 |
File file = new File("/home/paco/data/cartography/raster/tile-valencia1980");
|
|
| 141 |
File cacheFolder=null; |
|
| 148 | 142 |
|
| 143 |
//FIXME: Get appropriate folder to cache tiles |
|
| 144 |
cacheFolder = new File("/home/paco/data/cartography/raster/tile-valencia1980");
|
|
| 145 |
|
|
| 149 | 146 |
resource = this.createResource( |
| 150 | 147 |
FileResource.NAME, |
| 151 |
new Object[] { file.getAbsolutePath() }
|
|
| 148 |
new Object[] { cacheFolder.getAbsolutePath() }
|
|
| 152 | 149 |
); |
| 153 | 150 |
|
| 154 | 151 |
resource.addConsumer(this); |
| org.gvsig.raster/branches/org.gvsig.raster.2.4/org.gvsig.raster/org.gvsig.raster.tilecache/org.gvsig.raster.tilecache.provider/src/main/java/org/gvsig/raster/tilecache/provider/TileCacheBandPageManager.java | ||
|---|---|---|
| 3 | 3 |
import java.io.IOException; |
| 4 | 4 |
import java.nio.Buffer; |
| 5 | 5 |
|
| 6 |
import org.gvsig.raster.lib.buffer.api.Band; |
|
| 6 | 7 |
import org.gvsig.raster.lib.buffer.api.BandInfo; |
| 7 | 8 |
import org.gvsig.raster.lib.buffer.api.BandTileManager; |
| 8 | 9 |
|
| ... | ... | |
| 14 | 15 |
public class TileCacheBandPageManager implements BandTileManager{
|
| 15 | 16 |
|
| 16 | 17 |
private TileStructImage tileStructImage; |
| 17 |
private int band; |
|
| 18 |
private int bandNumber;
|
|
| 18 | 19 |
private int zoomLevel; |
| 19 | 20 |
|
| 20 | 21 |
/** |
| ... | ... | |
| 24 | 25 |
*/ |
| 25 | 26 |
public TileCacheBandPageManager(TileStructImage tileStructImage, int zoomLevel, int band){
|
| 26 | 27 |
this.tileStructImage=tileStructImage; |
| 27 |
this.band=band; |
|
| 28 |
this.bandNumber=band;
|
|
| 28 | 29 |
this.zoomLevel=zoomLevel; |
| 29 | 30 |
} |
| 30 | 31 |
|
| ... | ... | |
| 34 | 35 |
} |
| 35 | 36 |
|
| 36 | 37 |
@Override |
| 37 |
public void load(Buffer buffer, int row, int rows, int col, int cols, int dataType) throws IOException {
|
|
| 38 |
buffer.rewind(); |
|
| 38 |
public Band load(int row, int col, int dataType) throws IOException {
|
|
| 39 | 39 |
|
| 40 | 40 |
int tileRow=(int)row/getRowsPerTile(); |
| 41 | 41 |
int tileCol=(int)col/getColumnsPerTile(); |
| 42 | 42 |
|
| 43 |
tileStructImage.fetchTile(buffer, band, this.zoomLevel,tileRow,tileCol);
|
|
| 43 |
return tileStructImage.fetchTile(bandNumber, this.zoomLevel, tileRow, tileCol);
|
|
| 44 | 44 |
|
| 45 | 45 |
} |
| 46 | 46 |
|
Also available in: Unified diff