Revision 6488
| 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 | ||
|---|---|---|
| 2 | 2 |
|
| 3 | 3 |
import org.slf4j.LoggerFactory; |
| 4 | 4 |
|
| 5 |
import org.gvsig.fmap.dal.exception.DataException; |
|
| 6 |
import org.gvsig.fmap.dal.exception.ValidateDataParametersException; |
|
| 5 | 7 |
import org.gvsig.fmap.dal.raster.api.RasterStore; |
| 8 |
import org.gvsig.fmap.geom.exception.CreateEnvelopeException; |
|
| 9 |
import org.gvsig.raster.lib.buffer.api.exceptions.BufferException; |
|
| 6 | 10 |
import org.gvsig.raster.lib.legend.api.ColorInterpretation; |
| 7 | 11 |
import org.gvsig.raster.tilecache.provider.TileCacheStoreProvider; |
| 8 | 12 |
import org.gvsig.raster.tilecache.provider.TileStructImage; |
| ... | ... | |
| 57 | 61 |
|
| 58 | 62 |
TileStructImage tileStructImage = tileCacheStoreProvider.getTileStructImage(); |
| 59 | 63 |
|
| 60 |
colorInterpretation = (ColorInterpretation)tileStructImage.getColorInterpretation(); |
|
| 64 |
try {
|
|
| 65 |
colorInterpretation = (ColorInterpretation)tileStructImage.getColorInterpretation(); |
|
| 66 |
} catch (ValidateDataParametersException | CreateEnvelopeException | BufferException | DataException |
|
| 67 |
| CloneNotSupportedException e) {
|
|
| 68 |
logger.warn("Can't get color interpretation", e);
|
|
| 69 |
} |
|
| 61 | 70 |
|
| 62 | 71 |
return colorInterpretation; |
| 63 | 72 |
} |
| 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 | ||
|---|---|---|
| 2 | 2 |
|
| 3 | 3 |
import org.slf4j.LoggerFactory; |
| 4 | 4 |
|
| 5 |
import org.gvsig.fmap.dal.exception.DataException; |
|
| 6 |
import org.gvsig.fmap.dal.exception.ValidateDataParametersException; |
|
| 5 | 7 |
import org.gvsig.fmap.dal.raster.api.RasterStore; |
| 8 |
import org.gvsig.fmap.geom.exception.CreateEnvelopeException; |
|
| 9 |
import org.gvsig.raster.lib.buffer.api.exceptions.BufferException; |
|
| 6 | 10 |
import org.gvsig.raster.lib.legend.api.ColorTable; |
| 7 | 11 |
import org.gvsig.raster.tilecache.provider.TileCacheStoreProvider; |
| 8 | 12 |
import org.gvsig.raster.tilecache.provider.TileStructImage; |
| ... | ... | |
| 57 | 61 |
(TileCacheStoreProvider) self; |
| 58 | 62 |
TileStructImage tileStructImage = tileCacheStoreProvider.getTileStructImage(); |
| 59 | 63 |
|
| 60 |
colorTable = (ColorTable)tileStructImage.getColorTable(); |
|
| 64 |
try {
|
|
| 65 |
colorTable = (ColorTable)tileStructImage.getColorTable(); |
|
| 66 |
} catch (ValidateDataParametersException | CreateEnvelopeException | BufferException | DataException |
|
| 67 |
| CloneNotSupportedException e) {
|
|
| 68 |
logger.warn("Can't get color table", e);
|
|
| 69 |
} |
|
| 61 | 70 |
|
| 62 | 71 |
return colorTable; |
| 63 | 72 |
|
| 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 | ||
|---|---|---|
| 2 | 2 |
|
| 3 | 3 |
import org.slf4j.LoggerFactory; |
| 4 | 4 |
|
| 5 |
import org.gvsig.fmap.dal.exception.DataException; |
|
| 6 |
import org.gvsig.fmap.dal.exception.ValidateDataParametersException; |
|
| 5 | 7 |
import org.gvsig.fmap.dal.raster.api.RasterStore; |
| 8 |
import org.gvsig.fmap.geom.exception.CreateEnvelopeException; |
|
| 9 |
import org.gvsig.raster.lib.buffer.api.exceptions.BufferException; |
|
| 6 | 10 |
import org.gvsig.raster.lib.legend.api.RasterLegend; |
| 7 | 11 |
import org.gvsig.raster.tilecache.provider.TileCacheStoreProvider; |
| 8 | 12 |
import org.gvsig.raster.tilecache.provider.TileStructImage; |
| ... | ... | |
| 56 | 60 |
TileCacheStoreProvider tileCacheStoreProvider = (TileCacheStoreProvider) self; |
| 57 | 61 |
|
| 58 | 62 |
TileStructImage tileStructImage = tileCacheStoreProvider.getTileStructImage(); |
| 59 |
legend = (RasterLegend) tileStructImage.getLegend(); |
|
| 63 |
try {
|
|
| 64 |
legend = (RasterLegend) tileStructImage.getLegend(); |
|
| 65 |
} catch (ValidateDataParametersException | CreateEnvelopeException | BufferException | DataException |
|
| 66 |
| CloneNotSupportedException e) {
|
|
| 67 |
logger.warn("Can't get legend", e);
|
|
| 68 |
} |
|
| 60 | 69 |
|
| 61 | 70 |
return legend; |
| 62 | 71 |
} |
| 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.fmap.dal.exception.ValidateDataParametersException; |
|
| 7 |
import org.gvsig.fmap.geom.exception.CreateEnvelopeException; |
|
| 6 | 8 |
import org.gvsig.raster.lib.buffer.api.Band; |
| 7 | 9 |
import org.gvsig.raster.lib.buffer.api.BandInfo; |
| 8 | 10 |
import org.gvsig.raster.lib.buffer.api.BandTileManager; |
| ... | ... | |
| 40 | 42 |
int tileRow=(int)row/getRowsPerTile(); |
| 41 | 43 |
int tileCol=(int)col/getColumnsPerTile(); |
| 42 | 44 |
|
| 43 |
return tileStructImage.fetchTile(bandNumber, this.zoomLevel, tileRow, tileCol); |
|
| 45 |
try {
|
|
| 46 |
return tileStructImage.fetchTile(bandNumber, this.zoomLevel, tileRow, tileCol); |
|
| 47 |
} catch (ValidateDataParametersException | CreateEnvelopeException | CloneNotSupportedException e) {
|
|
| 48 |
throw new IOException("Can't load band.", e);
|
|
| 49 |
} |
|
| 44 | 50 |
|
| 45 | 51 |
} |
| 46 | 52 |
|
| 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/TileCacheStoreProviderFactory.java | ||
|---|---|---|
| 38 | 38 |
import org.slf4j.LoggerFactory; |
| 39 | 39 |
|
| 40 | 40 |
/** |
| 41 |
* Factory for JIMI provider
|
|
| 41 |
* Factory for TileCache provider
|
|
| 42 | 42 |
* @author dmartinezizquierdo |
| 43 | 43 |
* |
| 44 | 44 |
*/ |
| ... | ... | |
| 60 | 60 |
public DynObject createParameters() {
|
| 61 | 61 |
return new TileCacheStoreProviderParameters(); |
| 62 | 62 |
} |
| 63 |
|
|
| 64 |
public TileCacheStoreProvider createJimiProvider(TileCacheStoreProviderParameters parameters, |
|
| 65 |
DataStoreProviderServices providerServices) throws InitializeException {
|
|
| 66 |
return new TileCacheStoreProvider(parameters,providerServices); |
|
| 67 |
} |
|
| 68 |
|
|
| 69 |
public TileCacheStoreProviderParameters createJimiParameters(){
|
|
| 70 |
return new TileCacheStoreProviderParameters(); |
|
| 71 |
} |
|
| 72 |
|
|
| 73 | 63 |
} |
| 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 | ||
|---|---|---|
| 43 | 43 |
import org.w3c.dom.NodeList; |
| 44 | 44 |
|
| 45 | 45 |
import org.gvsig.fmap.dal.DALFileLocator; |
| 46 |
import org.gvsig.fmap.dal.DataServerExplorer; |
|
| 47 |
import org.gvsig.fmap.dal.DataServerExplorerParameters; |
|
| 46 | 48 |
import org.gvsig.fmap.dal.DataStoreProviderFactory; |
| 47 | 49 |
import org.gvsig.fmap.dal.exception.DataException; |
| 48 | 50 |
import org.gvsig.fmap.dal.exception.InitializeException; |
| 49 | 51 |
import org.gvsig.fmap.dal.exception.ProviderNotRegisteredException; |
| 50 | 52 |
import org.gvsig.fmap.dal.exception.ValidateDataParametersException; |
| 53 |
import org.gvsig.fmap.dal.raster.api.RasterQuery; |
|
| 51 | 54 |
import org.gvsig.fmap.dal.raster.api.RasterStore; |
| 55 |
import org.gvsig.fmap.dal.raster.spi.NewRasterStoreParameters; |
|
| 52 | 56 |
import org.gvsig.fmap.dal.raster.spi.RasterStoreProvider; |
| 53 | 57 |
import org.gvsig.fmap.dal.serverexplorer.filesystem.spi.FilesystemServerExplorerManager; |
| 54 | 58 |
import org.gvsig.fmap.dal.serverexplorer.filesystem.spi.FilesystemServerExplorerProviderFactory; |
| ... | ... | |
| 58 | 62 |
import org.gvsig.fmap.geom.Geometry.SUBTYPES; |
| 59 | 63 |
import org.gvsig.fmap.geom.GeometryLocator; |
| 60 | 64 |
import org.gvsig.fmap.geom.GeometryManager; |
| 65 |
import org.gvsig.fmap.geom.exception.CreateEnvelopeException; |
|
| 61 | 66 |
import org.gvsig.fmap.geom.primitive.Envelope; |
| 62 | 67 |
import org.gvsig.raster.lib.buffer.api.Band; |
| 63 | 68 |
import org.gvsig.raster.lib.buffer.api.Buffer; |
| ... | ... | |
| 66 | 71 |
import org.gvsig.raster.lib.buffer.api.exceptions.BufferException; |
| 67 | 72 |
import org.gvsig.tools.dynobject.DynObject; |
| 68 | 73 |
import org.gvsig.tools.dynobject.exception.DynMethodException; |
| 69 |
import org.gvsig.tools.dynobject.exception.DynMethodNotSupportedException; |
|
| 70 | 74 |
import org.gvsig.tools.extensionpoint.ExtensionPoint.Extension; |
| 71 | 75 |
|
| 72 | 76 |
/** |
| ... | ... | |
| 85 | 89 |
private String providerName; |
| 86 | 90 |
private String extension; |
| 87 | 91 |
private SortedMap<Integer,Double> pixelSizePerZoomLevel; |
| 88 |
private SortedMap<Integer,Envelope> envelopePerZoomLevel; |
|
| 92 |
// private SortedMap<Integer,Envelope> envelopePerZoomLevel;
|
|
| 89 | 93 |
private File tilesFolder; |
| 90 | 94 |
private Map<String, Tile> recentAccededTiles; |
| 91 | 95 |
|
| ... | ... | |
| 94 | 98 |
private int[] dataTypes; |
| 95 | 99 |
|
| 96 | 100 |
private IProjection crs; |
| 101 |
// Este envelope sirve para calcular el nombre de la fila y columna del tile en la estructura de cach?. |
|
| 97 | 102 |
private Envelope structExtent; |
| 98 |
private RasterStoreProvider remoteProvider; |
|
| 99 | 103 |
private Object colorInterpretation; |
| 100 | 104 |
private Object legend; |
| 101 |
// Este envelope sirve para calcular el nombre de la fila y columna del tile en la estructura de cach?. |
|
| 102 | 105 |
private Object colorTable; |
| 103 | 106 |
|
| 107 |
private RasterStoreProvider innerProvider; |
|
| 108 |
private RasterQuery query; |
|
| 109 |
|
|
| 104 | 110 |
/** |
| 105 | 111 |
* @param folder |
| 106 | 112 |
* @param crs |
| 107 |
* @param remoteProvider |
|
| 113 |
* @param innerProvider |
|
| 114 |
* @param innerStore |
|
| 108 | 115 |
*/ |
| 109 |
public TileStructImage(File folder, IProjection crs, RasterStoreProvider remoteProvider){
|
|
| 110 |
GeometryManager geoManager=GeometryLocator.getGeometryManager(); |
|
| 116 |
public TileStructImage(File folder, IProjection crs, RasterStoreProvider innerProvider, RasterQuery query) {
|
|
| 117 |
this.crs = crs; |
|
| 118 |
this.innerProvider = innerProvider; |
|
| 119 |
this.query = query; |
|
| 120 |
GeometryManager geoManager = GeometryLocator.getGeometryManager(); |
|
| 111 | 121 |
|
| 112 |
this.remoteProvider = remoteProvider; |
|
| 113 |
|
|
| 114 |
this.crs=crs; |
|
| 115 |
|
|
| 116 |
envelopePerZoomLevel=new TreeMap<Integer,Envelope>(); |
|
| 117 |
pixelSizePerZoomLevel=new TreeMap<Integer,Double>(); |
|
| 122 |
// envelopePerZoomLevel = new TreeMap<Integer, Envelope>(); |
|
| 123 |
pixelSizePerZoomLevel = new TreeMap<Integer, Double>(); |
|
| 118 | 124 |
recentAccededTiles = new HashMap<String, Tile>(); |
| 119 | 125 |
|
| 120 |
|
|
| 121 |
//FIXME |
|
| 122 |
File tilePropertiesFile=new File(folder, "tileCacheStruct.xml"); |
|
| 123 |
tilesFolder=new File (folder,"V"+File.separatorChar+"Z"+File.separatorChar+"T"); |
|
| 126 |
// FIXME |
|
| 127 |
File tilePropertiesFile = new File(folder, "tileCacheStruct.xml"); |
|
| 128 |
tilesFolder = new File(folder, "V" + File.separatorChar + "Z" + File.separatorChar + "T"); |
|
| 129 |
if(!tilesFolder.exists()){
|
|
| 130 |
tilesFolder.mkdirs(); |
|
| 131 |
} |
|
| 124 | 132 |
DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance(); |
| 125 | 133 |
DocumentBuilder dBuilder; |
| 126 | 134 |
try {
|
| ... | ... | |
| 137 | 145 |
if (nNode.getNodeType() == Node.ELEMENT_NODE) {
|
| 138 | 146 |
Element eElement = (Element) nNode; |
| 139 | 147 |
|
| 140 |
|
|
| 141 | 148 |
NamedNodeMap tileSizeAttributes = eElement.getElementsByTagName("tileSize").item(0).getAttributes();
|
| 142 |
rowsPerTile=Integer.valueOf(tileSizeAttributes.getNamedItem("rows").getNodeValue());
|
|
| 143 |
columnsPerTile=Integer.valueOf(tileSizeAttributes.getNamedItem("columns").getNodeValue());
|
|
| 149 |
rowsPerTile = Integer.valueOf(tileSizeAttributes.getNamedItem("rows").getNodeValue());
|
|
| 150 |
columnsPerTile = Integer.valueOf(tileSizeAttributes.getNamedItem("columns").getNodeValue());
|
|
| 144 | 151 |
|
| 145 | 152 |
NodeList elementsByTagName = eElement.getElementsByTagName("format");
|
| 146 |
providerName=elementsByTagName.item(0).getTextContent();
|
|
| 153 |
providerName = elementsByTagName.item(0).getTextContent();
|
|
| 147 | 154 |
|
| 148 | 155 |
NodeList structExtentList = eElement.getElementsByTagName("structExtent");
|
| 149 |
if(structExtentList.getLength()>0){
|
|
| 150 |
Element structExtentNode=(Element) structExtentList.item(0); |
|
| 151 |
if(structExtentNode!=null){
|
|
| 152 |
Double minX = Double.valueOf(structExtentNode.getElementsByTagName("minX").item(0).getTextContent());
|
|
| 153 |
Double minY = Double.valueOf(structExtentNode.getElementsByTagName("minY").item(0).getTextContent());
|
|
| 154 |
Double maxX = Double.valueOf(structExtentNode.getElementsByTagName("maxX").item(0).getTextContent());
|
|
| 155 |
Double maxY = Double.valueOf(structExtentNode.getElementsByTagName("maxY").item(0).getTextContent());
|
|
| 156 |
structExtent = geoManager.createEnvelope( |
|
| 157 |
minX, |
|
| 158 |
minY, |
|
| 159 |
maxX, |
|
| 160 |
maxY, |
|
| 161 |
SUBTYPES.GEOM2D); |
|
| 156 |
if (structExtentList.getLength() > 0) {
|
|
| 157 |
Element structExtentNode = (Element) structExtentList.item(0); |
|
| 158 |
if (structExtentNode != null) {
|
|
| 159 |
Double minX = |
|
| 160 |
Double.valueOf(structExtentNode.getElementsByTagName("minX").item(0).getTextContent());
|
|
| 161 |
Double minY = |
|
| 162 |
Double.valueOf(structExtentNode.getElementsByTagName("minY").item(0).getTextContent());
|
|
| 163 |
Double maxX = |
|
| 164 |
Double.valueOf(structExtentNode.getElementsByTagName("maxX").item(0).getTextContent());
|
|
| 165 |
Double maxY = |
|
| 166 |
Double.valueOf(structExtentNode.getElementsByTagName("maxY").item(0).getTextContent());
|
|
| 167 |
structExtent = geoManager.createEnvelope(minX, minY, maxX, maxY, SUBTYPES.GEOM2D); |
|
| 162 | 168 |
} |
| 163 | 169 |
} |
| 164 | 170 |
|
| 165 |
FilesystemServerExplorerManager explorerManager = DALFileLocator.getFilesystemServerExplorerManager(); |
|
| 171 |
FilesystemServerExplorerManager explorerManager = |
|
| 172 |
DALFileLocator.getFilesystemServerExplorerManager(); |
|
| 166 | 173 |
@SuppressWarnings("unchecked")
|
| 167 | 174 |
Iterator<Extension> it = explorerManager.getRegisteredProviders(); |
| 168 |
while(it.hasNext()){
|
|
| 175 |
while (it.hasNext()) {
|
|
| 169 | 176 |
|
| 170 | 177 |
Extension ext = it.next(); |
| 171 | 178 |
FilesystemServerExplorerProviderFactory providerFactory; |
| 172 | 179 |
try {
|
| 173 | 180 |
providerFactory = (FilesystemServerExplorerProviderFactory) ext.create(); |
| 174 |
if(providerFactory.getName().equalsIgnoreCase(providerName)){
|
|
| 181 |
if (providerFactory.getName().equalsIgnoreCase(providerName)) {
|
|
| 175 | 182 |
this.factory = providerFactory; |
| 176 | 183 |
break; |
| 177 | 184 |
} |
| ... | ... | |
| 181 | 188 |
} |
| 182 | 189 |
|
| 183 | 190 |
NodeList levelsTag = eElement.getElementsByTagName("levels");
|
| 184 |
Element levels = (Element)levelsTag.item(0); |
|
| 185 |
NodeList levelList=levels.getElementsByTagName("level");
|
|
| 191 |
Element levels = (Element) levelsTag.item(0);
|
|
| 192 |
NodeList levelList = levels.getElementsByTagName("level");
|
|
| 186 | 193 |
for (int i = 0; i < levelList.getLength(); i++) {
|
| 187 |
Element level = (Element)levelList.item(i); |
|
| 194 |
Element level = (Element) levelList.item(i);
|
|
| 188 | 195 |
|
| 189 | 196 |
NamedNodeMap levelAttributes = level.getAttributes(); |
| 190 |
int zoomLevel=Integer.valueOf(levelAttributes.getNamedItem("index").getNodeValue());
|
|
| 191 |
double pixelSize=Double.valueOf(levelAttributes.getNamedItem("pixelSize").getNodeValue());
|
|
| 197 |
int zoomLevel = Integer.valueOf(levelAttributes.getNamedItem("index").getNodeValue());
|
|
| 198 |
double pixelSize = Double.valueOf(levelAttributes.getNamedItem("pixelSize").getNodeValue());
|
|
| 192 | 199 |
|
| 193 | 200 |
pixelSizePerZoomLevel.put(zoomLevel, pixelSize); |
| 194 | 201 |
|
| 195 |
NodeList extentList = level.getElementsByTagName("extent");
|
|
| 196 |
if(extentList.getLength()>0){
|
|
| 197 |
Element extentNode=(Element) extentList.item(0); |
|
| 198 |
if(extentNode!=null){
|
|
| 199 |
Double minX = Double.valueOf(extentNode.getElementsByTagName("minX").item(0).getTextContent());
|
|
| 200 |
Double minY = Double.valueOf(extentNode.getElementsByTagName("minY").item(0).getTextContent());
|
|
| 201 |
Double maxX = Double.valueOf(extentNode.getElementsByTagName("maxX").item(0).getTextContent());
|
|
| 202 |
Double maxY = Double.valueOf(extentNode.getElementsByTagName("maxY").item(0).getTextContent());
|
|
| 203 |
Envelope extent = geoManager.createEnvelope( |
|
| 204 |
minX, |
|
| 205 |
minY, |
|
| 206 |
maxX, |
|
| 207 |
maxY, |
|
| 208 |
SUBTYPES.GEOM2D); |
|
| 209 |
envelopePerZoomLevel.put(zoomLevel, extent); |
|
| 210 |
} |
|
| 211 |
} |
|
| 202 |
// NodeList extentList = level.getElementsByTagName("extent");
|
|
| 203 |
// if (extentList.getLength() > 0) {
|
|
| 204 |
// Element extentNode = (Element) extentList.item(0); |
|
| 205 |
// if (extentNode != null) {
|
|
| 206 |
// Double minX = |
|
| 207 |
// Double.valueOf(extentNode.getElementsByTagName("minX").item(0).getTextContent());
|
|
| 208 |
// Double minY = |
|
| 209 |
// Double.valueOf(extentNode.getElementsByTagName("minY").item(0).getTextContent());
|
|
| 210 |
// Double maxX = |
|
| 211 |
// Double.valueOf(extentNode.getElementsByTagName("maxX").item(0).getTextContent());
|
|
| 212 |
// Double maxY = |
|
| 213 |
// Double.valueOf(extentNode.getElementsByTagName("maxY").item(0).getTextContent());
|
|
| 214 |
// Envelope extent = geoManager.createEnvelope(minX, minY, maxX, maxY, SUBTYPES.GEOM2D); |
|
| 215 |
// envelopePerZoomLevel.put(zoomLevel, extent); |
|
| 216 |
// } |
|
| 217 |
// } |
|
| 212 | 218 |
} |
| 213 | 219 |
} |
| 214 | 220 |
} |
| 215 | 221 |
} catch (Exception e) {
|
| 216 | 222 |
throw new RuntimeException(); |
| 217 | 223 |
} |
| 218 |
|
|
| 219 | 224 |
} |
| 225 |
// |
|
| 226 |
// public TileStructImage(File folder, IProjection crs, RasterStoreProvider innerProvider) {
|
|
| 227 |
// |
|
| 228 |
// this.innerProvider = innerProvider; |
|
| 229 |
// this.crs = crs; |
|
| 230 |
// |
|
| 231 |
// |
|
| 232 |
// |
|
| 233 |
// } |
|
| 220 | 234 |
|
| 235 |
|
|
| 221 | 236 |
/** |
| 222 | 237 |
* @param pixelSize |
| 223 | 238 |
* @return The appropiate zoom level for the pizelSize |
| ... | ... | |
| 238 | 253 |
//index 0 structRow, index 1 structCol |
| 239 | 254 |
int[] structRowCol = new int[2]; |
| 240 | 255 |
|
| 241 |
if(envelopePerZoomLevel.isEmpty()){
|
|
| 256 |
// if(envelopePerZoomLevel==null || envelopePerZoomLevel.isEmpty()){
|
|
| 242 | 257 |
structRowCol[0] = tileRow; |
| 243 | 258 |
structRowCol[1] = tileCol; |
| 244 |
} else {
|
|
| 245 |
Envelope envelopeInZoomLevel = envelopePerZoomLevel.get(zoomLevel); |
|
| 246 |
structRowCol[0] = (int)(-(envelopeInZoomLevel.getMaximum(DIMENSIONS.Y)-structExtent.getMaximum(DIMENSIONS.Y))/(pixelSizePerZoomLevel.get(zoomLevel)*rowsPerTile))+tileRow; |
|
| 247 |
structRowCol[1] = (int)((envelopeInZoomLevel.getMinimum(DIMENSIONS.X)-structExtent.getMinimum(DIMENSIONS.X))/(pixelSizePerZoomLevel.get(zoomLevel)*columnsPerTile))+tileCol; |
|
| 248 |
} |
|
| 259 |
// } else {
|
|
| 260 |
// Envelope envelopeInZoomLevel = envelopePerZoomLevel.get(zoomLevel);
|
|
| 261 |
// structRowCol[0] = (int)(-(envelopeInZoomLevel.getMaximum(DIMENSIONS.Y)-structExtent.getMaximum(DIMENSIONS.Y))/(pixelSizePerZoomLevel.get(zoomLevel)*rowsPerTile))+tileRow;
|
|
| 262 |
// structRowCol[1] = (int)((envelopeInZoomLevel.getMinimum(DIMENSIONS.X)-structExtent.getMinimum(DIMENSIONS.X))/(pixelSizePerZoomLevel.get(zoomLevel)*columnsPerTile))+tileCol;
|
|
| 263 |
// }
|
|
| 249 | 264 |
|
| 250 | 265 |
return structRowCol; |
| 251 | 266 |
|
| ... | ... | |
| 258 | 273 |
* @param tileRow |
| 259 | 274 |
* @param tileCol |
| 260 | 275 |
* @return Band |
| 276 |
* @throws CreateEnvelopeException |
|
| 277 |
* @throws CloneNotSupportedException |
|
| 278 |
* @throws ValidateDataParametersException |
|
| 261 | 279 |
*/ |
| 262 |
public Band fetchTile(int band, int zoomLevel, int tileRow, int tileCol) {
|
|
| 280 |
public Band fetchTile(int band, int zoomLevel, int tileRow, int tileCol) throws CreateEnvelopeException, ValidateDataParametersException, CloneNotSupportedException {
|
|
| 263 | 281 |
|
| 264 | 282 |
BufferManager bufferManager = BufferLocator.getBufferManager(); |
| 265 | 283 |
int[] structRowCol = calculateStructRowCol(zoomLevel, tileRow, tileCol); |
| ... | ... | |
| 286 | 304 |
recentAccededTiles.put(keyTile, new Tile(rasterSet, keyTile)); |
| 287 | 305 |
|
| 288 | 306 |
return rasterSet.getBand(band); |
| 289 |
} catch (DataException | ValidateDataParametersException | BufferException e) {
|
|
| 307 |
} catch (DataException | BufferException e) {
|
|
| 290 | 308 |
logger.warn("Can't fetch tile: zoomLevel = " + zoomLevel + ", tileRow = " + tileRow + ", tileColumn = "
|
| 291 | 309 |
+ tileCol + ", band = " + band + ".", e); |
| 292 | 310 |
return null; |
| ... | ... | |
| 298 | 316 |
} |
| 299 | 317 |
} |
| 300 | 318 |
|
| 301 |
private RasterStore createTileStore(int zoomLevel, int structRow, int structCol) throws ValidateDataParametersException, InitializeException, ProviderNotRegisteredException{
|
|
| 319 |
private RasterStore createTileStore(int zoomLevel, int structRow, int structCol) |
|
| 320 |
throws ValidateDataParametersException, CreateEnvelopeException, BufferException, DataException, |
|
| 321 |
CloneNotSupportedException {
|
|
| 302 | 322 |
|
| 303 | 323 |
File tileFile = null; |
| 304 | 324 |
File zoomFolder = new File(tilesFolder, String.valueOf(zoomLevel)); |
| 305 |
if (zoomFolder.exists()) {
|
|
| 306 |
File firstColumnFolder = new File(zoomFolder, String.valueOf(structCol)); |
|
| 307 |
if (firstColumnFolder.exists()) {
|
|
| 308 |
String rowBaseName = String.valueOf(structRow); |
|
| 325 |
if (!zoomFolder.exists()) {
|
|
| 326 |
zoomFolder.mkdirs(); |
|
| 327 |
} |
|
| 328 |
File firstColumnFolder = new File(zoomFolder, String.valueOf(structCol)); |
|
| 329 |
if (!firstColumnFolder.exists()) {
|
|
| 330 |
tileFile = requestTileFile(zoomLevel, structRow, structCol); |
|
| 331 |
this.extension = FilenameUtils.getExtension(tileFile.getAbsolutePath()); |
|
| 332 |
} |
|
| 333 |
String rowBaseName = String.valueOf(structRow); |
|
| 334 |
if (this.extension == null) {
|
|
| 335 |
File[] providerAcceptedFiles = firstColumnFolder.listFiles(factory); |
|
| 336 |
for (int i = 0; i < providerAcceptedFiles.length; i++) {
|
|
| 337 |
File providerAcceptedFile = providerAcceptedFiles[i]; |
|
| 338 |
if (FilenameUtils.getBaseName(providerAcceptedFile.getAbsolutePath()).equalsIgnoreCase(rowBaseName)) {
|
|
| 339 |
tileFile = providerAcceptedFile; |
|
| 340 |
} |
|
| 341 |
} |
|
| 342 |
if (tileFile == null || !tileFile.exists()) {
|
|
| 343 |
tileFile = requestTileFile(zoomLevel, structRow, structCol); |
|
| 344 |
} |
|
| 345 |
this.extension = FilenameUtils.getExtension(tileFile.getAbsolutePath()); |
|
| 346 |
} else {
|
|
| 347 |
if (tileFile == null) {
|
|
| 348 |
tileFile = |
|
| 349 |
new File(firstColumnFolder.getAbsolutePath() + File.separatorChar + rowBaseName + "." |
|
| 350 |
+ this.extension); |
|
| 351 |
} |
|
| 352 |
} |
|
| 353 |
if (!tileFile.exists()) {
|
|
| 354 |
tileFile = requestTileFile(zoomLevel, structRow, structCol); |
|
| 355 |
} |
|
| 356 |
RasterStore tileStore = null; |
|
| 357 |
DataManagerProviderServices manager = DALSPILocator.getDataManagerProviderServices(); |
|
| 358 |
DataStoreProviderFactory providerFactory = manager.getStoreProviderFactory(providerName); |
|
| 309 | 359 |
|
| 310 |
if (this.extension == null) {
|
|
| 311 |
File[] providerAcceptedFiles = firstColumnFolder.listFiles(factory); |
|
| 312 |
for (int i = 0; i < providerAcceptedFiles.length; i++) {
|
|
| 313 |
File providerAcceptedFile = providerAcceptedFiles[i]; |
|
| 314 |
if (FilenameUtils.getBaseName(providerAcceptedFile.getAbsolutePath()).equalsIgnoreCase( |
|
| 315 |
rowBaseName)) {
|
|
| 316 |
tileFile = providerAcceptedFile; |
|
| 317 |
} |
|
| 318 |
} |
|
| 319 |
this.extension = FilenameUtils.getExtension(tileFile.getAbsolutePath()); |
|
| 320 |
} else {
|
|
| 360 |
DynObject params = providerFactory.createParameters(); |
|
| 361 |
if (params.getDynClass().getDynField("file") != null) {
|
|
| 362 |
params.setDynValue("file", tileFile);
|
|
| 363 |
} |
|
| 364 |
if (params.getDynClass().getDynField("crs") != null) {
|
|
| 365 |
params.setDynValue("crs", this.crs);
|
|
| 366 |
} |
|
| 321 | 367 |
|
| 322 |
tileFile = |
|
| 323 |
new File(firstColumnFolder.getAbsolutePath() + File.separatorChar + rowBaseName + "." |
|
| 324 |
+ this.extension); |
|
| 325 |
} |
|
| 326 |
if (!tileFile.exists()) {
|
|
| 327 |
// TODO pedirselo al proveedor remoto |
|
| 328 |
} |
|
| 329 |
RasterStore tileStore = null; |
|
| 330 |
DataManagerProviderServices manager = DALSPILocator.getDataManagerProviderServices(); |
|
| 331 |
DataStoreProviderFactory providerFactory = manager.getStoreProviderFactory(providerName); |
|
| 368 |
tileStore = (RasterStore) manager.openStore(providerName, params); |
|
| 369 |
return tileStore; |
|
| 370 |
} |
|
| 332 | 371 |
|
| 333 |
DynObject params = providerFactory.createParameters(); |
|
| 334 |
if (params.getDynClass().getDynField("file") != null) {
|
|
| 335 |
params.setDynValue("file", tileFile);
|
|
| 336 |
} |
|
| 337 |
if (params.getDynClass().getDynField("crs") != null) {
|
|
| 338 |
params.setDynValue("crs", this.crs);
|
|
| 339 |
} |
|
| 372 |
private File requestTileFile(int zoomLevel, int structRow, int structCol) throws CloneNotSupportedException, CreateEnvelopeException, BufferException, ValidateDataParametersException, DataException {
|
|
| 340 | 373 |
|
| 341 |
tileStore = (RasterStore) manager.openStore(providerName, params); |
|
| 342 |
return tileStore; |
|
| 343 |
} |
|
| 374 |
RasterQuery rasterQuery = (RasterQuery) this.query.clone(); |
|
| 375 |
|
|
| 376 |
Double pixelSize = this.pixelSizePerZoomLevel.get(zoomLevel); |
|
| 377 |
rasterQuery.setPixelSize(pixelSize); |
|
| 378 |
|
|
| 379 |
GeometryManager geomManager = GeometryLocator.getGeometryManager(); |
|
| 380 |
|
|
| 381 |
double minX = structExtent.getMinimum(DIMENSIONS.X)+structCol*(pixelSize*columnsPerTile); |
|
| 382 |
double minY = structExtent.getMaximum(DIMENSIONS.Y)-((structRow+1)*(pixelSize*rowsPerTile)); |
|
| 383 |
double maxX = minX + pixelSize*columnsPerTile; |
|
| 384 |
double maxY = minY + pixelSize*rowsPerTile; |
|
| 385 |
|
|
| 386 |
Buffer buffer; |
|
| 387 |
|
|
| 388 |
// try {
|
|
| 389 |
Envelope envelope = geomManager.createEnvelope(minX, minY, maxX, maxY, SUBTYPES.GEOM2D); |
|
| 390 |
// rasterQuery.setClip(envelope); |
|
| 391 |
buffer = innerProvider.createBuffer(rasterQuery); |
|
| 392 |
buffer = buffer.clip(envelope); |
|
| 393 |
buffer = buffer.createInterpolated((int)(buffer.getPixelSizeY()*buffer.getRows()/pixelSize), (int)(buffer.getPixelSizeX()*buffer.getColumns()/pixelSize), Buffer.INTERPOLATION_NearestNeighbour, null); |
|
| 394 |
// } catch (LocatorException | BufferException | CreateEnvelopeException e) {
|
|
| 395 |
// logger.warn("Can't get tile file zoomLevel = "+zoomLevel+", structRow = "+structRow+", structColumn = "+structCol+".", e);
|
|
| 396 |
// throw new RuntimeException("Can't get tile file zoomLevel = "+zoomLevel+", structRow = "+structRow+", structColumn = "+structCol+".", e);
|
|
| 397 |
// } |
|
| 398 |
|
|
| 399 |
String providerName = "GTiff"; |
|
| 400 |
String extension = "tif"; |
|
| 401 |
|
|
| 402 |
DataManagerProviderServices manager = DALSPILocator.getDataManagerProviderServices(); |
|
| 403 |
DataServerExplorerParameters eparams; |
|
| 404 |
eparams = manager.createServerExplorerParameters("FilesystemExplorer");
|
|
| 405 |
|
|
| 406 |
int count = 0; |
|
| 407 |
StringBuilder builder = new StringBuilder(); |
|
| 408 |
builder.append(tilesFolder); |
|
| 409 |
builder.append(File.separator); |
|
| 410 |
builder.append(zoomLevel); |
|
| 411 |
builder.append(File.separator); |
|
| 412 |
builder.append(structCol); |
|
| 413 |
builder.append(File.separator); |
|
| 414 |
builder.append(structRow); |
|
| 415 |
builder.append(".");
|
|
| 416 |
builder.append(extension); |
|
| 417 |
String path = builder.toString(); |
|
| 418 |
File destFile = new File(path); |
|
| 419 |
File parent = destFile.getParentFile(); |
|
| 420 |
if(!parent.exists()){
|
|
| 421 |
parent.mkdirs(); |
|
| 344 | 422 |
} |
| 345 |
return null; |
|
| 423 |
eparams.setDynValue("initialpath", path);
|
|
| 424 |
DataServerExplorer serverExplorer = manager.createServerExplorer(eparams); |
|
| 425 |
|
|
| 426 |
NewRasterStoreParameters params = (NewRasterStoreParameters) serverExplorer.getAddParameters(providerName); |
|
| 427 |
params.setDynValue("file", destFile);
|
|
| 428 |
|
|
| 429 |
params.setDynValue("compress", "NONE");
|
|
| 430 |
params.setDynValue("tfw", false);
|
|
| 431 |
params.setDynValue("photometric", "RGB");
|
|
| 432 |
params.setDynValue("alpha", "NON-PREMULTIPLIED");
|
|
| 433 |
|
|
| 434 |
params.setBuffer(buffer); |
|
| 435 |
serverExplorer.add(providerName, params, true); |
|
| 436 |
|
|
| 437 |
return destFile; |
|
| 346 | 438 |
} |
| 347 | 439 |
|
| 348 | 440 |
/** |
| 349 | 441 |
* @return delegatedRasterStore |
| 350 |
* @throws ProviderNotRegisteredException |
|
| 351 |
* @throws InitializeException |
|
| 442 |
* @throws CloneNotSupportedException |
|
| 352 | 443 |
* @throws ValidateDataParametersException |
| 444 |
* @throws DataException |
|
| 445 |
* @throws BufferException |
|
| 446 |
* @throws CreateEnvelopeException |
|
| 353 | 447 |
*/ |
| 354 |
private RasterStore getDelegatedRasterStore() throws ValidateDataParametersException, InitializeException, ProviderNotRegisteredException{
|
|
| 448 |
private RasterStore getDelegatedRasterStore() throws ValidateDataParametersException, CreateEnvelopeException, BufferException, DataException, CloneNotSupportedException {
|
|
| 355 | 449 |
int[] structRowCol = calculateStructRowCol(pixelSizePerZoomLevel.firstKey(), 0, 0); |
| 356 | 450 |
return createTileStore(0, structRowCol[0], structRowCol[1]); |
| 357 | 451 |
} |
| ... | ... | |
| 359 | 453 |
|
| 360 | 454 |
/** |
| 361 | 455 |
* @return the band number |
| 456 |
* @throws CloneNotSupportedException |
|
| 457 |
* @throws ValidateDataParametersException |
|
| 458 |
* @throws DataException |
|
| 459 |
* @throws BufferException |
|
| 460 |
* @throws CreateEnvelopeException |
|
| 461 |
* @throws DynMethodException |
|
| 362 | 462 |
*/ |
| 363 |
public int getBandNumber(){
|
|
| 463 |
public int getBandNumber() throws ValidateDataParametersException, CreateEnvelopeException, BufferException, DataException, CloneNotSupportedException {
|
|
| 364 | 464 |
if(this.bandNumber == null){
|
| 365 |
fillBandsInfo();
|
|
| 465 |
fillStoreInfo();
|
|
| 366 | 466 |
} |
| 367 | 467 |
return this.bandNumber; |
| 368 | 468 |
} |
| 369 | 469 |
|
| 370 | 470 |
/** |
| 371 | 471 |
* @return the data types |
| 472 |
* @throws CloneNotSupportedException |
|
| 473 |
* @throws ValidateDataParametersException |
|
| 474 |
* @throws DataException |
|
| 475 |
* @throws BufferException |
|
| 476 |
* @throws CreateEnvelopeException |
|
| 477 |
* @throws DynMethodException |
|
| 372 | 478 |
*/ |
| 373 |
public int[] getDataTypes(){
|
|
| 479 |
public int[] getDataTypes() throws ValidateDataParametersException, CreateEnvelopeException, BufferException, DataException, CloneNotSupportedException {
|
|
| 374 | 480 |
if(this.dataTypes == null){
|
| 375 |
fillBandsInfo();
|
|
| 481 |
fillStoreInfo();
|
|
| 376 | 482 |
} |
| 377 | 483 |
return this.dataTypes; |
| 378 | 484 |
} |
| 379 | 485 |
|
| 380 | 486 |
/** |
| 487 |
* @throws CloneNotSupportedException |
|
| 488 |
* @throws ValidateDataParametersException |
|
| 489 |
* @throws DynMethodException |
|
| 490 |
* @throws DataException |
|
| 491 |
* @throws BufferException |
|
| 492 |
* @throws CreateEnvelopeException |
|
| 381 | 493 |
* |
| 382 | 494 |
*/ |
| 383 |
private void fillBandsInfo() {
|
|
| 495 |
private void fillStoreInfo() throws ValidateDataParametersException, CreateEnvelopeException, BufferException, DataException, CloneNotSupportedException {
|
|
| 384 | 496 |
RasterStore rasterStore = null; |
| 385 | 497 |
try {
|
| 386 | 498 |
rasterStore = getDelegatedRasterStore(); |
| ... | ... | |
| 389 | 501 |
for (int i=0;i<this.bandNumber;i++){
|
| 390 | 502 |
dataTypes[i]=rasterStore.getBandInfo(i).getDataType(); |
| 391 | 503 |
} |
| 392 |
} catch (ValidateDataParametersException | InitializeException | ProviderNotRegisteredException e) {
|
|
| 393 |
logger.warn("Can't get the delegated raster store", e);
|
|
| 504 |
try {
|
|
| 505 |
this.colorInterpretation = |
|
| 506 |
rasterStore.invokeDynMethod(RasterStore.DYNMETHOD_GETCOLORINTERPRETATION_NAME, null); |
|
| 507 |
this.colorTable = rasterStore.invokeDynMethod(RasterStore.DYNMETHOD_GETCOLORTABLE_NAME, null); |
|
| 508 |
this.legend = rasterStore.invokeDynMethod(RasterStore.DYNMETHOD_GETLEGEND_NAME, null); |
|
| 509 |
} catch (DynMethodException e) {
|
|
| 510 |
logger.warn("Can't fill legend info from store.");
|
|
| 511 |
} |
|
| 512 |
|
|
| 394 | 513 |
} finally {
|
| 395 | 514 |
if(rasterStore != null){
|
| 396 | 515 |
rasterStore.dispose(); |
| ... | ... | |
| 404 | 523 |
* @return rows per zoom level |
| 405 | 524 |
*/ |
| 406 | 525 |
public int getRows(int zoomLevel){
|
| 407 |
return (int)(getEnvelopePerZoomLevel(zoomLevel).getLength(DIMENSIONS.Y)/pixelSizePerZoomLevel.get(zoomLevel));
|
|
| 526 |
return (int)(getEnvelope().getLength(DIMENSIONS.Y)/pixelSizePerZoomLevel.get(zoomLevel));
|
|
| 408 | 527 |
} |
| 409 | 528 |
|
| 410 | 529 |
/** |
| ... | ... | |
| 412 | 531 |
* @return columns per zoom level |
| 413 | 532 |
*/ |
| 414 | 533 |
public int getColumns(int zoomLevel){
|
| 415 |
return (int)(getEnvelopePerZoomLevel(zoomLevel).getLength(DIMENSIONS.X)/pixelSizePerZoomLevel.get(zoomLevel));
|
|
| 534 |
return (int)(this.getEnvelope().getLength(DIMENSIONS.X)/pixelSizePerZoomLevel.get(zoomLevel));
|
|
| 416 | 535 |
} |
| 417 | 536 |
|
| 418 | 537 |
/** |
| 419 |
* @param zoomLevel |
|
| 420 | 538 |
* @return envelope per zoom level |
| 421 | 539 |
*/ |
| 422 |
public Envelope getEnvelopePerZoomLevel(int zoomLevel){
|
|
| 423 |
Envelope envelope = envelopePerZoomLevel.get(zoomLevel); |
|
| 424 |
if(envelope==null){
|
|
| 540 |
public Envelope getEnvelope(){
|
|
| 541 |
// Envelope envelope = null; |
|
| 542 |
|
|
| 543 |
// if(envelopePerZoomLevel != null){
|
|
| 544 |
// envelope = envelopePerZoomLevel.get(zoomLevel); |
|
| 545 |
// } |
|
| 546 |
|
|
| 547 |
// if(envelope == null){
|
|
| 425 | 548 |
return structExtent; |
| 426 |
} |
|
| 427 |
return envelope; |
|
| 549 |
// } |
|
| 550 |
// |
|
| 551 |
// return envelope; |
|
| 428 | 552 |
} |
| 429 | 553 |
|
| 430 | 554 |
/** |
| ... | ... | |
| 474 | 598 |
/** |
| 475 | 599 |
* @return the color interpretation |
| 476 | 600 |
* @throws DynMethodException |
| 601 |
* @throws CloneNotSupportedException |
|
| 602 |
* @throws ValidateDataParametersException |
|
| 603 |
* @throws DataException |
|
| 604 |
* @throws BufferException |
|
| 605 |
* @throws CreateEnvelopeException |
|
| 477 | 606 |
*/ |
| 478 |
public Object getColorInterpretation() throws DynMethodException {
|
|
| 607 |
public Object getColorInterpretation() throws DynMethodException, ValidateDataParametersException, CreateEnvelopeException, BufferException, DataException, CloneNotSupportedException {
|
|
| 479 | 608 |
if(this.colorInterpretation == null){
|
| 480 |
RasterStore delegatedRasterStore = null; |
|
| 481 |
try {
|
|
| 482 |
delegatedRasterStore = getDelegatedRasterStore(); |
|
| 483 |
} catch (ValidateDataParametersException | InitializeException | ProviderNotRegisteredException e) {
|
|
| 484 |
logger.warn("Can't get raster store", e);
|
|
| 485 |
} |
|
| 486 |
if (delegatedRasterStore != null) {
|
|
| 487 |
this.colorInterpretation = |
|
| 488 |
delegatedRasterStore.invokeDynMethod(RasterStore.DYNMETHOD_GETCOLORINTERPRETATION_NAME, null); |
|
| 489 |
} |
|
| 609 |
fillStoreInfo(); |
|
| 490 | 610 |
} |
| 491 | 611 |
return this.colorInterpretation; |
| 492 | 612 |
} |
| ... | ... | |
| 495 | 615 |
* @return the color table |
| 496 | 616 |
* @throws ValidateDataParametersException |
| 497 | 617 |
* @throws DynMethodException |
| 618 |
* @throws CloneNotSupportedException |
|
| 619 |
* @throws DataException |
|
| 620 |
* @throws BufferException |
|
| 621 |
* @throws CreateEnvelopeException |
|
| 498 | 622 |
* @throws InitializeException |
| 499 | 623 |
* @throws ProviderNotRegisteredException |
| 500 | 624 |
*/ |
| 501 |
public Object getColorTable() throws DynMethodException {
|
|
| 625 |
public Object getColorTable() throws DynMethodException, ValidateDataParametersException, CreateEnvelopeException, BufferException, DataException, CloneNotSupportedException {
|
|
| 502 | 626 |
if (this.colorTable == null) {
|
| 503 |
|
|
| 504 |
RasterStore delegatedRasterStore = null; |
|
| 505 |
try {
|
|
| 506 |
delegatedRasterStore = getDelegatedRasterStore(); |
|
| 507 |
} catch (ValidateDataParametersException | InitializeException | ProviderNotRegisteredException e) {
|
|
| 508 |
logger.warn("Can't get raster store {}.", e);
|
|
| 509 |
} |
|
| 510 |
if (delegatedRasterStore != null) {
|
|
| 511 |
this.colorTable = delegatedRasterStore.invokeDynMethod(RasterStore.DYNMETHOD_GETCOLORTABLE_NAME, null); |
|
| 512 |
} |
|
| 627 |
fillStoreInfo(); |
|
| 513 | 628 |
} |
| 514 | 629 |
return this.colorTable; |
| 515 | 630 |
} |
| ... | ... | |
| 518 | 633 |
* @return the legend |
| 519 | 634 |
* @throws ValidateDataParametersException |
| 520 | 635 |
* @throws DynMethodException |
| 636 |
* @throws CloneNotSupportedException |
|
| 637 |
* @throws DataException |
|
| 638 |
* @throws BufferException |
|
| 639 |
* @throws CreateEnvelopeException |
|
| 521 | 640 |
* @throws InitializeException |
| 522 | 641 |
* @throws ProviderNotRegisteredException |
| 523 | 642 |
*/ |
| 524 |
public Object getLegend() throws DynMethodException{
|
|
| 643 |
public Object getLegend() throws DynMethodException, ValidateDataParametersException, CreateEnvelopeException, BufferException, DataException, CloneNotSupportedException {
|
|
| 525 | 644 |
if(this.legend == null){
|
| 526 |
RasterStore delegatedRasterStore = null; |
|
| 527 |
try {
|
|
| 528 |
delegatedRasterStore = getDelegatedRasterStore(); |
|
| 529 |
} catch (ValidateDataParametersException | InitializeException | ProviderNotRegisteredException e) {
|
|
| 530 |
logger.warn("Can't get raster store {}.", e);
|
|
| 531 |
} |
|
| 532 |
if (delegatedRasterStore != null) {
|
|
| 533 |
this.legend = delegatedRasterStore.invokeDynMethod(RasterStore.DYNMETHOD_GETLEGEND_NAME, null); |
|
| 534 |
} |
|
| 645 |
fillStoreInfo(); |
|
| 535 | 646 |
} |
| 536 | 647 |
return this.legend; |
| 537 | 648 |
} |
| 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/TileCacheLibrary.java | ||
|---|---|---|
| 43 | 43 |
*/ |
| 44 | 44 |
public class TileCacheLibrary extends AbstractLibrary {
|
| 45 | 45 |
|
| 46 |
public static int DEFAULT_LEVELS = 25; |
|
| 47 |
public static int DEFAULT_TILEWIDTH = 256; |
|
| 48 |
public static int DEFAULT_TILEHEIGHT = 256; |
|
| 49 |
|
|
| 50 |
|
|
| 46 | 51 |
@Override |
| 47 | 52 |
public void doRegistration() {
|
| 48 | 53 |
registerAsServiceOf(DALLibrary.class); |
| 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 | ||
|---|---|---|
| 37 | 37 |
import org.gvsig.fmap.dal.DataStoreNotification; |
| 38 | 38 |
import org.gvsig.fmap.dal.FileHelper; |
| 39 | 39 |
import org.gvsig.fmap.dal.exception.CloseException; |
| 40 |
import org.gvsig.fmap.dal.exception.DataException; |
|
| 40 | 41 |
import org.gvsig.fmap.dal.exception.InitializeException; |
| 41 | 42 |
import org.gvsig.fmap.dal.exception.OpenException; |
| 42 | 43 |
import org.gvsig.fmap.dal.exception.ReadException; |
| ... | ... | |
| 45 | 46 |
import org.gvsig.fmap.dal.raster.api.BandDescriptor; |
| 46 | 47 |
import org.gvsig.fmap.dal.raster.api.BandQuery; |
| 47 | 48 |
import org.gvsig.fmap.dal.raster.api.RasterQuery; |
| 49 |
import org.gvsig.fmap.dal.raster.api.RasterStore; |
|
| 48 | 50 |
import org.gvsig.fmap.dal.raster.spi.AbstractRasterStoreProvider; |
| 49 |
import org.gvsig.fmap.dal.resource.ResourceAction;
|
|
| 50 |
import org.gvsig.fmap.dal.resource.exception.AccessResourceException;
|
|
| 51 |
import org.gvsig.fmap.dal.raster.spi.RasterCacheStoreProvider;
|
|
| 52 |
import org.gvsig.fmap.dal.raster.spi.RasterStoreProvider;
|
|
| 51 | 53 |
import org.gvsig.fmap.dal.resource.file.FileResource; |
| 52 | 54 |
import org.gvsig.fmap.dal.resource.spi.ResourceConsumer; |
| 53 | 55 |
import org.gvsig.fmap.dal.resource.spi.ResourceProvider; |
| 54 | 56 |
import org.gvsig.fmap.dal.spi.DataStoreProviderServices; |
| 57 |
import org.gvsig.fmap.geom.exception.CreateEnvelopeException; |
|
| 55 | 58 |
import org.gvsig.fmap.geom.primitive.Envelope; |
| 56 | 59 |
import org.gvsig.metadata.MetadataLocator; |
| 57 | 60 |
import org.gvsig.metadata.MetadataManager; |
| ... | ... | |
| 72 | 75 |
|
| 73 | 76 |
/** |
| 74 | 77 |
* Provider for Tile Cache |
| 78 |
* |
|
| 75 | 79 |
* @author dmartinezizquierdo |
| 76 | 80 |
* |
| 77 | 81 |
*/ |
| 78 |
public class TileCacheStoreProvider extends AbstractRasterStoreProvider implements |
|
| 79 |
ResourceConsumer{
|
|
| 82 |
public class TileCacheStoreProvider extends AbstractRasterStoreProvider implements RasterCacheStoreProvider,
|
|
| 83 |
ResourceConsumer {
|
|
| 80 | 84 |
|
| 81 |
private static final Logger logger = |
|
| 82 |
LoggerFactory.getLogger(TileCacheStoreProvider.class); |
|
| 85 |
private static final Logger logger = LoggerFactory.getLogger(TileCacheStoreProvider.class); |
|
| 83 | 86 |
|
| 84 | 87 |
public static String NAME = "TileCache"; |
| 85 | 88 |
public static String DESCRIPTION = "Tile cache provider"; |
| ... | ... | |
| 91 | 94 |
private TileStructImage tileStructImage = null; |
| 92 | 95 |
|
| 93 | 96 |
private Envelope envelope = null; |
| 94 |
private IProjection projection= null; |
|
| 97 |
private IProjection projection = null;
|
|
| 95 | 98 |
|
| 96 | 99 |
Map<Integer,List<PageManager>> pageManagersPerZoomLevel = null; |
| 97 | 100 |
|
| 101 |
// private RasterStore innerStore; |
|
| 98 | 102 |
|
| 99 |
protected static void registerMetadataDefinition() |
|
| 100 |
throws MetadataException {
|
|
| 103 |
private RasterStoreProvider innerProvider; |
|
| 104 |
private int bandsNumber; |
|
| 105 |
|
|
| 106 |
protected static void registerMetadataDefinition() throws MetadataException {
|
|
| 101 | 107 |
MetadataManager manager = MetadataLocator.getMetadataManager(); |
| 102 | 108 |
if (manager.getDefinition(METADATA_DEFINITION_NAME) == null) {
|
| 103 | 109 |
manager.addDefinition(METADATA_DEFINITION_NAME, |
| 104 |
TileCacheStoreProviderParameters.class |
|
| 105 |
.getResourceAsStream("TileCacheMetadata.xml"),
|
|
| 110 |
TileCacheStoreProviderParameters.class.getResourceAsStream("TileCacheMetadata.xml"),
|
|
| 106 | 111 |
TileCacheStoreProviderParameters.class.getClassLoader()); |
| 107 | 112 |
} |
| 108 | 113 |
} |
| 109 | 114 |
|
| 110 |
public TileCacheStoreProvider(TileCacheStoreProviderParameters params, |
|
| 111 |
DataStoreProviderServices storeServices) |
|
| 115 |
/** |
|
| 116 |
* @param params |
|
| 117 |
* @param storeServices |
|
| 118 |
* @throws InitializeException |
|
| 119 |
*/ |
|
| 120 |
public TileCacheStoreProvider(TileCacheStoreProviderParameters params, DataStoreProviderServices storeServices) |
|
| 112 | 121 |
throws InitializeException {
|
| 113 |
super( |
|
| 114 |
params, |
|
| 115 |
storeServices, |
|
| 116 |
FileHelper.newMetadataContainer(METADATA_DEFINITION_NAME) |
|
| 117 |
); |
|
| 122 |
super(params, storeServices, FileHelper.newMetadataContainer(METADATA_DEFINITION_NAME)); |
|
| 118 | 123 |
TaskStatusManager manager = ToolsLocator.getTaskStatusManager(); |
| 119 | 124 |
this.taskStatus = manager.createDefaultSimpleTaskStatus("TileCache");
|
| 120 | 125 |
this.init(params, storeServices); |
| 121 | 126 |
} |
| 122 | 127 |
|
| 123 |
protected TileCacheStoreProvider(TileCacheStoreProviderParameters params, |
|
| 124 |
DataStoreProviderServices storeServices, DynObject metadata) |
|
| 125 |
throws InitializeException {
|
|
| 128 |
protected TileCacheStoreProvider(TileCacheStoreProviderParameters params, DataStoreProviderServices storeServices, |
|
| 129 |
DynObject metadata) throws InitializeException {
|
|
| 126 | 130 |
super(params, storeServices, metadata); |
| 127 | 131 |
TaskStatusManager manager = ToolsLocator.getTaskStatusManager(); |
| 128 | 132 |
this.taskStatus = manager.createDefaultSimpleTaskStatus("TileCache");
|
| ... | ... | |
| 131 | 135 |
|
| 132 | 136 |
protected void init(TileCacheStoreProviderParameters params, |
| 133 | 137 |
DataStoreProviderServices storeServices) throws InitializeException {
|
| 138 |
// store = (RasterStore) storeServices.getStore(); |
|
| 139 |
bandsNumber = ((RasterStore)storeServices).getBands(); |
|
| 140 |
|
|
| 134 | 141 |
if (params == null) {
|
| 135 | 142 |
throw new InitializeException( |
| 136 | 143 |
new NullPointerException("params is null"));
|
| ... | ... | |
| 138 | 145 |
|
| 139 | 146 |
this.projection=params.getCRS(); |
| 140 | 147 |
|
| 141 |
File cacheFolder=null;
|
|
| 148 |
// String rcacheDir = Launcher.getAppHomeDir() + File.separator + "gvsig_rcache";
|
|
| 142 | 149 |
|
| 143 |
//FIXME: Get appropriate folder to cache tiles |
|
| 144 |
cacheFolder = new File("/home/paco/data/cartography/raster/tile-valencia1980");
|
|
| 145 | 150 |
|
| 151 |
// Envelope storeEnvelope = store.getEnvelope(); |
|
| 152 |
// store.getRasterSet().getPixelSizeX(); |
|
| 153 |
|
|
| 154 |
File cacheFolder = (File) params.getDynValue(TileCacheStoreProviderParameters.TILECACHE_CACHEFOLDER_PARAMTER_NAME); |
|
| 155 |
|
|
| 146 | 156 |
resource = this.createResource( |
| 147 | 157 |
FileResource.NAME, |
| 148 | 158 |
new Object[] { cacheFolder.getAbsolutePath() }
|
| ... | ... | |
| 158 | 168 |
|
| 159 | 169 |
@Override |
| 160 | 170 |
public BandDescriptor getBandDescriptor(int band) {
|
| 161 |
if(band > this.getBands()){
|
|
| 171 |
if (band > this.getBands()) {
|
|
| 162 | 172 |
throw new IllegalArgumentException("Invalid band");
|
| 163 | 173 |
} |
| 164 |
return getStoreServices().createBandDescriptor(band, |
|
| 165 |
new ArrayList<BandAttributeDescriptor>()); |
|
| 174 |
return getStoreServices().createBandDescriptor(band, new ArrayList<BandAttributeDescriptor>()); |
|
| 166 | 175 |
} |
| 167 | 176 |
|
| 168 | 177 |
@Override |
| 169 | 178 |
public int getBands() {
|
| 170 |
return tileStructImage.getBandNumber();
|
|
| 179 |
return bandsNumber;
|
|
| 171 | 180 |
} |
| 172 | 181 |
|
| 173 | 182 |
@Override |
| ... | ... | |
| 176 | 185 |
int[] bandDataTypes; |
| 177 | 186 |
List<PageManager> pageManagers = new ArrayList<PageManager>(); |
| 178 | 187 |
NoData[] bandNoData; |
| 179 |
// if (rasterQuery != null) {
|
|
| 180 |
List<BandQuery> bands;
|
|
| 181 |
bands = rasterQuery.getBands();
|
|
| 182 |
bandDataTypes = new int[bands.size()];
|
|
| 183 |
bandNoData = new NoData[bands.size()];
|
|
| 188 |
// if (rasterQuery != null) {
|
|
| 189 |
List<BandQuery> bands; |
|
| 190 |
bands = rasterQuery.getBands(); |
|
| 191 |
bandDataTypes = new int[bandsNumber];
|
|
| 192 |
bandNoData = new NoData[bandsNumber];
|
|
| 184 | 193 |
|
| 185 |
int zoomLevel = tileStructImage.getZoomLvlForPixelSize(rasterQuery.getPixelSize()); |
|
| 186 |
List<PageManager> pageManagersInZoom = getPageManagersInZoom(zoomLevel); |
|
| 187 |
for (BandQuery bandQuery : bands) {
|
|
| 188 |
//FIXME: |
|
| 189 |
int band = bandQuery.getBand(); |
|
| 190 |
bandDataTypes[band] = tileStructImage.getDataTypes()[band]; |
|
| 191 |
bandNoData[band] = null; |
|
| 192 |
pageManagers.add(pageManagersInZoom.get(band)); |
|
| 194 |
int zoomLevel = tileStructImage.getZoomLvlForPixelSize(rasterQuery.getPixelSize()); |
|
| 195 |
List<PageManager> pageManagersInZoom; |
|
| 196 |
int[] tileStructDataTypes; |
|
| 197 |
try {
|
|
| 198 |
pageManagersInZoom = getPageManagersInZoom(zoomLevel); |
|
| 199 |
tileStructDataTypes = tileStructImage.getDataTypes(); |
|
| 200 |
} catch (ValidateDataParametersException | CreateEnvelopeException | DataException | CloneNotSupportedException e) {
|
|
| 201 |
throw new BufferException(e); |
|
| 202 |
} |
|
| 203 |
try {
|
|
| 204 |
for(int i = 0; i<tileStructImage.getBandNumber(); i++){
|
|
| 205 |
bandDataTypes[i] = tileStructDataTypes[i]; |
|
| 206 |
bandNoData[i] = null; |
|
| 207 |
pageManagers.add(pageManagersInZoom.get(i)); |
|
| 193 | 208 |
} |
| 194 |
// } else {
|
|
| 195 |
// int bands = getBands(); |
|
| 196 |
// bandDataTypes = new int[bands]; |
|
| 197 |
// bandNoData = new NoData[bands]; |
|
| 198 |
// for (int i = 0; i < bands; i++) {
|
|
| 199 |
// bandDataTypes[i] = tileStructImage.getDataTypes()[i]; |
|
| 200 |
// bandNoData[i] = null; |
|
| 201 |
// pageManagers.add(new TileCacheBandPageManager(tileStructImage, rasterQuery.getPixelSize(), i)); |
|
| 202 |
// } |
|
| 209 |
} catch (ValidateDataParametersException | CreateEnvelopeException | DataException | CloneNotSupportedException e) {
|
|
| 210 |
throw new BufferException(e); |
|
| 211 |
} |
|
| 212 |
|
|
| 213 |
// for (BandQuery bandQuery : bands) {
|
|
| 214 |
// // FIXME: |
|
| 215 |
// int band = bandQuery.getBand(); |
|
| 216 |
// bandDataTypes[band] = tileStructDataTypes[band]; |
|
| 217 |
// bandNoData[band] = null; |
|
| 218 |
// pageManagers.add(pageManagersInZoom.get(band)); |
|
| 203 | 219 |
// } |
| 204 |
envelope=tileStructImage.getEnvelopePerZoomLevel(zoomLevel); |
|
| 220 |
// } else {
|
|
| 221 |
// int bands = getBands(); |
|
| 222 |
// bandDataTypes = new int[bands]; |
|
| 223 |
// bandNoData = new NoData[bands]; |
|
| 224 |
// for (int i = 0; i < bands; i++) {
|
|
| 225 |
// bandDataTypes[i] = tileStructImage.getDataTypes()[i]; |
|
| 226 |
// bandNoData[i] = null; |
|
| 227 |
// pageManagers.add(new TileCacheBandPageManager(tileStructImage, |
|
| 228 |
// rasterQuery.getPixelSize(), i)); |
|
| 229 |
// } |
|
| 230 |
// } |
|
| 231 |
envelope = tileStructImage.getEnvelope(); |
|
| 205 | 232 |
Buffer buffer = |
| 206 |
bufferManager.createBuffer(tileStructImage.getRows(zoomLevel), tileStructImage.getColumns(zoomLevel), bandDataTypes, bandNoData,
|
|
| 207 |
projection, envelope, pageManagers); |
|
| 233 |
bufferManager.createBuffer(tileStructImage.getRows(zoomLevel), tileStructImage.getColumns(zoomLevel), |
|
| 234 |
bandDataTypes, bandNoData, projection, envelope, pageManagers);
|
|
| 208 | 235 |
|
| 209 | 236 |
return buffer; |
| 210 | 237 |
} |
| 211 | 238 |
|
| 212 |
private List<PageManager> getPageManagersInZoom(int zoomLevel) {
|
|
| 239 |
private List<PageManager> getPageManagersInZoom(int zoomLevel) throws ValidateDataParametersException, CreateEnvelopeException, BufferException, DataException, CloneNotSupportedException {
|
|
| 213 | 240 |
List<PageManager> pageManagersInZoom = this.pageManagersPerZoomLevel.get(zoomLevel); |
| 214 | 241 |
if (pageManagersInZoom == null) {
|
| 215 | 242 |
pageManagersInZoom = new ArrayList<PageManager>(); |
| ... | ... | |
| 221 | 248 |
return pageManagersInZoom; |
| 222 | 249 |
} |
| 223 | 250 |
|
| 224 |
|
|
| 225 | 251 |
@Override |
| 226 | 252 |
public BandInfo getBandInfo(int band) {
|
| 227 |
//FIXME |
|
| 228 |
return null;//tileStructImage.getBandInfo(band); |
|
| 253 |
// FIXME
|
|
| 254 |
return null;// tileStructImage.getBandInfo(band);
|
|
| 229 | 255 |
} |
| 230 | 256 |
|
| 231 | 257 |
@Override |
| 232 |
public DataServerExplorer getExplorer() |
|
| 233 |
throws ReadException, ValidateDataParametersException {
|
|
| 234 |
// DataManager manager = DALLocator.getDataManager();
|
|
| 235 |
// FilesystemServerExplorerParameters params;
|
|
| 236 |
// try {
|
|
| 237 |
// params = (FilesystemServerExplorerParameters) manager
|
|
| 238 |
// .createServerExplorerParameters(FilesystemServerExplorer.NAME);
|
|
| 239 |
// params.setRoot(this.getTileCacheParameters().getFile().getParent());
|
|
| 240 |
// return manager.openServerExplorer(FilesystemServerExplorer.NAME,params);
|
|
| 241 |
// } catch (DataException e) {
|
|
| 242 |
// throw new ReadException(this.getProviderName(), e);
|
|
| 243 |
// } catch (ValidateDataParametersException e) {
|
|
| 244 |
// throw new ReadException(this.getProviderName(), e);
|
|
| 245 |
// }
|
|
| 246 |
//FIXME |
|
| 258 |
public DataServerExplorer getExplorer() throws ReadException, ValidateDataParametersException {
|
|
| 259 |
// DataManager manager = DALLocator.getDataManager();
|
|
| 260 |
// FilesystemServerExplorerParameters params;
|
|
| 261 |
// try {
|
|
| 262 |
// params = (FilesystemServerExplorerParameters) manager
|
|
| 263 |
// .createServerExplorerParameters(FilesystemServerExplorer.NAME);
|
|
| 264 |
// params.setRoot(this.getTileCacheParameters().getFile().getParent());
|
|
| 265 |
// return
|
|
| 266 |
// manager.openServerExplorer(FilesystemServerExplorer.NAME,params);
|
|
| 267 |
// } catch (DataException e) {
|
|
| 268 |
// throw new ReadException(this.getProviderName(), e);
|
|
| 269 |
// } catch (ValidateDataParametersException e) {
|
|
| 270 |
// throw new ReadException(this.getProviderName(), e);
|
|
| 271 |
// }
|
|
| 272 |
// FIXME
|
|
| 247 | 273 |
return null; |
| 248 | 274 |
} |
| 249 | 275 |
|
| ... | ... | |
| 251 | 277 |
if (this.tileStructImage != null) {
|
| 252 | 278 |
return; |
| 253 | 279 |
} |
| 254 |
openEver(); |
|
| 280 |
// openEver();
|
|
| 255 | 281 |
} |
| 256 | 282 |
|
| 257 |
private void openEver() throws OpenException {
|
|
| 258 |
try {
|
|
| 259 |
|
|
| 260 |
getResource().execute(new ResourceAction() {
|
|
| 261 |
|
|
| 262 |
public Object run() throws Exception {
|
|
| 263 |
|
|
| 264 |
try {
|
|
| 265 |
File folder = (File) resource.get(); |
|
| 266 |
resource.notifyOpen(); |
|
| 267 |
|
|
| 268 |
//FIXME |
|
| 269 |
tileStructImage = new TileStructImage(folder,getTileCacheParameters().getCRS()); |
|
| 270 |
pageManagersPerZoomLevel = new HashMap<Integer, List<PageManager>>(); |
|
| 271 |
|
|
| 272 |
// if (getTileCacheParameters().getWldParams()!=null){
|
|
| 273 |
// envelope=createWLDEnvelope(getTileCacheParameters().getWldParams()); |
|
| 274 |
// }else{
|
|
| 275 |
// envelope = |
|
| 276 |
// GeometryLocator.getGeometryManager().createEnvelope(0, 0, |
|
| 277 |
// tileStructImage.getColumns(), tileStructImage.getRows(), Geometry.SUBTYPES.GEOM2D); |
|
| 278 |
// } |
|
| 279 |
|
|
| 280 |
resource.notifyClose(); |
|
| 281 |
|
|
| 282 |
resource.setData(tileStructImage); |
|
| 283 |
} finally {
|
|
| 284 |
//TODO |
|
| 285 |
} |
|
| 286 |
return null; |
|
| 287 |
} |
|
| 288 |
|
|
| 289 |
}); |
|
| 290 |
} catch (Exception e) {
|
|
| 291 |
this.tileStructImage = null; |
|
| 292 |
try {
|
|
| 293 |
throw new OpenException(resource.getName(), e); |
|
| 294 |
} catch (AccessResourceException e1) {
|
|
| 295 |
throw new OpenException(getProviderName(), e); |
|
| 296 |
} |
|
| 297 |
} finally {
|
|
| 298 |
this.taskStatus.remove(); |
|
| 299 |
} |
|
| 300 |
} |
|
| 301 |
|
|
| 302 |
// private Envelope createWLDEnvelope(List<String> wldParams){
|
|
| 303 |
// double pixelSizeX=Double.valueOf(wldParams.get(0)); |
|
| 304 |
// double rotationAxisY = Double.valueOf(wldParams.get(1)); |
|
| 305 |
// double rotationAxisX = Double.valueOf(wldParams.get(2)); |
|
| 306 |
// double pixelSizeY = Double.valueOf(wldParams.get(3)); |
|
| 307 |
// double upperLeftPixelCenterCoordX = Double.valueOf(wldParams.get(4)); |
|
| 308 |
// double upperLeftPixelCenterCoordY = Double.valueOf(wldParams.get(5)); |
|
| 283 |
// private void openEver() throws OpenException {
|
|
| 284 |
// try {
|
|
| 309 | 285 |
// |
| 310 |
// if (0.0 != rotationAxisX || 0.0 != rotationAxisY) {
|
|
| 311 |
// logger.warn( |
|
| 312 |
// "Rotation in wld file not implemented yet. It will be ignored"); |
|
| 313 |
// } |
|
| 286 |
// getResource().execute(new ResourceAction() {
|
|
| 314 | 287 |
// |
| 315 |
// double leftMostX = upperLeftPixelCenterCoordX - (pixelSizeX * 0.5); |
|
| 316 |
// double upperMostY = upperLeftPixelCenterCoordY - (pixelSizeY * 0.5); |
|
| 317 |
// double height=tileStructImage.getRows()*pixelSizeY; |
|
| 318 |
// double width=tileStructImage.getColumns()*pixelSizeX; |
|
| 288 |
// public Object run() throws Exception {
|
|
| 319 | 289 |
// |
| 320 |
// // double minX, double minY, double maxX, double maxY, int subType |
|
| 321 |
// try {
|
|
| 322 |
// envelope = GeometryLocator.getGeometryManager().createEnvelope( |
|
| 323 |
// Math.min(leftMostX,leftMostX + width), |
|
| 324 |
// Math.min(upperMostY,upperMostY + height), |
|
| 325 |
// Math.max(leftMostX,leftMostX + width), |
|
| 326 |
// Math.max(upperMostY,upperMostY + height), |
|
| 327 |
// Geometry.SUBTYPES.GEOM2D); |
|
| 328 |
// } catch (LocatorException | CreateEnvelopeException e) {
|
|
| 329 |
// logger.warn( |
|
| 330 |
// "Failed to create envelope from wld file with coords: minx:"+leftMostX+ |
|
| 331 |
// ", miny:"+upperMostY+", maxX: "+leftMostX + width+", maxY: "+upperMostY + height); |
|
| 332 |
// e.printStackTrace(); |
|
| 290 |
// try {
|
|
| 291 |
// File folder = (File) resource.get(); |
|
| 292 |
// resource.notifyOpen(); |
|
| 293 |
// |
|
| 294 |
// // FIXME |
|
| 295 |
// tileStructImage = new TileStructImage(folder, getTileCacheParameters().getCRS(), null); |
|
| 296 |
// pageManagersPerZoomLevel = new HashMap<Integer, List<PageManager>>(); |
|
| 297 |
// |
|
| 298 |
// // if (getTileCacheParameters().getWldParams()!=null){
|
|
| 299 |
// // envelope=createWLDEnvelope(getTileCacheParameters().getWldParams()); |
|
| 300 |
// // }else{
|
|
| 301 |
// // envelope = |
|
| 302 |
// // GeometryLocator.getGeometryManager().createEnvelope(0, |
|
| 303 |
// // 0, |
|
| 304 |
// // tileStructImage.getColumns(), |
|
| 305 |
// // tileStructImage.getRows(), Geometry.SUBTYPES.GEOM2D); |
|
| 306 |
// // } |
|
| 307 |
// |
|
| 308 |
// resource.notifyClose(); |
|
| 309 |
// |
|
| 310 |
// resource.setData(tileStructImage); |
|
| 311 |
// } finally {
|
|
| 312 |
// // TODO |
|
| 313 |
// } |
|
| 314 |
// return null; |
|
| 315 |
// } |
|
| 316 |
// |
|
| 317 |
// }); |
|
| 318 |
// } catch (Exception e) {
|
|
| 319 |
// this.tileStructImage = null; |
|
| 320 |
// try {
|
|
| 321 |
// throw new OpenException(resource.getName(), e); |
|
| 322 |
// } catch (AccessResourceException e1) {
|
|
| 323 |
// throw new OpenException(getProviderName(), e); |
|
| 324 |
// } |
|
| 325 |
// } finally {
|
|
| 326 |
// this.taskStatus.remove(); |
|
| 333 | 327 |
// } |
| 334 |
// |
|
| 335 |
// return envelope; |
|
| 336 | 328 |
// } |
| 337 | 329 |
|
| 330 |
// private Envelope createWLDEnvelope(List<String> wldParams){
|
|
| 331 |
// double pixelSizeX=Double.valueOf(wldParams.get(0)); |
|
| 332 |
// double rotationAxisY = Double.valueOf(wldParams.get(1)); |
|
| 333 |
// double rotationAxisX = Double.valueOf(wldParams.get(2)); |
|
| 334 |
// double pixelSizeY = Double.valueOf(wldParams.get(3)); |
|
| 335 |
// double upperLeftPixelCenterCoordX = Double.valueOf(wldParams.get(4)); |
|
| 336 |
// double upperLeftPixelCenterCoordY = Double.valueOf(wldParams.get(5)); |
|
| 337 |
// |
|
| 338 |
// if (0.0 != rotationAxisX || 0.0 != rotationAxisY) {
|
|
| 339 |
// logger.warn( |
|
| 340 |
// "Rotation in wld file not implemented yet. It will be ignored"); |
|
| 341 |
// } |
|
| 342 |
// |
|
| 343 |
// double leftMostX = upperLeftPixelCenterCoordX - (pixelSizeX * 0.5); |
|
| 344 |
// double upperMostY = upperLeftPixelCenterCoordY - (pixelSizeY * 0.5); |
|
| 345 |
// double height=tileStructImage.getRows()*pixelSizeY; |
|
| 346 |
// double width=tileStructImage.getColumns()*pixelSizeX; |
|
| 347 |
// |
|
| 348 |
// // double minX, double minY, double maxX, double maxY, int subType |
|
| 349 |
// try {
|
|
| 350 |
// envelope = GeometryLocator.getGeometryManager().createEnvelope( |
|
| 351 |
// Math.min(leftMostX,leftMostX + width), |
|
| 352 |
// Math.min(upperMostY,upperMostY + height), |
|
| 353 |
// Math.max(leftMostX,leftMostX + width), |
|
| 354 |
// Math.max(upperMostY,upperMostY + height), |
|
| 355 |
// Geometry.SUBTYPES.GEOM2D); |
|
| 356 |
// } catch (LocatorException | CreateEnvelopeException e) {
|
|
| 357 |
// logger.warn( |
|
| 358 |
// "Failed to create envelope from wld file with coords: minx:"+leftMostX+ |
|
| 359 |
// ", miny:"+upperMostY+", maxX: "+leftMostX + width+", maxY: "+upperMostY + |
|
| 360 |
// height); |
|
| 361 |
// e.printStackTrace(); |
|
| 362 |
// } |
|
| 363 |
// |
|
| 364 |
// return envelope; |
|
| 365 |
// } |
|
| 366 |
|
|
| 338 | 367 |
@Override |
| 339 | 368 |
public Object getDynValue(String name) throws DynFieldNotFoundException {
|
| 340 |
if( DataStore.METADATA_ENVELOPE.equalsIgnoreCase(name) ) {
|
|
| 369 |
if (DataStore.METADATA_ENVELOPE.equalsIgnoreCase(name)) {
|
|
| 341 | 370 |
return this.envelope; |
| 342 |
} else if( DataStore.METADATA_CRS.equalsIgnoreCase(name) ) {
|
|
| 371 |
} else if (DataStore.METADATA_CRS.equalsIgnoreCase(name)) {
|
|
| 343 | 372 |
IProjection pro = this.getTileCacheParameters().getCRS(); |
| 344 | 373 |
if (pro != null) {
|
| 345 | 374 |
return pro; |
| ... | ... | |
| 358 | 387 |
return this.resource; |
| 359 | 388 |
} |
| 360 | 389 |
|
| 361 |
|
|
| 362 | 390 |
@Override |
| 363 | 391 |
public Object getSourceId() {
|
| 364 |
return this.getTileCacheParameters().getName();
|
|
| 392 |
return this.getTileCacheParameters().getCacheFolder();
|
|
| 365 | 393 |
} |
| 366 | 394 |
|
| 367 | 395 |
@Override |
| ... | ... | |
| 371 | 399 |
|
| 372 | 400 |
@Override |
| 373 | 401 |
public String getName() {
|
| 374 |
String name = this.getTileCacheParameters().getName(); |
|
| 375 |
return name; //FilenameUtils.getBaseName(name); |
|
| 402 |
String name = this.getTileCacheParameters().getCacheFolder().getName();
|
|
| 403 |
return name; // FilenameUtils.getBaseName(name);
|
|
| 376 | 404 |
|
| 377 | 405 |
} |
| 378 | 406 |
|
| 379 | 407 |
@Override |
| 380 | 408 |
public String getFullName() {
|
| 381 |
return this.getTileCacheParameters().getName();
|
|
| 409 |
return this.getTileCacheParameters().getCacheFolder().getAbsolutePath();
|
|
| 382 | 410 |
} |
| 383 | 411 |
|
| 384 | 412 |
@Override |
| ... | ... | |
| 395 | 423 |
* gvsig.fmap.dal.resource.spi.ResourceProvider) |
| 396 | 424 |
*/ |
| 397 | 425 |
public void resourceChanged(ResourceProvider resource) {
|
| 398 |
this.getStoreServices().notifyChange( |
|
| 399 |
DataStoreNotification.RESOURCE_CHANGED, |
|
| 400 |
resource); |
|
| 426 |
this.getStoreServices().notifyChange(DataStoreNotification.RESOURCE_CHANGED, resource); |
|
| 401 | 427 |
} |
| 402 | 428 |
|
| 403 | 429 |
@Override |
| 404 |
/* (non-Javadoc) |
|
| 405 |
* @see org.gvsig.fmap.dal.feature.spi.memory.AbstractMemoryStoreProvider#doDispose() |
|
| 430 |
/* |
|
| 431 |
* (non-Javadoc) |
|
| 432 |
* |
|
| 433 |
* @see |
|
| 434 |
* org.gvsig.fmap.dal.feature.spi.memory.AbstractMemoryStoreProvider#doDispose |
|
| 435 |
* () |
|
| 406 | 436 |
*/ |
| 407 | 437 |
protected void doDispose() throws BaseException {
|
| 408 | 438 |
super.doDispose(); |
| 409 | 439 |
resource.removeConsumer(this); |
| 410 | 440 |
} |
| 411 | 441 |
|
| 442 |
/** |
|
| 443 |
* @return TileStructImage |
|
| 444 |
*/ |
|
| 412 | 445 |
public TileStructImage getTileStructImage() {
|
| 413 | 446 |
return tileStructImage; |
| 414 | 447 |
} |
| 448 |
|
|
| 449 |
@Override |
|
| 450 |
public void apply(RasterStoreProvider provider, IProjection crs, RasterQuery query) throws DataException {
|
|
| 451 |
|
|
| 452 |
this.innerProvider = provider; |
|
| 453 |
pageManagersPerZoomLevel = new HashMap<Integer, List<PageManager>>(); |
|
| 454 |
|
|
| 455 |
this.tileStructImage = |
|
| 456 |
new TileStructImage(((FileResource)resource).getFile(), crs, provider, query); |
|
| 457 |
} |
|
| 458 |
|
|
| 459 |
@Override |
|
| 460 |
public RasterStoreProvider getInnerProvider() {
|
|
| 461 |
return innerProvider; |
|
| 462 |
} |
|
| 415 | 463 |
} |
| 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/TileCacheStoreProviderParameters.java | ||
|---|---|---|
| 43 | 43 |
import org.slf4j.LoggerFactory; |
| 44 | 44 |
|
| 45 | 45 |
/** |
| 46 |
* Parameters to create a JIMI Provider
|
|
| 46 |
* Parameters to create a TileCache Provider
|
|
| 47 | 47 |
* @author dmartinezizquierdo |
| 48 | 48 |
* |
| 49 | 49 |
*/ |
| ... | ... | |
| 53 | 53 |
private static final Logger logger = LoggerFactory.getLogger(TileCacheStoreProviderParameters.class); |
| 54 | 54 |
|
| 55 | 55 |
public static final String PARAMETERS_DEFINITION_NAME = "TileCacheStoreProviderParameters"; |
| 56 |
public static final String TILECACHE_NAME_PARAMTER_NAME = "name";
|
|
| 56 |
public static final String TILECACHE_CACHEFOLDER_PARAMTER_NAME = "cacheFolder";
|
|
| 57 | 57 |
public static final String CRS_PARAMTER_NAME = "crs"; |
| 58 | 58 |
public static final String WLD_PARAMS_NAME= "wldParams"; |
| 59 | 59 |
|
| ... | ... | |
| 90 | 90 |
|
| 91 | 91 |
@Override |
| 92 | 92 |
public boolean isValid() {
|
| 93 |
return (this.getName() != null);
|
|
| 93 |
return (this.getCacheFolder() != null);
|
|
| 94 | 94 |
} |
| 95 | 95 |
|
| 96 | 96 |
@Override |
| ... | ... | |
| 98 | 98 |
return this.getDynClass().getDescription(); |
| 99 | 99 |
} |
| 100 | 100 |
|
| 101 |
public String getName() {
|
|
| 102 |
return (String) this.getDynValue(TILECACHE_NAME_PARAMTER_NAME);
|
|
| 101 |
public File getCacheFolder() {
|
|
| 102 |
return (File) this.getDynValue(TILECACHE_CACHEFOLDER_PARAMTER_NAME);
|
|
| 103 | 103 |
} |
| 104 | 104 |
|
| 105 |
public void setName(String name) {
|
|
| 106 |
this.setDynValue(TILECACHE_NAME_PARAMTER_NAME, name);
|
|
| 105 |
public void setCacheFolder(File cacheFolder) {
|
|
| 106 |
this.setDynValue(TILECACHE_CACHEFOLDER_PARAMTER_NAME, cacheFolder);
|
|
| 107 | 107 |
} |
| 108 | 108 |
|
| 109 | 109 |
/** |
| org.gvsig.raster/branches/org.gvsig.raster.2.4/org.gvsig.raster/org.gvsig.raster.tilecache/org.gvsig.raster.tilecache.provider/src/main/resources/org/gvsig/raster/tilecache/provider/TileCacheParameters.xml | ||
|---|---|---|
| 8 | 8 |
</extends> |
| 9 | 9 |
<description>Store the parameters need to open a tile cache file</description> |
| 10 | 10 |
<fields> |
| 11 |
<field name="name" type="string" mandatory="true" group="Basic">
|
|
| 11 |
<field name="cacheFolder" type="folder" mandatory="true" group="Basic">
|
|
| 12 | 12 |
<description>Name to identify the tile structure</description> |
| 13 | 13 |
</field> |
| 14 | 14 |
<field name="crs" type="crs" mandatory="true" group="Basic"> |
| org.gvsig.raster/branches/org.gvsig.raster.2.4/org.gvsig.raster/org.gvsig.raster.tilecache/org.gvsig.raster.tilecache.provider/pom.xml | ||
|---|---|---|
| 28 | 28 |
<groupId>com.sun</groupId> |
| 29 | 29 |
<artifactId>jimi</artifactId> |
| 30 | 30 |
</dependency> |
| 31 |
<!-- <dependency> |
|
| 32 |
<groupId>org.gvsig</groupId> |
|
| 33 |
<artifactId>org.gvsig.andami</artifactId> |
|
| 34 |
</dependency> --> |
|
| 31 | 35 |
</dependencies> |
| 32 | 36 |
</project> |
| org.gvsig.raster/branches/org.gvsig.raster.2.4/org.gvsig.raster/org.gvsig.raster.tilecache/org.gvsig.raster.tilecache.app/org.gvsig.raster.tilecache.app.mainplugin/src/main/java/org/gvsig/raster/tilecache/app/mainplugin/AddTestRasterLayerExtension.java | ||
|---|---|---|
| 1 | 1 |
package org.gvsig.raster.tilecache.app.mainplugin; |
| 2 | 2 |
|
| 3 | 3 |
import java.io.File; |
| 4 |
import java.io.IOException; |
|
| 5 |
import java.security.MessageDigest; |
|
| 6 |
import java.security.NoSuchAlgorithmException; |
|
| 7 |
import java.util.ArrayList; |
|
| 8 |
import java.util.HashMap; |
|
| 9 |
import java.util.List; |
|
| 10 |
import java.util.Map; |
|
| 4 | 11 |
|
| 12 |
import javax.xml.parsers.DocumentBuilder; |
|
| 13 |
import javax.xml.parsers.DocumentBuilderFactory; |
|
| 14 |
import javax.xml.parsers.ParserConfigurationException; |
|
| 15 |
import javax.xml.transform.Transformer; |
|
| 16 |
import javax.xml.transform.TransformerException; |
|
| 17 |
import javax.xml.transform.TransformerFactory; |
|
| 18 |
import javax.xml.transform.dom.DOMSource; |
|
| 19 |
import javax.xml.transform.stream.StreamResult; |
|
| 20 |
|
|
| 5 | 21 |
import org.slf4j.Logger; |
| 6 | 22 |
import org.slf4j.LoggerFactory; |
| 23 |
import org.w3c.dom.Attr; |
|
| 24 |
import org.w3c.dom.Document; |
|
| 25 |
import org.w3c.dom.Element; |
|
| 7 | 26 |
|
| 8 | 27 |
import org.gvsig.andami.IconThemeHelper; |
| 28 |
import org.gvsig.andami.Launcher; |
|
| 9 | 29 |
import org.gvsig.andami.plugins.Extension; |
| 10 | 30 |
import org.gvsig.app.ApplicationLocator; |
| 11 | 31 |
import org.gvsig.app.ApplicationManager; |
| ... | ... | |
| 22 | 42 |
import org.gvsig.fmap.dal.exception.InitializeException; |
| 23 | 43 |
import org.gvsig.fmap.dal.exception.ProviderNotRegisteredException; |
| 24 | 44 |
import org.gvsig.fmap.dal.exception.ValidateDataParametersException; |
| 45 |
import org.gvsig.fmap.dal.raster.RasterStoreProviderFactory; |
|
| 46 |
import org.gvsig.fmap.dal.raster.api.RasterSet; |
|
| 25 | 47 |
import org.gvsig.fmap.dal.raster.api.RasterStore; |
| 26 | 48 |
import org.gvsig.fmap.dal.raster.spi.NewRasterStoreParameters; |
| 27 | 49 |
import org.gvsig.fmap.dal.spi.DALSPILocator; |
| 28 | 50 |
import org.gvsig.fmap.dal.spi.DataManagerProviderServices; |
| 51 |
import org.gvsig.fmap.geom.Geometry.DIMENSIONS; |
|
| 52 |
import org.gvsig.fmap.geom.primitive.Envelope; |
|
| 29 | 53 |
import org.gvsig.fmap.mapcontext.MapContext; |
| 30 | 54 |
import org.gvsig.fmap.mapcontext.MapContextLocator; |
| 31 | 55 |
import org.gvsig.fmap.mapcontext.MapContextManager; |
| ... | ... | |
| 34 | 58 |
import org.gvsig.fmap.mapcontrol.MapControl; |
| 35 | 59 |
import org.gvsig.raster.lib.buffer.api.Buffer; |
| 36 | 60 |
import org.gvsig.raster.lib.buffer.api.exceptions.BufferException; |
| 61 |
import org.gvsig.raster.tilecache.provider.TileCacheStoreProvider; |
|
| 62 |
import org.gvsig.tools.ToolsLocator; |
|
| 37 | 63 |
import org.gvsig.tools.dynobject.DynObject; |
| 38 | 64 |
|
| 39 | 65 |
/** |
| ... | ... | |
| 65 | 91 |
final MapContextManager mapContextManager = MapContextLocator.getMapContextManager(); |
| 66 | 92 |
FLayer layer = null; |
| 67 | 93 |
DataManager dataManager = DALLocator.getDataManager(); |
| 68 |
DataStore dataStore = openTileCache(); |
|
| 94 |
// DataStore dataStore = openFileCached(new File("/home/paco/data/cartography/raster/ecw/valencia_1980_tif.tif"));
|
|
| 95 |
DataStore dataStore = openFileCached(new File("/home/paco/data/Testdata/raster/JPG/relieve_andalucia.png"));
|
|
| 69 | 96 |
String layerName = dataStore.getName(); |
| 70 | 97 |
try {
|
| 71 | 98 |
layer = mapContextManager.createLayer(layerName, dataStore); |
| ... | ... | |
| 259 | 286 |
return store; |
| 260 | 287 |
} |
| 261 | 288 |
|
| 289 |
private RasterStore openFileCached(File file){
|
|
| 290 |
DataManagerProviderServices manager = DALSPILocator.getDataManagerProviderServices(); |
|
| 291 |
// DataStoreProviderFactory providerFactory = manager.getStoreProviderFactory("GTiff");
|
|
| 292 |
DataStoreProviderFactory providerFactory = manager.getStoreProviderFactory("JIMI");
|
|
| 293 |
DynObject params = providerFactory.createParameters(); |
|
Also available in: Unified diff