gvsig-raster / org.gvsig.raster / trunk / org.gvsig.raster / org.gvsig.raster.lib / org.gvsig.raster.lib.impl / src / main / java / org / gvsig / raster / impl / store / DefaultRasterStore.java @ 1356
History | View | Annotate | Download (57.4 KB)
1 | 689 | nbrodin | /* gvSIG. Geographic Information System of the Valencian Government
|
---|---|---|---|
2 | *
|
||
3 | * Copyright (C) 2007-2008 Infrastructures and Transports Department
|
||
4 | * of the Valencian Government (CIT)
|
||
5 | *
|
||
6 | * This program is free software; you can redistribute it and/or
|
||
7 | * modify it under the terms of the GNU General Public License
|
||
8 | * as published by the Free Software Foundation; either version 2
|
||
9 | * of the License, or (at your option) any later version.
|
||
10 | *
|
||
11 | * This program is distributed in the hope that it will be useful,
|
||
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
14 | * GNU General Public License for more details.
|
||
15 | *
|
||
16 | * You should have received a copy of the GNU General Public License
|
||
17 | * along with this program; if not, write to the Free Software
|
||
18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
||
19 | * MA 02110-1301, USA.
|
||
20 | *
|
||
21 | */
|
||
22 | package org.gvsig.raster.impl.store; |
||
23 | |||
24 | 1082 | nbrodin | import java.awt.Image; |
25 | 689 | nbrodin | import java.awt.geom.AffineTransform; |
26 | import java.awt.geom.Point2D; |
||
27 | import java.awt.geom.Rectangle2D; |
||
28 | 762 | nbrodin | import java.util.ArrayList; |
29 | 857 | nbrodin | import java.util.Collection; |
30 | 762 | nbrodin | import java.util.List; |
31 | 689 | nbrodin | |
32 | import org.cresques.cts.IProjection; |
||
33 | import org.gvsig.compat.net.ICancellable; |
||
34 | 753 | nbrodin | import org.gvsig.fmap.dal.DALLocator; |
35 | 689 | nbrodin | import org.gvsig.fmap.dal.DataStoreParameters; |
36 | 859 | nbrodin | import org.gvsig.fmap.dal.coverage.RasterLibrary; |
37 | 689 | nbrodin | import org.gvsig.fmap.dal.coverage.RasterLocator; |
38 | import org.gvsig.fmap.dal.coverage.RasterManager; |
||
39 | import org.gvsig.fmap.dal.coverage.dataset.Buffer; |
||
40 | import org.gvsig.fmap.dal.coverage.datastruct.BandList; |
||
41 | import org.gvsig.fmap.dal.coverage.datastruct.DatasetBand; |
||
42 | import org.gvsig.fmap.dal.coverage.datastruct.Extent; |
||
43 | 859 | nbrodin | import org.gvsig.fmap.dal.coverage.datastruct.NoData; |
44 | 762 | nbrodin | import org.gvsig.fmap.dal.coverage.datastruct.Params; |
45 | 689 | nbrodin | import org.gvsig.fmap.dal.coverage.exception.BandAccessException; |
46 | import org.gvsig.fmap.dal.coverage.exception.BandNotFoundInListException; |
||
47 | import org.gvsig.fmap.dal.coverage.exception.CloneException; |
||
48 | import org.gvsig.fmap.dal.coverage.exception.FileNotExistsException; |
||
49 | import org.gvsig.fmap.dal.coverage.exception.FileNotOpenException; |
||
50 | 762 | nbrodin | import org.gvsig.fmap.dal.coverage.exception.FilterManagerException; |
51 | import org.gvsig.fmap.dal.coverage.exception.FilterTypeException; |
||
52 | 689 | nbrodin | import org.gvsig.fmap.dal.coverage.exception.InvalidSetViewException; |
53 | import org.gvsig.fmap.dal.coverage.exception.InvalidSourceException; |
||
54 | import org.gvsig.fmap.dal.coverage.exception.NotSupportedExtensionException; |
||
55 | import org.gvsig.fmap.dal.coverage.exception.OperationNotSupportedException; |
||
56 | import org.gvsig.fmap.dal.coverage.exception.ProcessInterruptedException; |
||
57 | import org.gvsig.fmap.dal.coverage.exception.RasterDriverException; |
||
58 | import org.gvsig.fmap.dal.coverage.exception.RemoteServiceException; |
||
59 | import org.gvsig.fmap.dal.coverage.exception.RmfSerializerException; |
||
60 | import org.gvsig.fmap.dal.coverage.exception.TimeException; |
||
61 | 762 | nbrodin | import org.gvsig.fmap.dal.coverage.grid.RasterFilter; |
62 | import org.gvsig.fmap.dal.coverage.grid.RasterFilterList; |
||
63 | import org.gvsig.fmap.dal.coverage.grid.RasterFilterListManager; |
||
64 | 758 | nbrodin | import org.gvsig.fmap.dal.coverage.grid.render.Render; |
65 | 689 | nbrodin | import org.gvsig.fmap.dal.coverage.store.RasterDataStore; |
66 | import org.gvsig.fmap.dal.coverage.store.parameter.MultiDimensionalStoreParameters; |
||
67 | import org.gvsig.fmap.dal.coverage.store.parameter.RasterDataParameters; |
||
68 | import org.gvsig.fmap.dal.coverage.store.props.ColorInterpretation; |
||
69 | import org.gvsig.fmap.dal.coverage.store.props.ColorTable; |
||
70 | import org.gvsig.fmap.dal.coverage.store.props.HistogramComputer; |
||
71 | import org.gvsig.fmap.dal.coverage.store.props.Metadata; |
||
72 | import org.gvsig.fmap.dal.coverage.store.props.Statistics; |
||
73 | import org.gvsig.fmap.dal.coverage.store.props.TimeSeries; |
||
74 | import org.gvsig.fmap.dal.coverage.store.props.Transparency; |
||
75 | 753 | nbrodin | import org.gvsig.fmap.dal.exception.InitializeException; |
76 | import org.gvsig.fmap.dal.exception.ProviderNotRegisteredException; |
||
77 | 689 | nbrodin | import org.gvsig.fmap.dal.raster.spi.CoverageStoreProvider; |
78 | 753 | nbrodin | import org.gvsig.fmap.dal.spi.DataManagerProviderServices; |
79 | 953 | nbrodin | import org.gvsig.fmap.dal.spi.DataStoreProvider; |
80 | 689 | nbrodin | import org.gvsig.raster.cache.tile.Tile; |
81 | import org.gvsig.raster.cache.tile.TileCacheLocator; |
||
82 | import org.gvsig.raster.cache.tile.TileCacheManager; |
||
83 | import org.gvsig.raster.cache.tile.exception.TileGettingException; |
||
84 | import org.gvsig.raster.impl.DefaultRasterManager; |
||
85 | 1046 | nbrodin | import org.gvsig.raster.impl.buffer.DefaultRasterQuery; |
86 | 689 | nbrodin | import org.gvsig.raster.impl.buffer.cache.RasterReadOnlyBuffer; |
87 | import org.gvsig.raster.impl.datastruct.BandListImpl; |
||
88 | import org.gvsig.raster.impl.datastruct.DatasetBandImpl; |
||
89 | import org.gvsig.raster.impl.datastruct.ExtentImpl; |
||
90 | import org.gvsig.raster.impl.provider.DefaultRasterProvider; |
||
91 | import org.gvsig.raster.impl.provider.RasterProvider; |
||
92 | import org.gvsig.raster.impl.provider.TiledRasterProvider; |
||
93 | import org.gvsig.raster.impl.store.properties.MultiDataStoreMetadata; |
||
94 | 762 | nbrodin | import org.gvsig.raster.util.persistence.PersistencyFilterParam; |
95 | 857 | nbrodin | import org.gvsig.timesupport.Interval; |
96 | 689 | nbrodin | import org.gvsig.timesupport.Time; |
97 | 753 | nbrodin | import org.gvsig.tools.ToolsLocator; |
98 | import org.gvsig.tools.dynobject.DynStruct; |
||
99 | import org.gvsig.tools.persistence.PersistenceManager; |
||
100 | import org.gvsig.tools.persistence.PersistentState; |
||
101 | import org.gvsig.tools.persistence.exception.PersistenceException; |
||
102 | 689 | nbrodin | |
103 | /**
|
||
104 | * Default data store for raster
|
||
105 | *
|
||
106 | * @author Nacho Brodin (nachobrodin@gmail.com)
|
||
107 | */
|
||
108 | public class DefaultRasterStore extends AbstractRasterDataStore { |
||
109 | 753 | nbrodin | public static final String PERSISTENT_NAME = "DefaultRasterStore_Persistent"; |
110 | public static final String PERSISTENT_DESCRIPTION = "DefaultRasterStore Persistent"; |
||
111 | |||
112 | protected RasterProvider provider = null; |
||
113 | protected BandListImpl bandList = new BandListImpl(); |
||
114 | protected Metadata metadata = null; |
||
115 | private RasterManager rManager = RasterLocator.getManager();
|
||
116 | 689 | nbrodin | |
117 | /**
|
||
118 | * Flag que fuerza al buffer en memoria
|
||
119 | */
|
||
120 | protected boolean forceToMemory = false; |
||
121 | |||
122 | public DefaultRasterStore() {
|
||
123 | super();
|
||
124 | } |
||
125 | 840 | nbrodin | |
126 | 689 | nbrodin | public void setProvider(RasterProvider provider) { |
127 | this.provider = provider;
|
||
128 | 696 | nbrodin | parameters = (DataStoreParameters)provider.getDataParameters(); |
129 | 689 | nbrodin | bandList.clear(); |
130 | for(int i = 0; i < provider.getBandCount(); i++) { |
||
131 | try {
|
||
132 | int dataType = provider.getDataType()[i];
|
||
133 | 692 | nbrodin | DatasetBand band = new DatasetBandImpl(provider.getURIByBand(i),
|
134 | provider.getBandPositionByProvider(i), |
||
135 | dataType, |
||
136 | provider.getBandCount()); |
||
137 | 689 | nbrodin | bandList.addBand(band, i); |
138 | } catch(BandNotFoundInListException ex) {
|
||
139 | //No a?adimos la banda
|
||
140 | } |
||
141 | } |
||
142 | } |
||
143 | |||
144 | /*
|
||
145 | * (non-Javadoc)
|
||
146 | 953 | nbrodin | * @see org.gvsig.fmap.dal.impl.DataStoreImplementation#intializePhase2(org.gvsig.fmap.dal.spi.DataStoreProvider)
|
147 | */
|
||
148 | public void intializePhase2(DataStoreProvider provider) |
||
149 | throws InitializeException {
|
||
150 | setProvider((RasterProvider)provider); |
||
151 | } |
||
152 | |||
153 | /*
|
||
154 | * (non-Javadoc)
|
||
155 | 776 | nbrodin | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#setParameters(org.gvsig.fmap.dal.DataStoreParameters)
|
156 | */
|
||
157 | public void setParameters(DataStoreParameters p) { |
||
158 | this.parameters = p;
|
||
159 | } |
||
160 | |||
161 | /*
|
||
162 | * (non-Javadoc)
|
||
163 | 713 | nbrodin | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#setProvider(org.gvsig.fmap.dal.raster.spi.CoverageStoreProvider)
|
164 | */
|
||
165 | public void setProvider(CoverageStoreProvider prov) { |
||
166 | if(prov instanceof RasterProvider) |
||
167 | setProvider((RasterProvider)prov); |
||
168 | } |
||
169 | |||
170 | /*
|
||
171 | * (non-Javadoc)
|
||
172 | 689 | nbrodin | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getName()
|
173 | */
|
||
174 | public String getName() { |
||
175 | if(provider != null) |
||
176 | 697 | nbrodin | return provider.getURI();
|
177 | 689 | nbrodin | return null; |
178 | } |
||
179 | 840 | nbrodin | |
180 | /*
|
||
181 | * (non-Javadoc)
|
||
182 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#needEnhanced()
|
||
183 | */
|
||
184 | public boolean needEnhanced() { |
||
185 | if(provider != null) |
||
186 | return provider.needEnhanced();
|
||
187 | return false; |
||
188 | } |
||
189 | 689 | nbrodin | |
190 | /**
|
||
191 | * Inicializa el buffer a valores NoData
|
||
192 | * @param raster Buffer a inicializar
|
||
193 | * @param bandList Lista de bandas
|
||
194 | */
|
||
195 | 859 | nbrodin | private void initBufferToNoData(Buffer buf, BandList bandList) { |
196 | for(int i = 0; i < bandList.getDrawableBandsCount(); i++) { |
||
197 | 689 | nbrodin | switch(getDataType()[0]) { |
198 | 859 | nbrodin | case Buffer.TYPE_BYTE:buf.assign(i, |
199 | buf.getNoDataValue().isDefined() ? buf.getNoDataValue().getValue().byteValue() : RasterLibrary.defaultByteNoDataValue); |
||
200 | break;
|
||
201 | case Buffer.TYPE_SHORT:buf.assign(i, |
||
202 | buf.getNoDataValue().isDefined() ? buf.getNoDataValue().getValue().shortValue() : RasterLibrary.defaultShortNoDataValue); |
||
203 | break;
|
||
204 | case Buffer.TYPE_INT:buf.assign(i, |
||
205 | buf.getNoDataValue().isDefined() ? buf.getNoDataValue().getValue().intValue() : RasterLibrary.defaultIntegerNoDataValue); |
||
206 | break;
|
||
207 | case Buffer.TYPE_FLOAT:buf.assign(i, |
||
208 | buf.getNoDataValue().isDefined() ? buf.getNoDataValue().getValue().floatValue() : RasterLibrary.defaultFloatNoDataValue); |
||
209 | break;
|
||
210 | case Buffer.TYPE_DOUBLE:buf.assign(i, |
||
211 | buf.getNoDataValue().isDefined() ? buf.getNoDataValue().getValue().doubleValue() : RasterLibrary.defaultDoubleNoDataValue); |
||
212 | break;
|
||
213 | 689 | nbrodin | } |
214 | 859 | nbrodin | } |
215 | 689 | nbrodin | } |
216 | |||
217 | /*
|
||
218 | * (non-Javadoc)
|
||
219 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#isTiled()
|
||
220 | */
|
||
221 | public boolean isTiled() { |
||
222 | 750 | nbrodin | return provider.isTiled();
|
223 | 689 | nbrodin | } |
224 | 724 | nbrodin | |
225 | /*
|
||
226 | * (non-Javadoc)
|
||
227 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#isMosaic()
|
||
228 | */
|
||
229 | public boolean isMosaic() { |
||
230 | return provider.isMosaic();
|
||
231 | } |
||
232 | 1046 | nbrodin | |
233 | 689 | nbrodin | /*
|
234 | * (non-Javadoc)
|
||
235 | 1046 | nbrodin | * @see org.gvsig.raster.impl.store.QueryableRaster#getWindowRaster(double, double, double, double, boolean)
|
236 | 689 | nbrodin | */
|
237 | 1046 | nbrodin | public Buffer getWindowWithoutResampling(DefaultRasterQuery q) |
238 | 689 | nbrodin | throws InvalidSetViewException, ProcessInterruptedException, RasterDriverException {
|
239 | 1046 | nbrodin | |
240 | //El incremento o decremento de las X e Y depende de los signos de rotaci?n y escala en la matriz de transformaci?n. Por esto
|
||
241 | //tenemos que averiguar si lrx es x + w o x -w, asi como si lry es y + h o y - h
|
||
242 | Extent ext = getExtent(); |
||
243 | Point2D pInit = provider.rasterToWorld(new Point2D.Double(0, 0)); |
||
244 | Point2D pEnd = provider.rasterToWorld(new Point2D.Double((int)getWidth(), (int)getHeight())); |
||
245 | double wRaster = Math.abs(pEnd.getX() - pInit.getX()); |
||
246 | double hRaster = Math.abs(pEnd.getY() - pInit.getY()); |
||
247 | double lrx = (((int)(ext.getULX() - wRaster)) == ((int)ext.getLRX())) ? (q.getX() - q.getW()) : (q.getX() + q.getW()); |
||
248 | double lry = (((int)(ext.getULY() - hRaster)) == ((int)ext.getLRY())) ? (q.getY() - q.getH()) : (q.getY() + q.getH()); |
||
249 | |||
250 | 689 | nbrodin | //Extent selectedExtent = new Extent(ulx, uly, lrx, lry);
|
251 | |||
252 | //Leemos pixels completos aunque el valor obtenido sea decimal. Esto se consigue redondeando
|
||
253 | //por arriba el m?s alto y por abajo el menor y luego restandolos
|
||
254 | |||
255 | 1046 | nbrodin | Point2D p1 = provider.worldToRaster(new Point2D.Double(q.getX(), q.getY())); |
256 | 689 | nbrodin | Point2D p2 = provider.worldToRaster(new Point2D.Double(lrx, lry)); |
257 | 1069 | nbrodin | adjustPoints(p1, p2); |
258 | 1046 | nbrodin | int width = (int)Math.abs(Math.ceil(p2.getX()) - Math.floor(p1.getX())); |
259 | int height = (int)Math.abs(Math.floor(p1.getY()) - Math.ceil(p2.getY())); |
||
260 | 689 | nbrodin | |
261 | //Ajustamos por si nos hemos salido del raster
|
||
262 | 1046 | nbrodin | if(((int)(p1.getX() + width)) > getWidth()) |
263 | width = (int)(getWidth() - p1.getX());
|
||
264 | if(((int)(p1.getY() + height)) > getHeight()) |
||
265 | height = (int)(getHeight() - p1.getY());
|
||
266 | 689 | nbrodin | |
267 | 1046 | nbrodin | if (p1.getX() < 0) |
268 | p1.setLocation(0, p1.getY());
|
||
269 | if (p1.getY() < 0) |
||
270 | p1.setLocation(p1.getX(), 0);
|
||
271 | if (p2.getX() > getWidth())
|
||
272 | p2.setLocation(getWidth(), p2.getY()); |
||
273 | if (p2.getY() > getHeight())
|
||
274 | p2.setLocation(p2.getX(), getHeight()); |
||
275 | 689 | nbrodin | |
276 | int mallocNBands = 0; |
||
277 | if(bandList.getDrawableBands() != null) |
||
278 | mallocNBands = bandList.getDrawableBands().length; |
||
279 | else
|
||
280 | mallocNBands = bandList.getDrawableBandsCount(); |
||
281 | |||
282 | //Buffer ReadOnly
|
||
283 | |||
284 | if(isReadOnly()) {
|
||
285 | Buffer rb = DefaultRasterManager.getInstance().createReadOnlyBuffer(getDataType()[0], width, height, getBandCount()); |
||
286 | if(rb instanceof RasterReadOnlyBuffer) { |
||
287 | try {
|
||
288 | 1069 | nbrodin | ((RasterReadOnlyBuffer)rb).setBufferParams(this,
|
289 | (int)Math.floor(p1.getX()), |
||
290 | (int)Math.floor(p1.getY()), |
||
291 | (int)Math.ceil(p2.getX()), |
||
292 | (int)Math.ceil(p2.getY()), |
||
293 | bandList); |
||
294 | 689 | nbrodin | } catch (FileNotExistsException e) {
|
295 | //Esto no debe darse ya que se comprueba al hacer el open.
|
||
296 | return null; |
||
297 | } catch (NotSupportedExtensionException e) {
|
||
298 | //Esto no debe darse ya que se comprueba al hacer el open
|
||
299 | return null; |
||
300 | } |
||
301 | return rb;
|
||
302 | } |
||
303 | } |
||
304 | 1046 | nbrodin | |
305 | //Si hemos redondeado los pixeles de la petici?n (p1 y p2) por arriba y por abajo deberemos calcular un extent mayor
|
||
306 | //equivalente a los pixeles redondeados.
|
||
307 | Point2D wc1 = provider.rasterToWorld(new Point2D.Double(Math.floor(p1.getX()), Math.floor(p1.getY()))); |
||
308 | Point2D wc2 = provider.rasterToWorld(new Point2D.Double(Math.ceil(p2.getX()), Math.ceil(p2.getY()))); |
||
309 | 689 | nbrodin | |
310 | //Buffer RW
|
||
311 | Buffer raster = null; |
||
312 | |||
313 | if(forceToMemory) //Fuerza siempre buffer en memoria |
||
314 | raster = DefaultRasterManager.getInstance().createMemoryBuffer(getDataType()[0], width, height, mallocNBands, true); |
||
315 | else
|
||
316 | raster = DefaultRasterManager.getInstance().createBuffer(getDataType()[0], width, height, mallocNBands, true); |
||
317 | 1046 | nbrodin | |
318 | if(!q.isAdjustToExtent())
|
||
319 | initBufferToNoData(raster, bandList); |
||
320 | 689 | nbrodin | |
321 | 1047 | nbrodin | q.setAreaOfInterest(wc1.getX(), wc1.getY(), Math.abs(wc2.getX() - wc1.getX()), Math.abs(wc2.getY() - wc1.getY())); |
322 | q.setBandList(bandList); |
||
323 | q.setBuffer(raster); |
||
324 | raster = ((DefaultRasterProvider)provider).getDataSet(q); |
||
325 | 689 | nbrodin | |
326 | return raster;
|
||
327 | } |
||
328 | 1046 | nbrodin | |
329 | 1069 | nbrodin | private void adjustPoints(Point2D ul, Point2D lr) { |
330 | double a = (ul.getX() - (int)ul.getX()); |
||
331 | double b = (ul.getY() - (int)ul.getY()); |
||
332 | ul.setLocation( (a > 0.99 || a < 0.005) ? Math.round(ul.getX()) : ul.getX(), |
||
333 | (b > 0.99 || b < 0.005) ? Math.round(ul.getY()) : ul.getY()); |
||
334 | lr.setLocation( (a > 0.99 || a < 0.005) ? Math.round(lr.getX()) : lr.getX(), |
||
335 | (b > 0.99 || b < 0.005) ? Math.round(lr.getY()) : lr.getY()); |
||
336 | } |
||
337 | |||
338 | 689 | nbrodin | /*
|
339 | * (non-Javadoc)
|
||
340 | 1046 | nbrodin | * @see org.gvsig.raster.impl.store.AbstractRasterDataStore#getWindowWithResampling(org.gvsig.raster.impl.buffer.DefaultRasterQuery)
|
341 | 689 | nbrodin | */
|
342 | 1046 | nbrodin | public Buffer getWindowWithResampling(DefaultRasterQuery q) |
343 | 689 | nbrodin | throws InvalidSetViewException, ProcessInterruptedException, RasterDriverException {
|
344 | |||
345 | 1046 | nbrodin | Point2D p1 = worldToRaster(new Point2D.Double(q.getBBox().getULX(), q.getBBox().getULY())); |
346 | Point2D p2 = worldToRaster(new Point2D.Double(q.getBBox().getLRX(), q.getBBox().getLRY()));; |
||
347 | |||
348 | if(p1.getX() > p2.getX())
|
||
349 | p1.setLocation(p1.getX() - 1, p1.getY());
|
||
350 | else
|
||
351 | p2.setLocation(p2.getX() - 1, p2.getY());
|
||
352 | |||
353 | if(p1.getY() > p2.getY())
|
||
354 | p1.setLocation(p1.getX(), p1.getY() - 1);
|
||
355 | else
|
||
356 | p2.setLocation(p2.getX(), p2.getY() - 1);
|
||
357 | |||
358 | if( ((int)p1.getX()) < 0 || ((int)p2.getX()) > getWidth() || |
||
359 | ((int)p2.getY()) > getHeight() || ((int)p2.getY()) < 0) |
||
360 | throw new InvalidSetViewException(""); |
||
361 | 689 | nbrodin | |
362 | 1046 | nbrodin | int mallocNBands = 0; |
363 | if(bandList.getDrawableBands() != null) |
||
364 | mallocNBands = bandList.getDrawableBands().length; |
||
365 | else
|
||
366 | mallocNBands = bandList.getDrawableBandsCount(); |
||
367 | |||
368 | //Buffer ReadOnly
|
||
369 | |||
370 | if(isReadOnly()) {
|
||
371 | Buffer rb = DefaultRasterManager.getInstance().createReadOnlyBuffer(getDataType()[0], q.getBufWidth(), q.getBufHeight(), getBandCount()); |
||
372 | if(rb instanceof RasterReadOnlyBuffer) { |
||
373 | try {
|
||
374 | ((RasterReadOnlyBuffer)rb).setBufferParams(this, (int)p1.getX(), (int)p1.getY(), (int)p2.getX(), (int)p2.getY(), bandList); |
||
375 | } catch (FileNotExistsException e) {
|
||
376 | //Esto no debe darse ya que se comprueba al hacer el open.
|
||
377 | return null; |
||
378 | } catch (NotSupportedExtensionException e) {
|
||
379 | //Esto no debe darse ya que se comprueba al hacer el open
|
||
380 | return null; |
||
381 | } |
||
382 | return rb;
|
||
383 | } |
||
384 | } |
||
385 | |||
386 | double ulx = q.getBBox().getULX();
|
||
387 | double uly = q.getBBox().getULY();
|
||
388 | double lrx = q.getBBox().getLRX();
|
||
389 | double lry = q.getBBox().getLRY();
|
||
390 | |||
391 | //Buffer RW
|
||
392 | Buffer raster = null; |
||
393 | |||
394 | if(forceToMemory) //Fuerza siempre buffer en memoria |
||
395 | raster = DefaultRasterManager.getInstance().createMemoryBuffer(getDataType()[0], q.getBufWidth(), q.getBufHeight(), mallocNBands, true); |
||
396 | else
|
||
397 | raster = DefaultRasterManager.getInstance().createBuffer(getDataType()[0], q.getBufWidth(), q.getBufHeight(), mallocNBands, true); |
||
398 | |||
399 | Extent ex = rManager.getDataStructFactory().createExtent(ulx, uly, lrx, lry); |
||
400 | |||
401 | 1047 | nbrodin | q.setBBox(ex); |
402 | q.setBandList(bandList); |
||
403 | q.setBuffer(raster); |
||
404 | raster = ((DefaultRasterProvider)provider).getDataSet(q); |
||
405 | 1046 | nbrodin | |
406 | return raster;
|
||
407 | } |
||
408 | |||
409 | /*
|
||
410 | * (non-Javadoc)
|
||
411 | * @see org.gvsig.raster.impl.store.QueryableRaster#getWindowRaster(double, double, double, double)
|
||
412 | */
|
||
413 | public Buffer getWindowWC(DefaultRasterQuery q) |
||
414 | throws InvalidSetViewException, ProcessInterruptedException, RasterDriverException {
|
||
415 | |||
416 | if(q.getBufWidth() > 0 && q.getBufHeight() > 0) |
||
417 | return getWindowWithResampling(q);
|
||
418 | |||
419 | 689 | nbrodin | //Leemos pixels completos aunque el valor obtenido sea decimal. Esto se consigue redondeando
|
420 | //por arriba el m?s alto y por abajo el menor y luego restandolos
|
||
421 | |||
422 | 1046 | nbrodin | Point2D p1 = provider.worldToRaster(new Point2D.Double(q.getBBox().getULX(), q.getBBox().getULY())); |
423 | Point2D p2 = provider.worldToRaster(new Point2D.Double(q.getBBox().getLRX(), q.getBBox().getLRY())); |
||
424 | 689 | nbrodin | |
425 | 1046 | nbrodin | //Para el valor mayor redondeamos por arriba. Para el valor menor redondeamos por abajo.
|
426 | double p1X = (p1.getX() > p2.getX()) ? Math.ceil(p1.getX()) : Math.floor(p1.getX()); |
||
427 | double p1Y = (p1.getY() > p2.getY()) ? Math.ceil(p1.getY()) : Math.floor(p1.getY()); |
||
428 | double p2X = (p2.getX() > p1.getX()) ? Math.ceil(p2.getX()) : Math.floor(p2.getX()); |
||
429 | double p2Y = (p2.getY() > p1.getY()) ? Math.ceil(p2.getY()) : Math.floor(p2.getY()); |
||
430 | |||
431 | int width = (int)Math.abs(p1X - p2X); |
||
432 | int height = (int)Math.abs(p1Y - p2Y); |
||
433 | |||
434 | 689 | nbrodin | //Ajustamos por si nos hemos salido del raster
|
435 | 1046 | nbrodin | if(((int)(Math.min(p1X, p2X) + width)) > getWidth()) |
436 | width = (int)(getWidth() - Math.min(p1X, p2X)); |
||
437 | if(((int)(Math.min(p1Y, p2Y) + height)) > getHeight()) |
||
438 | height = (int)(getHeight() - Math.min(p1Y, p2Y)); |
||
439 | 689 | nbrodin | |
440 | 1046 | nbrodin | if (p1X < 0) |
441 | p1X = 0;
|
||
442 | if (p1Y < 0) |
||
443 | p1Y = 0;
|
||
444 | if (p2X > getWidth())
|
||
445 | p2X = getWidth(); |
||
446 | if (p2Y > getHeight())
|
||
447 | p2Y = getHeight(); |
||
448 | 689 | nbrodin | |
449 | int mallocNBands = 0; |
||
450 | if(bandList.getDrawableBands() != null) |
||
451 | mallocNBands = bandList.getDrawableBands().length; |
||
452 | else
|
||
453 | mallocNBands = bandList.getDrawableBandsCount(); |
||
454 | |||
455 | //Buffer ReadOnly
|
||
456 | |||
457 | if(isReadOnly()) {
|
||
458 | Buffer rb = DefaultRasterManager.getInstance().createReadOnlyBuffer(getDataType()[0], width, height, getBandCount()); |
||
459 | if(rb instanceof RasterReadOnlyBuffer) { |
||
460 | try {
|
||
461 | ((RasterReadOnlyBuffer)rb).setBufferParams(this, (int)p1.getX(), (int)p1.getY(), (int)p2.getX(), (int)p2.getY(), bandList); |
||
462 | } catch (FileNotExistsException e) {
|
||
463 | //Esto no debe darse ya que se comprueba al hacer el open.
|
||
464 | return null; |
||
465 | } catch (NotSupportedExtensionException e) {
|
||
466 | //Esto no debe darse ya que se comprueba al hacer el open
|
||
467 | return null; |
||
468 | } |
||
469 | return rb;
|
||
470 | } |
||
471 | } |
||
472 | |||
473 | //Buffer RW
|
||
474 | Buffer raster = null; |
||
475 | |||
476 | 1046 | nbrodin | //Si hemos redondeado los pixeles de la petici?n (p1 y p2) por arriba y por abajo deberemos calcular un extent mayor
|
477 | //equivalente a los pixeles redondeados.
|
||
478 | Point2D wc1 = provider.rasterToWorld(new Point2D.Double(p1X, p1Y)); |
||
479 | Point2D wc2 = provider.rasterToWorld(new Point2D.Double(p2X, p2Y)); |
||
480 | |||
481 | 689 | nbrodin | if(forceToMemory) //Fuerza siempre buffer en memoria |
482 | raster = DefaultRasterManager.getInstance().createMemoryBuffer(getDataType()[0], width, height, mallocNBands, true); |
||
483 | else
|
||
484 | raster = DefaultRasterManager.getInstance().createBuffer(getDataType()[0], width, height, mallocNBands, true); |
||
485 | |||
486 | 1046 | nbrodin | Extent ex = rManager.getDataStructFactory().createExtent(wc1.getX(), wc1.getY(), wc2.getX(), wc2.getY()); |
487 | 1047 | nbrodin | q.setType(DefaultRasterQuery.TYPE_COORDS); |
488 | q.setBBox(ex); |
||
489 | q.setBandList(bandList); |
||
490 | q.setBuffer(raster); |
||
491 | raster = ((DefaultRasterProvider)provider).getDataSet(q); |
||
492 | //raster = ((DefaultRasterProvider)provider).getWindow(ex, bandList, raster);
|
||
493 | 689 | nbrodin | |
494 | return raster;
|
||
495 | } |
||
496 | 1046 | nbrodin | |
497 | 689 | nbrodin | /*
|
498 | * (non-Javadoc)
|
||
499 | * @see org.gvsig.raster.impl.store.QueryableRaster#getWindowRaster(double, double, double, double, int, int, org.gvsig.fmap.dal.coverage.grid.render.TileListener, int)
|
||
500 | */
|
||
501 | 1047 | nbrodin | public void getWindowTiled(DefaultRasterQuery q) |
502 | 689 | nbrodin | throws InvalidSetViewException, ProcessInterruptedException, RasterDriverException {
|
503 | if(isTiled()) {
|
||
504 | 1047 | nbrodin | //Extent ex = q.getBBox();//new ExtentImpl(ulx, uly, lrx, lry);
|
505 | q.setBandList(bandList); |
||
506 | ((DefaultRasterProvider)provider).getDataSet(q); |
||
507 | //((DefaultRasterProvider)provider).getWindow(ex, q.getBufWidth(), q.getBufHeight(), bandList, listener);
|
||
508 | 689 | nbrodin | return;
|
509 | } |
||
510 | |||
511 | double[] step = null; |
||
512 | Buffer buf = null; |
||
513 | |||
514 | 1046 | nbrodin | double ulx = q.getBBox().getULX();
|
515 | double uly = q.getBBox().getULY();
|
||
516 | double lrx = q.getBBox().getLRX();
|
||
517 | double lry = q.getBBox().getLRY();
|
||
518 | |||
519 | 689 | nbrodin | //Esta secci?n es para que no supersamplee el driver y pueda hacerse en el cliente
|
520 | if(!currentQuery.isSupersamplingLoadingBuffer()) {
|
||
521 | //nWidth = ((adjustedDataExtent.width() * mDataset.getDataset(0).getWidth()) / mDataset.getExtentForRequest().width());
|
||
522 | //nHeight = ((adjustedDataExtent.height() * mDataset.getDataset(0).getHeight()) / mDataset.getExtentForRequest().height());
|
||
523 | Point2D p1 = worldToRaster(new Point2D.Double(ulx, uly)); |
||
524 | Point2D p2 = worldToRaster(new Point2D.Double(lrx, lry)); |
||
525 | nWidth = Math.abs(p1.getX() - p2.getX());
|
||
526 | nHeight = Math.abs(p1.getY() - p2.getY());
|
||
527 | |||
528 | 1046 | nbrodin | if(q.getBufWidth() > Math.ceil(nWidth) && q.getBufHeight() > Math.ceil(nHeight)) { |
529 | step = calcSteps(ulx, uly, lrx, lry, nWidth, nHeight, q.getBufWidth(), q.getBufHeight()); |
||
530 | buf = getWindowWC(q); |
||
531 | 689 | nbrodin | } |
532 | } |
||
533 | |||
534 | 1046 | nbrodin | if(buf == null) { |
535 | q.setAdjustToExtent(true);
|
||
536 | buf = getWindowWithResampling(q); |
||
537 | } |
||
538 | 689 | nbrodin | |
539 | buf.setDataExtent(new Rectangle2D.Double(ulx, uly, Math.abs(ulx - lrx), Math.abs(uly - lry))); |
||
540 | |||
541 | Buffer alphaBand = null; |
||
542 | if(currentQuery.getAlphaBandNumber() != -1) { |
||
543 | int[] drawableBands = bandList.getDrawableBands(); |
||
544 | bandList.setDrawableBands(new int[]{currentQuery.getAlphaBandNumber(), -1, -1}); |
||
545 | for(int i = 0; i < provider.getInternalProviderCount(); i++) |
||
546 | ((AbstractRasterDataParameters)((DefaultRasterProvider)provider.getInternalProvider(i)).getDataParameters()).setAlphaBand(currentQuery.getAlphaBandNumber()); |
||
547 | 1046 | nbrodin | q.setAdjustToExtent(true);
|
548 | alphaBand = getWindowWithResampling(q); |
||
549 | 689 | nbrodin | bandList.setDrawableBands(drawableBands); |
550 | } |
||
551 | |||
552 | TileCacheManager m = TileCacheLocator.getManager(); |
||
553 | org.gvsig.raster.cache.tile.Tile t = m.createTile(-1, 0, 0); |
||
554 | t.setData(new Object[]{buf, alphaBand}); |
||
555 | t.setUl(new Point2D.Double(ulx, uly)); |
||
556 | t.setLr(new Point2D.Double(lrx, lry)); |
||
557 | if(provider.getDataParameters() instanceof MultiDimensionalStoreParameters) { |
||
558 | MultiDimensionalStoreParameters par = (MultiDimensionalStoreParameters)provider.getDataParameters(); |
||
559 | t.setVariable(par.getStringVariable()); |
||
560 | t.setZ(par.getStringLevel()); |
||
561 | t.setTimeInstant(par.getStringTime()); |
||
562 | } |
||
563 | t.setDownloaderParams("AffineTransform", getAffineTransform());
|
||
564 | t.setDownloaderParams("Tiling", new Boolean(true)); |
||
565 | t.setDownloaderParams("Step", step);
|
||
566 | try {
|
||
567 | 1047 | nbrodin | q.getTileListener().tileReady(t); |
568 | 689 | nbrodin | } catch (TileGettingException e) {
|
569 | throw new RasterDriverException("Error getting a tile", e); |
||
570 | } |
||
571 | |||
572 | //listener.nextBuffer(buf, alphaBand, new ExtentImpl(ulx, uly, lrx, lry), this.getAffineTransform(), step, false);
|
||
573 | 1047 | nbrodin | q.getTileListener().endReading(); |
574 | 689 | nbrodin | } |
575 | |||
576 | /*
|
||
577 | * (non-Javadoc)
|
||
578 | * @see org.gvsig.raster.impl.store.QueryableRaster#getTile(int, int, int, org.gvsig.fmap.dal.coverage.datastruct.Extent)
|
||
579 | */
|
||
580 | 1046 | nbrodin | public Tile getTile(DefaultRasterQuery q) throws TileGettingException { |
581 | 689 | nbrodin | TiledRasterProvider tiledProv = ((TiledRasterProvider)provider); |
582 | 1046 | nbrodin | return tiledProv.getTile(q);
|
583 | 689 | nbrodin | } |
584 | |||
585 | /*
|
||
586 | * (non-Javadoc)
|
||
587 | 1046 | nbrodin | * @see org.gvsig.raster.impl.store.QueryableRaster#getWindowRaster(int, int, int, int, int, int)
|
588 | 689 | nbrodin | */
|
589 | 1046 | nbrodin | public Buffer getWindowPx(DefaultRasterQuery q) |
590 | 689 | nbrodin | throws InvalidSetViewException, ProcessInterruptedException, RasterDriverException {
|
591 | 1046 | nbrodin | step = null;
|
592 | if(q.getPixelX() < 0 || q.getPixelY() < 0 || q.getPixelW() > getWidth() || q.getPixelH() > getHeight()) |
||
593 | throw new InvalidSetViewException("Out of image"); |
||
594 | 689 | nbrodin | |
595 | 1046 | nbrodin | q.setPixelX((q.getPixelX() < 0) ? 0 : q.getPixelX()); |
596 | q.setPixelY((q.getPixelY() < 0) ? 0 : q.getPixelY()); |
||
597 | q.setPixelW((q.getPixelW() > getWidth()) ? (int)getWidth() : q.getPixelW());
|
||
598 | q.setPixelH((q.getPixelH() > getHeight()) ? (int)getHeight() : q.getPixelH());
|
||
599 | 689 | nbrodin | |
600 | 1046 | nbrodin | dataExtent = new ExtentImpl(rasterToWorld(new Point2D.Double(q.getPixelX(), q.getPixelY())), |
601 | rasterToWorld(new Point2D.Double(q.getPixelX() + q.getPixelW(), q.getPixelY() + q.getPixelH()))); |
||
602 | 689 | nbrodin | |
603 | 1046 | nbrodin | if( q.getType() == DefaultRasterQuery.TYPE_PX ||
|
604 | q.getType() == DefaultRasterQuery.TYPE_ENTIRE || |
||
605 | q.getBufWidth() <= 0 || q.getBufHeight() <= 0) { |
||
606 | q.setBufWidth(q.getPixelW()); |
||
607 | q.setBufHeight(q.getPixelH()); |
||
608 | 1043 | nbrodin | } |
609 | 689 | nbrodin | |
610 | //Buffer ReadOnly
|
||
611 | |||
612 | if(isReadOnly()) {
|
||
613 | 1046 | nbrodin | Buffer rb = DefaultRasterManager.getInstance().createReadOnlyBuffer(getDataType()[0], |
614 | q.getBufWidth(), q.getBufHeight(), getBandCount()); |
||
615 | 689 | nbrodin | if(rb instanceof RasterReadOnlyBuffer) { |
616 | try {
|
||
617 | 1046 | nbrodin | ((RasterReadOnlyBuffer)rb).setBufferParams((QueryableRaster)this, q.getPixelX(),
|
618 | q.getPixelY(), q.getPixelX() + q.getPixelW(), q.getPixelY() + q.getPixelH(), bandList); |
||
619 | 689 | nbrodin | } catch (FileNotExistsException e) {
|
620 | //Esto no debe darse ya que se comprueba al hacer el open.
|
||
621 | return null; |
||
622 | } catch (NotSupportedExtensionException e) {
|
||
623 | //Esto no debe darse ya que se comprueba al hacer el open
|
||
624 | return null; |
||
625 | } |
||
626 | return rb;
|
||
627 | } |
||
628 | } |
||
629 | |||
630 | //Buffer RW
|
||
631 | Buffer raster = null; |
||
632 | |||
633 | if(forceToMemory) //Fuerza siempre buffer en memoria |
||
634 | 1046 | nbrodin | raster = DefaultRasterManager.getInstance().createMemoryBuffer(getDataType()[0], q.getBufWidth(), q.getBufHeight(), bandList.getDrawableBandsCount(), true); |
635 | 689 | nbrodin | else
|
636 | 1046 | nbrodin | raster = DefaultRasterManager.getInstance().createBuffer(getDataType()[0], q.getBufWidth(), q.getBufHeight(), bandList.getDrawableBandsCount(), true); |
637 | 689 | nbrodin | |
638 | 1047 | nbrodin | q.setBandList(bandList); |
639 | q.setBuffer(raster); |
||
640 | raster = ((DefaultRasterProvider)provider).getDataSet(q); |
||
641 | //raster = ((DefaultRasterProvider)provider).getWindow(q.getPixelX(), q.getPixelY(), q.getPixelW(), q.getPixelH(), bandList, raster);
|
||
642 | 689 | nbrodin | |
643 | return raster;
|
||
644 | } |
||
645 | |||
646 | //******************************
|
||
647 | //Setters and Getters
|
||
648 | //******************************
|
||
649 | |||
650 | /**
|
||
651 | * Calcula el tama?o de los ficheros en disco
|
||
652 | * @return tama?o en bytes de todos los ficheros de la lista
|
||
653 | */
|
||
654 | public long getFileSize() { |
||
655 | if(provider != null) { |
||
656 | long size = 0; |
||
657 | long[] fSize = provider.getFileSizeByProvider(); |
||
658 | if(fSize != null && fSize.length > 0) { |
||
659 | for (int j = 0; j < fSize.length; j++) { |
||
660 | size += fSize[j]; |
||
661 | } |
||
662 | } |
||
663 | return size;
|
||
664 | } |
||
665 | return 0; |
||
666 | } |
||
667 | |||
668 | /*
|
||
669 | * (non-Javadoc)
|
||
670 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getHeight()
|
||
671 | */
|
||
672 | public double getHeight() { |
||
673 | return provider.getHeight();
|
||
674 | } |
||
675 | |||
676 | /*
|
||
677 | * (non-Javadoc)
|
||
678 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getWidth()
|
||
679 | */
|
||
680 | public double getWidth() { |
||
681 | return provider.getWidth();
|
||
682 | } |
||
683 | |||
684 | /*
|
||
685 | * (non-Javadoc)
|
||
686 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getCellSize()
|
||
687 | */
|
||
688 | public double getCellSize() { |
||
689 | try {
|
||
690 | Extent e = getExtent(); |
||
691 | double dCellsize = (e.getMax().getX() - e.getMin().getX() ) / getWidth();
|
||
692 | return dCellsize;
|
||
693 | } catch (NullPointerException e) { |
||
694 | return 1; |
||
695 | } |
||
696 | } |
||
697 | |||
698 | /*
|
||
699 | * (non-Javadoc)
|
||
700 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getBandCount()
|
||
701 | */
|
||
702 | public int getBandCount() { |
||
703 | return provider.getBandCount();
|
||
704 | } |
||
705 | |||
706 | /*
|
||
707 | * (non-Javadoc)
|
||
708 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getDataType()
|
||
709 | */
|
||
710 | public int[] getDataType() { |
||
711 | return provider.getDataType();
|
||
712 | } |
||
713 | |||
714 | /*
|
||
715 | * (non-Javadoc)
|
||
716 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getBands()
|
||
717 | */
|
||
718 | public BandList getBands() {
|
||
719 | return bandList;
|
||
720 | } |
||
721 | |||
722 | /**
|
||
723 | * Obtiene la coordenada X m?nima de toda la lista
|
||
724 | * @return Coordenada X m?nima
|
||
725 | */
|
||
726 | public double getMinX() { |
||
727 | return provider.getExtent().getMin().getX();
|
||
728 | } |
||
729 | |||
730 | /**
|
||
731 | * Obtiene la coordenada Y m?nima de toda la lista
|
||
732 | * @return Coordenada Y m?nima
|
||
733 | */
|
||
734 | public double getMinY() { |
||
735 | return provider.getExtent().getMin().getY();
|
||
736 | } |
||
737 | |||
738 | /**
|
||
739 | * Obtiene la coordenada Y m?xima de toda la lista
|
||
740 | * @return Coordenada Y m?xima
|
||
741 | */
|
||
742 | public double getMaxX() { |
||
743 | return provider.getExtent().getMax().getX(); }
|
||
744 | |||
745 | /**
|
||
746 | * Obtiene la coordenada Y m?xima de toda la lista
|
||
747 | * @return Coordenada Y m?xima
|
||
748 | */
|
||
749 | public double getMaxY() { |
||
750 | return provider.getExtent().getMax().getY();
|
||
751 | } |
||
752 | |||
753 | /*
|
||
754 | * (non-Javadoc)
|
||
755 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getNoDataValue()
|
||
756 | */
|
||
757 | 859 | nbrodin | public NoData getNoDataValue() {
|
758 | 689 | nbrodin | return provider.getNoDataValue();
|
759 | } |
||
760 | |||
761 | /*
|
||
762 | * (non-Javadoc)
|
||
763 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#setNoDataValue(double)
|
||
764 | */
|
||
765 | 859 | nbrodin | public void setNoDataValue(NoData value) { |
766 | 689 | nbrodin | provider.setNoDataValue(value); |
767 | } |
||
768 | |||
769 | /*
|
||
770 | * (non-Javadoc)
|
||
771 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getExtent()
|
||
772 | */
|
||
773 | public Extent getExtent() {
|
||
774 | 1277 | nbrodin | Extent e = provider.getExtent(); |
775 | if (coordTrans != null) { |
||
776 | e = e.convert(coordTrans); |
||
777 | } |
||
778 | return e;
|
||
779 | 689 | nbrodin | } |
780 | |||
781 | /**
|
||
782 | * Este es el extent sobre el que se ajusta una petici?n para que esta no exceda el
|
||
783 | * extent m?ximo del raster. Para un raster sin rotar ser? igual al extent
|
||
784 | * pero para un raster rotado ser? igual al extent del raster como si no
|
||
785 | * tuviera rotaci?n. Esto ha de ser as? ya que la rotaci?n solo se hace sobre la
|
||
786 | * vista y las peticiones han de hacerse en coordenadas de la imagen sin shearing
|
||
787 | * aplicado.
|
||
788 | * @return Extent
|
||
789 | */
|
||
790 | public Extent getExtentForRequest() {
|
||
791 | return provider.getExtentWithoutRot();
|
||
792 | } |
||
793 | |||
794 | /**
|
||
795 | *
|
||
796 | * @return
|
||
797 | */
|
||
798 | public Extent getLastSelectedView(){
|
||
799 | return provider.getView();
|
||
800 | } |
||
801 | |||
802 | /*
|
||
803 | * (non-Javadoc)
|
||
804 | * @see org.gvsig.raster.impl.store.QueryableRaster#getColorTable(int)
|
||
805 | */
|
||
806 | public ColorTable getColorTable(int i){ |
||
807 | return provider.getColorTable();
|
||
808 | } |
||
809 | |||
810 | /**
|
||
811 | * Obtiene la lista de paletas correspondiente a todos los ficheros que forman el GeoMultiRasterFile
|
||
812 | * @return Paleta asociada a este o null si no tiene. Una posici?n null en el array tambi?n indica que
|
||
813 | * para ese fichero no hay paletas asociadas.
|
||
814 | */
|
||
815 | public ColorTable getColorTables() {
|
||
816 | return provider.getColorTable();
|
||
817 | } |
||
818 | 795 | nbrodin | |
819 | /*
|
||
820 | * (non-Javadoc)
|
||
821 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getColorTable()
|
||
822 | */
|
||
823 | public ColorTable getColorTable() {
|
||
824 | //Solo tiene sentido si tiene un fichero y ese fichero tiene una sola banda
|
||
825 | if(provider != null) |
||
826 | return provider.getColorTable();
|
||
827 | return null; |
||
828 | } |
||
829 | |||
830 | /**
|
||
831 | * Sets the color table
|
||
832 | * @param colorTable
|
||
833 | */
|
||
834 | public void setColorTable(ColorTable colorTable) { |
||
835 | provider.setColorTable(colorTable); |
||
836 | } |
||
837 | 689 | nbrodin | |
838 | /*
|
||
839 | * (non-Javadoc)
|
||
840 | * @see org.gvsig.raster.impl.store.QueryableRaster#getColorTable(java.lang.String)
|
||
841 | */
|
||
842 | public ColorTable getColorTable(String fileName){ |
||
843 | return provider.getColorTable();
|
||
844 | } |
||
845 | |||
846 | /*
|
||
847 | * (non-Javadoc)
|
||
848 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#rasterToWorld(java.awt.geom.Point2D)
|
||
849 | */
|
||
850 | public Point2D rasterToWorld(Point2D pt) { |
||
851 | return provider.rasterToWorld(pt);
|
||
852 | } |
||
853 | |||
854 | /*
|
||
855 | * (non-Javadoc)
|
||
856 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#worldToRaster(java.awt.geom.Point2D)
|
||
857 | */
|
||
858 | public Point2D worldToRaster(Point2D pt) { |
||
859 | return provider.worldToRaster(pt);
|
||
860 | } |
||
861 | |||
862 | /*
|
||
863 | * (non-Javadoc)
|
||
864 | * @see org.gvsig.raster.impl.store.QueryableRaster#calcSteps(double, double, double, double, double, double, int, int)
|
||
865 | */
|
||
866 | public double[] calcSteps(double dWorldTLX, double dWorldTLY, double dWorldBRX, double dWorldBRY, |
||
867 | double nWidth, double nHeight, int bufWidth, int bufHeight){ |
||
868 | return provider.calcSteps(dWorldTLX, dWorldTLY, dWorldBRX, dWorldBRY, nWidth, nHeight, bufWidth, bufHeight);
|
||
869 | } |
||
870 | |||
871 | /*
|
||
872 | * (non-Javadoc)
|
||
873 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#isGeoreferenced()
|
||
874 | */
|
||
875 | public boolean isGeoreferenced() { |
||
876 | return provider.isGeoreferenced();
|
||
877 | } |
||
878 | |||
879 | /*
|
||
880 | * (non-Javadoc)
|
||
881 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getPixelSizeX()
|
||
882 | */
|
||
883 | public double getPixelSizeX() { |
||
884 | return provider.getPixelSizeX();
|
||
885 | } |
||
886 | |||
887 | /*
|
||
888 | * (non-Javadoc)
|
||
889 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getPixelSizeY()
|
||
890 | */
|
||
891 | public double getPixelSizeY() { |
||
892 | return provider.getPixelSizeY();
|
||
893 | } |
||
894 | |||
895 | /*
|
||
896 | * (non-Javadoc)
|
||
897 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getData(int, int, int)
|
||
898 | */
|
||
899 | public Object getData(int x, int y, int band)throws InvalidSetViewException, FileNotOpenException, RasterDriverException { |
||
900 | return provider.getData(x, y, band);
|
||
901 | } |
||
902 | |||
903 | /*
|
||
904 | * (non-Javadoc)
|
||
905 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getWktProjection()
|
||
906 | */
|
||
907 | public String getWktProjection() throws RasterDriverException { |
||
908 | 953 | nbrodin | if(provider != null) |
909 | return provider.getWktProjection();
|
||
910 | return null; |
||
911 | 689 | nbrodin | } |
912 | |||
913 | /*
|
||
914 | * (non-Javadoc)
|
||
915 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#isInside(java.awt.geom.Point2D)
|
||
916 | */
|
||
917 | public boolean isInside(Point2D p) { |
||
918 | if(provider != null) |
||
919 | return provider.isInside(p);
|
||
920 | return false; |
||
921 | } |
||
922 | |||
923 | /*
|
||
924 | * (non-Javadoc)
|
||
925 | * @see org.gvsig.raster.impl.store.QueryableRaster#getDataStore()
|
||
926 | */
|
||
927 | public RasterDataStore getDataStore() {
|
||
928 | return this; |
||
929 | } |
||
930 | |||
931 | /**
|
||
932 | *
|
||
933 | * @param band
|
||
934 | * @return
|
||
935 | */
|
||
936 | public AffineTransform getAffineTransform(int band){ |
||
937 | return provider.getAffineTransform();
|
||
938 | } |
||
939 | |||
940 | |||
941 | /*
|
||
942 | * (non-Javadoc)
|
||
943 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#setAffineTransform(java.awt.geom.AffineTransform)
|
||
944 | */
|
||
945 | public void setAffineTransform(AffineTransform transf) { |
||
946 | provider.setAffineTransform(transf); |
||
947 | } |
||
948 | |||
949 | /**
|
||
950 | * Obtiene la matriz de transformaci?n del propio raster. Esta matriz es la encargada
|
||
951 | * de convertir las coordenadas de la petici?n en coordenadas a las que se pide a la libreria.
|
||
952 | * En gdal, por ejemplo, se piden las coordenadas a la libreria en coordenadas pixel por lo que
|
||
953 | * esta matriz tendr? la georreferenciaci?n asociada en el worldfile o cabecera. Otras librerias como
|
||
954 | * ermapper la petici?n a la libreria se hace en coordenadas geograficas que son las mismas en las
|
||
955 | * que pide el usuario de gvSIG por lo que esta matriz en este caso se inicializa con la identidad.
|
||
956 | * @return
|
||
957 | */
|
||
958 | public AffineTransform getOwnTransformation() { |
||
959 | return provider.getOwnAffineTransform();
|
||
960 | } |
||
961 | |||
962 | /*
|
||
963 | * (non-Javadoc)
|
||
964 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#isRotated()
|
||
965 | */
|
||
966 | public boolean isRotated() { |
||
967 | if(provider != null) |
||
968 | return provider.isRotated();
|
||
969 | return false; |
||
970 | } |
||
971 | |||
972 | /*
|
||
973 | * (non-Javadoc)
|
||
974 | * @see org.gvsig.raster.impl.store.QueryableRaster#setDrawableBands(int[])
|
||
975 | */
|
||
976 | public void setDrawableBands(int[] db) { |
||
977 | getBands().setDrawableBands(db); |
||
978 | } |
||
979 | |||
980 | /*
|
||
981 | * (non-Javadoc)
|
||
982 | * @see org.gvsig.raster.impl.store.QueryableRaster#getDrawableBands()
|
||
983 | */
|
||
984 | public int[] getDrawableBands() { |
||
985 | return getBands().getDrawableBands();
|
||
986 | } |
||
987 | |||
988 | /*
|
||
989 | * (non-Javadoc)
|
||
990 | * @see org.gvsig.raster.impl.store.QueryableRaster#clearDrawableBands()
|
||
991 | */
|
||
992 | public void clearDrawableBands() { |
||
993 | getBands().clearDrawableBands(); |
||
994 | } |
||
995 | |||
996 | /*
|
||
997 | * (non-Javadoc)
|
||
998 | * @see org.gvsig.raster.impl.store.QueryableRaster#addDrawableBand(int, int)
|
||
999 | */
|
||
1000 | public void addDrawableBand(int posRasterBuf, int imageBand) { |
||
1001 | getBands().addDrawableBand(posRasterBuf, imageBand); |
||
1002 | } |
||
1003 | |||
1004 | /**
|
||
1005 | *
|
||
1006 | * @return
|
||
1007 | */
|
||
1008 | public boolean isReadOnly() { |
||
1009 | return readOnly;
|
||
1010 | } |
||
1011 | |||
1012 | /**
|
||
1013 | *
|
||
1014 | * @param readOnly
|
||
1015 | */
|
||
1016 | public void setReadOnly(boolean readOnly) { |
||
1017 | this.readOnly = readOnly;
|
||
1018 | if(readOnly)
|
||
1019 | this.forceToMemory = false; |
||
1020 | } |
||
1021 | |||
1022 | /*
|
||
1023 | * (non-Javadoc)
|
||
1024 | * @see org.gvsig.raster.impl.store.QueryableRaster#setMemoryBuffer(boolean)
|
||
1025 | */
|
||
1026 | public void setMemoryBuffer(boolean memory) { |
||
1027 | this.forceToMemory = memory;
|
||
1028 | if(memory)
|
||
1029 | this.readOnly = false; |
||
1030 | } |
||
1031 | |||
1032 | /**
|
||
1033 | *
|
||
1034 | * @return
|
||
1035 | */
|
||
1036 | public boolean isMemoryBuffer() { |
||
1037 | return forceToMemory;
|
||
1038 | } |
||
1039 | |||
1040 | /*
|
||
1041 | * (non-Javadoc)
|
||
1042 | 859 | nbrodin | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#deleteLayerFromCache()
|
1043 | */
|
||
1044 | public void deleteLayerFromCache() { |
||
1045 | provider.deleteLayerFromCache(); |
||
1046 | } |
||
1047 | |||
1048 | /*
|
||
1049 | * (non-Javadoc)
|
||
1050 | 724 | nbrodin | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#isMultiFile()
|
1051 | */
|
||
1052 | public boolean isMultiFile() { |
||
1053 | return provider.isMultiFile();
|
||
1054 | } |
||
1055 | |||
1056 | /*
|
||
1057 | * (non-Javadoc)
|
||
1058 | 689 | nbrodin | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getOverviewWidth(int, int)
|
1059 | */
|
||
1060 | public int getOverviewWidth(int band, int overview) throws BandAccessException, RasterDriverException { |
||
1061 | return provider.getOverviewWidth(band, overview);
|
||
1062 | } |
||
1063 | |||
1064 | /*
|
||
1065 | * (non-Javadoc)
|
||
1066 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getOverviewHeight(int, int)
|
||
1067 | */
|
||
1068 | public int getOverviewHeight(int band, int overview) throws BandAccessException, RasterDriverException { |
||
1069 | return provider.getOverviewHeight(band, overview);
|
||
1070 | } |
||
1071 | |||
1072 | /*
|
||
1073 | * (non-Javadoc)
|
||
1074 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getOverviewCount(int)
|
||
1075 | */
|
||
1076 | public int getOverviewCount(int band) throws BandAccessException, RasterDriverException { |
||
1077 | if(band >= getBandCount())
|
||
1078 | throw new BandAccessException("Wrong band"); |
||
1079 | return provider.getOverviewCount(band);
|
||
1080 | } |
||
1081 | |||
1082 | /*
|
||
1083 | * (non-Javadoc)
|
||
1084 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#overviewsSupport()
|
||
1085 | */
|
||
1086 | public boolean overviewsSupport() { |
||
1087 | if(provider != null) |
||
1088 | return provider.isOverviewsSupported();
|
||
1089 | return false; |
||
1090 | } |
||
1091 | |||
1092 | /*
|
||
1093 | * (non-Javadoc)
|
||
1094 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#saveGeoreferencingToRmf()
|
||
1095 | */
|
||
1096 | public void saveGeoreferencingToRmf() throws RmfSerializerException { |
||
1097 | provider.saveObjectToRmf(DefaultRasterProvider.class, provider); |
||
1098 | } |
||
1099 | |||
1100 | /*
|
||
1101 | * (non-Javadoc)
|
||
1102 | * @see org.gvsig.raster.impl.store.AbstractRasterDataStore#saveSerialInfoToRmf(org.gvsig.fmap.dal.coverage.store.props.SerialInfo)
|
||
1103 | */
|
||
1104 | public void saveSerialInfoToRmf(TimeSeries serialInfo) throws RmfSerializerException { |
||
1105 | provider.saveObjectToRmf(TimeSeries.class, serialInfo); |
||
1106 | } |
||
1107 | |||
1108 | /*
|
||
1109 | * (non-Javadoc)
|
||
1110 | * @see org.gvsig.raster.impl.store.AbstractRasterDataStore#saveColorTableToRmf(org.gvsig.fmap.dal.coverage.store.props.ColorTable)
|
||
1111 | */
|
||
1112 | public void saveColorTableToRmf(ColorTable table) throws RmfSerializerException { |
||
1113 | provider.saveObjectToRmf(ColorTable.class, table); |
||
1114 | } |
||
1115 | |||
1116 | /*
|
||
1117 | * (non-Javadoc)
|
||
1118 | * @see org.gvsig.raster.impl.store.AbstractRasterDataStore#loadSerialInfoFromRmf(org.gvsig.fmap.dal.coverage.store.props.SerialInfo)
|
||
1119 | */
|
||
1120 | public boolean loadSerialInfoFromRmf(TimeSeries serialInfo) { |
||
1121 | try {
|
||
1122 | provider.loadObjectFromRmf(TimeSeries.class, serialInfo); |
||
1123 | return true; |
||
1124 | } catch (RmfSerializerException e) {
|
||
1125 | //Prueba hasta que alguno tiene la informaci?n
|
||
1126 | } |
||
1127 | return false; |
||
1128 | } |
||
1129 | |||
1130 | /*
|
||
1131 | * (non-Javadoc)
|
||
1132 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getView()
|
||
1133 | */
|
||
1134 | public Extent getView() {
|
||
1135 | if(provider != null) |
||
1136 | return provider.getView();
|
||
1137 | return null; |
||
1138 | } |
||
1139 | |||
1140 | /*
|
||
1141 | * (non-Javadoc)
|
||
1142 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getExtentWithoutRot()
|
||
1143 | */
|
||
1144 | public Extent getExtentWithoutRot() {
|
||
1145 | if(provider != null) |
||
1146 | return provider.getExtentWithoutRot();
|
||
1147 | return null; |
||
1148 | } |
||
1149 | |||
1150 | /*
|
||
1151 | * (non-Javadoc)
|
||
1152 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getOwnAffineTransform()
|
||
1153 | */
|
||
1154 | public AffineTransform getOwnAffineTransform() { |
||
1155 | if(provider != null) |
||
1156 | return provider.getOwnAffineTransform();
|
||
1157 | return null; |
||
1158 | } |
||
1159 | |||
1160 | /*
|
||
1161 | * (non-Javadoc)
|
||
1162 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getAffineTransform()
|
||
1163 | */
|
||
1164 | public AffineTransform getAffineTransform() { |
||
1165 | 1277 | nbrodin | if(provider != null) { |
1166 | AffineTransform at = provider.getAffineTransform();
|
||
1167 | /*if (coordTrans != null) {
|
||
1168 | Point2D scale = new Point2D.Double(at.getTranslateX() + at.getScaleX(), at.getTranslateY() + at.getScaleY());
|
||
1169 | Point2D translate = new Point2D.Double(at.getTranslateX(), at.getTranslateY());
|
||
1170 | scale = coordTrans.convert(scale, scale);
|
||
1171 | translate = coordTrans.convert(translate, translate);
|
||
1172 | double sX = scale.getX() - translate.getX();
|
||
1173 | double sY = scale.getY() - translate.getY();
|
||
1174 | at = new AffineTransform(
|
||
1175 | sX,
|
||
1176 | at.getShearY(),
|
||
1177 | at.getShearX(),
|
||
1178 | sY,
|
||
1179 | translate.getX(),
|
||
1180 | translate.getY());
|
||
1181 | }*/
|
||
1182 | return at;
|
||
1183 | } |
||
1184 | 689 | nbrodin | return null; |
1185 | } |
||
1186 | |||
1187 | /*
|
||
1188 | * (non-Javadoc)
|
||
1189 | 779 | nbrodin | * @see org.gvsig.fmap.dal.coverage.store.RasterStoreProperties#getProjection()
|
1190 | 689 | nbrodin | */
|
1191 | public IProjection getProjection() {
|
||
1192 | if(provider != null) |
||
1193 | return provider.getProjection();
|
||
1194 | return null; |
||
1195 | } |
||
1196 | |||
1197 | /*
|
||
1198 | * (non-Javadoc)
|
||
1199 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getStatistics()
|
||
1200 | */
|
||
1201 | public Statistics getStatistics() {
|
||
1202 | if(provider != null) |
||
1203 | return provider.getStatistics();
|
||
1204 | return null; |
||
1205 | } |
||
1206 | |||
1207 | 746 | nbrodin | private void setStatistics(Statistics stats) { |
1208 | if(provider != null) |
||
1209 | provider.setStatistics(stats); |
||
1210 | } |
||
1211 | |||
1212 | 689 | nbrodin | /*
|
1213 | * (non-Javadoc)
|
||
1214 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getHistogram()
|
||
1215 | */
|
||
1216 | 1081 | nbrodin | public HistogramComputer getHistogramComputer() {
|
1217 | 694 | nbrodin | if(provider != null) |
1218 | return provider.getHistogramComputer();
|
||
1219 | return null; |
||
1220 | 689 | nbrodin | } |
1221 | |||
1222 | /*
|
||
1223 | * (non-Javadoc)
|
||
1224 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getMetadata()
|
||
1225 | */
|
||
1226 | public Metadata getMetadata() {
|
||
1227 | if(provider != null) |
||
1228 | return provider.getMetadata();
|
||
1229 | return null; |
||
1230 | } |
||
1231 | |||
1232 | /*
|
||
1233 | * (non-Javadoc)
|
||
1234 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getTransparency()
|
||
1235 | */
|
||
1236 | public Transparency getTransparency() { |
||
1237 | 969 | nbrodin | if(provider != null) { |
1238 | provider.getTransparency().setNoData(getNoDataValue()); |
||
1239 | 689 | nbrodin | return provider.getTransparency();
|
1240 | 969 | nbrodin | } |
1241 | 689 | nbrodin | return null; |
1242 | } |
||
1243 | |||
1244 | /*
|
||
1245 | * (non-Javadoc)
|
||
1246 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getColorInterpretation()
|
||
1247 | */
|
||
1248 | public ColorInterpretation getColorInterpretation() {
|
||
1249 | return provider.getColorInterpretation();
|
||
1250 | } |
||
1251 | |||
1252 | /*
|
||
1253 | * (non-Javadoc)
|
||
1254 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#isReproyectable()
|
||
1255 | */
|
||
1256 | public boolean isReproyectable() { |
||
1257 | if(provider != null) |
||
1258 | return (provider.isReproyectable());
|
||
1259 | return false; |
||
1260 | } |
||
1261 | |||
1262 | /*
|
||
1263 | * (non-Javadoc)
|
||
1264 | * @see org.gvsig.metadata.Metadata#getMetadataName()
|
||
1265 | */
|
||
1266 | public String getMetadataName() { |
||
1267 | if(provider != null) |
||
1268 | return provider.getName();
|
||
1269 | return null; |
||
1270 | } |
||
1271 | |||
1272 | /*
|
||
1273 | * (non-Javadoc)
|
||
1274 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#cloneDataStore()
|
||
1275 | */
|
||
1276 | public RasterDataStore cloneDataStore() throws CloneException { |
||
1277 | DefaultRasterStore ds = new DefaultRasterStore();
|
||
1278 | ds.parameters = getParameters(); |
||
1279 | ds.provider = provider.cloneProvider(); |
||
1280 | |||
1281 | int[] bands = new int[1]; |
||
1282 | bands[0] = provider.getBandCount();
|
||
1283 | ds.metadata = new MultiDataStoreMetadata(bands);
|
||
1284 | ((MultiDataStoreMetadata)ds.metadata).add(provider.getMetadata()); |
||
1285 | |||
1286 | ds.bandList = (BandListImpl)bandList.clone(); |
||
1287 | return ds;
|
||
1288 | } |
||
1289 | |||
1290 | /*
|
||
1291 | * (non-Javadoc)
|
||
1292 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#isOpen()
|
||
1293 | */
|
||
1294 | public boolean isOpen() { |
||
1295 | if(provider == null) |
||
1296 | return false; |
||
1297 | return provider.isOpen();
|
||
1298 | } |
||
1299 | |||
1300 | /*
|
||
1301 | * (non-Javadoc)
|
||
1302 | * @see org.gvsig.raster.impl.store.AbstractRasterDataStore#getProvider()
|
||
1303 | */
|
||
1304 | public CoverageStoreProvider getProvider() {
|
||
1305 | return provider;
|
||
1306 | } |
||
1307 | |||
1308 | /*
|
||
1309 | * (non-Javadoc)
|
||
1310 | * @see org.gvsig.fmap.dal.coverage.store.RemoteRasterStore#getInfoByPoint(double, double)
|
||
1311 | */
|
||
1312 | public String getInfoByPoint(double x, double y, ICancellable cancellable) throws RemoteServiceException { |
||
1313 | return null; |
||
1314 | } |
||
1315 | |||
1316 | /*
|
||
1317 | * (non-Javadoc)
|
||
1318 | * @see org.gvsig.fmap.dal.coverage.store.TRasterStore#goTo(int)
|
||
1319 | */
|
||
1320 | public void goTo(int position) throws OperationNotSupportedException { |
||
1321 | if(!isTimeSupportedByTheProvider())
|
||
1322 | throw new OperationNotSupportedException("Not supported for a MultiRasterDataset"); |
||
1323 | if(getParameters() instanceof MultiDimensionalStoreParameters) { |
||
1324 | ((MultiDimensionalStoreParameters)getParameters()).goTo(position); |
||
1325 | } |
||
1326 | } |
||
1327 | |||
1328 | /*
|
||
1329 | * (non-Javadoc)
|
||
1330 | * @see org.gvsig.fmap.dal.coverage.store.TRasterStore#selectNext()
|
||
1331 | */
|
||
1332 | public void selectNext() throws OperationNotSupportedException { |
||
1333 | if(!isTimeSupportedByTheProvider())
|
||
1334 | throw new OperationNotSupportedException("Not supported for a MultiRasterDataset"); |
||
1335 | if(getParameters() instanceof MultiDimensionalStoreParameters) { |
||
1336 | ((MultiDimensionalStoreParameters)getParameters()).selectNextInstant(); |
||
1337 | } |
||
1338 | } |
||
1339 | |||
1340 | /*
|
||
1341 | * (non-Javadoc)
|
||
1342 | * @see org.gvsig.fmap.dal.coverage.store.TRasterStore#selectPrev()
|
||
1343 | */
|
||
1344 | public void selectPrev() throws OperationNotSupportedException { |
||
1345 | if(!isTimeSupportedByTheProvider())
|
||
1346 | throw new OperationNotSupportedException("Not supported for a MultiRasterDataset"); |
||
1347 | if(getParameters() instanceof MultiDimensionalStoreParameters) { |
||
1348 | ((MultiDimensionalStoreParameters)getParameters()).selectPrevInstant(); |
||
1349 | } |
||
1350 | } |
||
1351 | |||
1352 | /*
|
||
1353 | * (non-Javadoc)
|
||
1354 | * @see org.gvsig.fmap.dal.coverage.store.TRasterStore#setTime(org.gvsig.timesupport.Time)
|
||
1355 | */
|
||
1356 | public void setTime(Time time) throws TimeException, OperationNotSupportedException { |
||
1357 | if(!isTimeSupportedByTheProvider())
|
||
1358 | throw new OperationNotSupportedException("Not supported for a MultiRasterDataset"); |
||
1359 | |||
1360 | } |
||
1361 | |||
1362 | /**
|
||
1363 | * Returns true whether all providers support time
|
||
1364 | * @return
|
||
1365 | */
|
||
1366 | private boolean isTimeSupportedByTheProvider() { |
||
1367 | if(provider != null) |
||
1368 | return provider.isTimeSupported();
|
||
1369 | return false; |
||
1370 | } |
||
1371 | |||
1372 | /*
|
||
1373 | * (non-Javadoc)
|
||
1374 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#isRasterEnclosed()
|
||
1375 | */
|
||
1376 | public boolean isRasterEnclosed() { |
||
1377 | if(provider != null) |
||
1378 | return provider.isRasterEnclosed();
|
||
1379 | return false; |
||
1380 | } |
||
1381 | |||
1382 | /*
|
||
1383 | * (non-Javadoc)
|
||
1384 | * @see org.gvsig.fmap.dal.coverage.store.RemoteRasterStore#getCoordsInLevel(java.awt.geom.Point2D, int, int, int)
|
||
1385 | */
|
||
1386 | public Extent getCoordsInLevel(Point2D viewCenter, int level, int w, int h) { |
||
1387 | try {
|
||
1388 | return ((TiledRasterProvider)provider).getCoordsInLevel(viewCenter, level, w, h);
|
||
1389 | } catch (ClassCastException e) { |
||
1390 | return null; |
||
1391 | } |
||
1392 | } |
||
1393 | |||
1394 | /*
|
||
1395 | * (non-Javadoc)
|
||
1396 | * @see org.gvsig.fmap.dal.coverage.store.RemoteRasterStore#getCoordsInTheNearestLevel(org.gvsig.fmap.dal.coverage.datastruct.Extent, int, int)
|
||
1397 | */
|
||
1398 | public Extent getCoordsInTheNearestLevel(Extent extent, int w, int h) { |
||
1399 | try {
|
||
1400 | return ((TiledRasterProvider)provider).getCoordsInTheNearestLevel(extent, w, h);
|
||
1401 | } catch (ClassCastException e) { |
||
1402 | return null; |
||
1403 | } |
||
1404 | } |
||
1405 | |||
1406 | /*
|
||
1407 | * (non-Javadoc)
|
||
1408 | * @see org.gvsig.fmap.dal.coverage.store.RemoteRasterStore#getZoomLevels()
|
||
1409 | */
|
||
1410 | public int getZoomLevels() { |
||
1411 | try {
|
||
1412 | return ((TiledRasterProvider)provider).getZoomLevels();
|
||
1413 | } catch (ClassCastException e) { |
||
1414 | return -1; |
||
1415 | } |
||
1416 | } |
||
1417 | |||
1418 | /*
|
||
1419 | * (non-Javadoc)
|
||
1420 | * @see org.gvsig.fmap.dal.coverage.store.RemoteRasterStore#getNearestLevel(double)
|
||
1421 | */
|
||
1422 | public int getNearestLevel(double pixelSize) { |
||
1423 | try {
|
||
1424 | return ((TiledRasterProvider)provider).getNearestLevel(pixelSize);
|
||
1425 | } catch (ClassCastException e) { |
||
1426 | return -1; |
||
1427 | } |
||
1428 | } |
||
1429 | |||
1430 | /*
|
||
1431 | * (non-Javadoc)
|
||
1432 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#setTileServer(java.lang.Class)
|
||
1433 | */
|
||
1434 | 1356 | nbrodin | public void setTileServer(Class<?> tileServer) throws InitializeException { |
1435 | 689 | nbrodin | if(provider instanceof TiledRasterProvider) { |
1436 | 1356 | nbrodin | ((TiledRasterProvider)provider).setTileServer(tileServer); |
1437 | 689 | nbrodin | } |
1438 | } |
||
1439 | |||
1440 | /*
|
||
1441 | * (non-Javadoc)
|
||
1442 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getInternalParameters()
|
||
1443 | */
|
||
1444 | public RasterDataParameters getInternalParameters() {
|
||
1445 | if(provider instanceof TiledRasterProvider) { |
||
1446 | DefaultRasterProvider prov = (DefaultRasterProvider)((TiledRasterProvider)provider).getInternalProvider(); |
||
1447 | 723 | nbrodin | return prov.getDataParameters();
|
1448 | 689 | nbrodin | } |
1449 | return (RasterDataParameters)getParameters();
|
||
1450 | } |
||
1451 | |||
1452 | /*
|
||
1453 | * (non-Javadoc)
|
||
1454 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#newDataStore()
|
||
1455 | */
|
||
1456 | public RasterDataStore newDataStore() {
|
||
1457 | if(provider != null) { |
||
1458 | RasterManager manager = (DefaultRasterManager)RasterLocator.getManager(); |
||
1459 | try {
|
||
1460 | 746 | nbrodin | RasterDataStore newDataStore = manager.open((DataStoreParameters)parameters); |
1461 | if(newDataStore instanceof DefaultRasterStore) { |
||
1462 | ((DefaultRasterStore)newDataStore).setStatistics(getStatistics()); |
||
1463 | } |
||
1464 | return newDataStore;
|
||
1465 | 689 | nbrodin | } catch (NotSupportedExtensionException e) {
|
1466 | return null; |
||
1467 | } catch (RasterDriverException e) {
|
||
1468 | return null; |
||
1469 | } |
||
1470 | } |
||
1471 | return null; |
||
1472 | } |
||
1473 | |||
1474 | /*
|
||
1475 | * (non-Javadoc)
|
||
1476 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getFileNameByProvider()
|
||
1477 | */
|
||
1478 | public String[] getURIByProvider() { |
||
1479 | return provider.getURIByProvider();
|
||
1480 | } |
||
1481 | |||
1482 | /*
|
||
1483 | * (non-Javadoc)
|
||
1484 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getFileSizeByProvider()
|
||
1485 | */
|
||
1486 | public long[] getFileSizeByProvider() { |
||
1487 | return provider.getFileSizeByProvider();
|
||
1488 | } |
||
1489 | |||
1490 | /*
|
||
1491 | * (non-Javadoc)
|
||
1492 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getProviderCount()
|
||
1493 | */
|
||
1494 | public int getProviderCount() { |
||
1495 | return provider.getInternalProviderCount();
|
||
1496 | } |
||
1497 | |||
1498 | /*
|
||
1499 | * (non-Javadoc)
|
||
1500 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getBandCountByProvider()
|
||
1501 | */
|
||
1502 | public int[] getBandCountByProvider() { |
||
1503 | return provider.getBandCountByProvider();
|
||
1504 | } |
||
1505 | |||
1506 | /*
|
||
1507 | * (non-Javadoc)
|
||
1508 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getDataParametersByProvider()
|
||
1509 | */
|
||
1510 | public RasterDataParameters[] getDataParametersByProvider() { |
||
1511 | RasterDataParameters[] res = new RasterDataParameters[getProviderCount()]; |
||
1512 | for (int i = 0; i < res.length; i++) { |
||
1513 | res[i] = (RasterDataParameters)provider.getInternalProvider(i).getDataParameters(); |
||
1514 | } |
||
1515 | return res;
|
||
1516 | } |
||
1517 | |||
1518 | /*
|
||
1519 | * (non-Javadoc)
|
||
1520 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getMetadataByProvider()
|
||
1521 | */
|
||
1522 | public Metadata[] getMetadataByProvider() { |
||
1523 | Metadata[] res = new Metadata[getProviderCount()]; |
||
1524 | for (int i = 0; i < res.length; i++) { |
||
1525 | res[i] = provider.getInternalProvider(i).getMetadata(); |
||
1526 | } |
||
1527 | return res;
|
||
1528 | } |
||
1529 | |||
1530 | /*
|
||
1531 | * (non-Javadoc)
|
||
1532 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getOverviewCountByProvider()
|
||
1533 | */
|
||
1534 | public int[] getOverviewCountByProvider(int band) throws BandAccessException { |
||
1535 | int[] res = new int[getProviderCount()]; |
||
1536 | for (int i = 0; i < res.length; i++) { |
||
1537 | try {
|
||
1538 | res[i] = provider.getInternalProvider(i).getOverviewCount(band); |
||
1539 | } catch (RasterDriverException e) {
|
||
1540 | throw new BandAccessException("", e); |
||
1541 | } |
||
1542 | } |
||
1543 | return res;
|
||
1544 | } |
||
1545 | |||
1546 | /*
|
||
1547 | * (non-Javadoc)
|
||
1548 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getOverviewSizeByProvider(int, int)
|
||
1549 | */
|
||
1550 | public String[] getOverviewSizeByProvider(int band, int overview) throws BandAccessException { |
||
1551 | String[] res = new String[getProviderCount()]; |
||
1552 | for (int i = 0; i < res.length; i++) { |
||
1553 | try {
|
||
1554 | res[i] = provider.getInternalProvider(i).getOverviewWidth(band, overview) + |
||
1555 | "x" +
|
||
1556 | provider.getInternalProvider(i).getOverviewHeight(band, overview); |
||
1557 | } catch (RasterDriverException e) {
|
||
1558 | throw new BandAccessException("", e); |
||
1559 | } |
||
1560 | } |
||
1561 | return res;
|
||
1562 | } |
||
1563 | |||
1564 | /*
|
||
1565 | * (non-Javadoc)
|
||
1566 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getAffineTransformByProvider()
|
||
1567 | */
|
||
1568 | public AffineTransform[] getAffineTransformByProvider() { |
||
1569 | AffineTransform[] res = new AffineTransform[getProviderCount()]; |
||
1570 | for (int i = 0; i < res.length; i++) { |
||
1571 | res[i] = provider.getInternalProvider(i).getAffineTransform(); |
||
1572 | } |
||
1573 | return res;
|
||
1574 | } |
||
1575 | |||
1576 | /*
|
||
1577 | * (non-Javadoc)
|
||
1578 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getHeightByProvider()
|
||
1579 | */
|
||
1580 | public double[] getHeightByProvider() { |
||
1581 | double[] res = new double[getProviderCount()]; |
||
1582 | for (int i = 0; i < res.length; i++) { |
||
1583 | res[i] = provider.getInternalProvider(i).getHeight(); |
||
1584 | } |
||
1585 | return res;
|
||
1586 | } |
||
1587 | |||
1588 | /*
|
||
1589 | * (non-Javadoc)
|
||
1590 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getWidthByProvider()
|
||
1591 | */
|
||
1592 | public double[] getWidthByProvider() { |
||
1593 | double[] res = new double[getProviderCount()]; |
||
1594 | for (int i = 0; i < res.length; i++) { |
||
1595 | res[i] = provider.getInternalProvider(i).getWidth(); |
||
1596 | } |
||
1597 | return res;
|
||
1598 | } |
||
1599 | |||
1600 | /*
|
||
1601 | * (non-Javadoc)
|
||
1602 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#addFile(java.lang.String)
|
||
1603 | */
|
||
1604 | public void addFile(String file) throws InvalidSourceException { |
||
1605 | provider.addFile(file); |
||
1606 | } |
||
1607 | |||
1608 | /*
|
||
1609 | * (non-Javadoc)
|
||
1610 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#removeFile(java.lang.String)
|
||
1611 | */
|
||
1612 | public void removeFile(String file) { |
||
1613 | provider.removeFile(file); |
||
1614 | 692 | nbrodin | bandList.removeBands(file); |
1615 | 689 | nbrodin | } |
1616 | |||
1617 | /*
|
||
1618 | * (non-Javadoc)
|
||
1619 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#getURIByBand(int)
|
||
1620 | */
|
||
1621 | public String getURIByBand(int band) { |
||
1622 | return provider.getURIByBand(band);
|
||
1623 | } |
||
1624 | 857 | nbrodin | |
1625 | /**
|
||
1626 | * Gets the {@link Interval} of the store, that means the temporal
|
||
1627 | * interval where the store has valid data.
|
||
1628 | * In raster this method has sense in a mosaic. Therefore this has to be implemented
|
||
1629 | * by the provider.
|
||
1630 | * @return
|
||
1631 | * a time interval or null if there is not time support
|
||
1632 | */
|
||
1633 | public Interval getInterval() {
|
||
1634 | return provider.getInterval();
|
||
1635 | } |
||
1636 | |||
1637 | /**
|
||
1638 | * Gets all the possible values of time for which the store has data.
|
||
1639 | * In raster this method has sense in a mosaic. Therefore this has to be implemented
|
||
1640 | * by the provider.
|
||
1641 | * @return
|
||
1642 | * a collection of {@link Time} objects.
|
||
1643 | */
|
||
1644 | @SuppressWarnings("unchecked") |
||
1645 | public Collection getTimes() { |
||
1646 | return provider.getTimes();
|
||
1647 | } |
||
1648 | |||
1649 | /**
|
||
1650 | * Gets all the possible values of time for which the store has data
|
||
1651 | * and intersects with an interval.
|
||
1652 | * In raster this method has sense in a mosaic. Therefore this has to be implemented
|
||
1653 | * by the provider.
|
||
1654 | * @param interval
|
||
1655 | * the interval of time
|
||
1656 | * @return
|
||
1657 | * a collection of {@link Time} objects.
|
||
1658 | */
|
||
1659 | @SuppressWarnings("unchecked") |
||
1660 | public Collection getTimes(Interval interval) { |
||
1661 | return provider.getTimes(interval);
|
||
1662 | } |
||
1663 | 1082 | nbrodin | |
1664 | /*
|
||
1665 | * (non-Javadoc)
|
||
1666 | * @see org.gvsig.fmap.dal.coverage.store.RasterStoreProperties#getImageLegend()
|
||
1667 | */
|
||
1668 | public Image getImageLegend() { |
||
1669 | return provider.getImageLegend();
|
||
1670 | } |
||
1671 | 753 | nbrodin | |
1672 | /*
|
||
1673 | * (non-Javadoc)
|
||
1674 | * @see org.gvsig.raster.impl.store.AbstractRasterDataStore#loadFromState(org.gvsig.tools.persistence.PersistentState)
|
||
1675 | */
|
||
1676 | 762 | nbrodin | @SuppressWarnings("unchecked") |
1677 | 753 | nbrodin | public void loadFromState(PersistentState state) |
1678 | throws PersistenceException {
|
||
1679 | 776 | nbrodin | if(parameters == null) |
1680 | this.parameters = (RasterDataParameters)state.get("parameters"); |
||
1681 | 753 | nbrodin | DataManagerProviderServices dataManager = (DataManagerProviderServices)DALLocator.getDataManager(); |
1682 | try {
|
||
1683 | this.provider = (DefaultRasterProvider)dataManager.createProvider(this, this.parameters); |
||
1684 | } catch (InitializeException e) {
|
||
1685 | 776 | nbrodin | //throw new PersistenceException(e);
|
1686 | 753 | nbrodin | } catch (ProviderNotRegisteredException e) {
|
1687 | throw new PersistenceException(e); |
||
1688 | } |
||
1689 | this.bandList = (BandListImpl)state.get("bandList"); |
||
1690 | 1328 | nbrodin | if(parameters instanceof AbstractRasterFileDataParameters && !this.provider.isMultiFile()) { |
1691 | //Esto solo es por si al cargar un proyecto se ha cambiado el fichero de sitio y el usuario
|
||
1692 | //lo introduce manualmente. En ese caso el bandList debe contener la misma ruta al fichero que el
|
||
1693 | //provider y no la que se grab? inicialmente
|
||
1694 | for (int i = 0; i < bandList.getBandCount(); i++) { |
||
1695 | bandList.getBand(i).setFileName(provider.getURI()); |
||
1696 | } |
||
1697 | } |
||
1698 | 753 | nbrodin | this.metadata = (Metadata)state.get("metadata"); |
1699 | 758 | nbrodin | setRender((Render)state.get("render"));
|
1700 | 772 | nbrodin | int[] rb = getRender().getRenderBands(); //Evitamos que las bandas que fueron cargadas se machaquen ahora |
1701 | 758 | nbrodin | getRender().setDataStore(this);
|
1702 | 772 | nbrodin | getRender().setRenderBands(rb); |
1703 | 859 | nbrodin | if(getRender().getLastTransparency() != null) |
1704 | getRender().getLastTransparency().setNoData(getNoDataValue()); |
||
1705 | 762 | nbrodin | |
1706 | RasterFilterList fList = (RasterFilterList)state.get("filterList");
|
||
1707 | fList.addEnvParam("IStatistics", getStatistics());
|
||
1708 | fList.addEnvParam("MultiRasterDataset", this); |
||
1709 | getRender().setFilterList(fList); |
||
1710 | |||
1711 | //Gets the filter parameters and loads the filters
|
||
1712 | List<PersistencyFilterParam> listFilterUsed = state.getList("paramlist"); |
||
1713 | |||
1714 | ArrayList<Exception> exc = new ArrayList<Exception>(); |
||
1715 | for (int i = 0; i < listFilterUsed.size(); i++) { |
||
1716 | try {
|
||
1717 | PersistencyFilterParam pfp = (PersistencyFilterParam) listFilterUsed.get(i); |
||
1718 | if(pfp != null && pfp.getFilterClass() != null && pfp.getFilterParam() != null) { |
||
1719 | RasterFilterListManager filterManager = fList.getManagerByFilterClass(pfp.getFilterClass()); |
||
1720 | filterManager.setFilterList(fList); |
||
1721 | if(filterManager != null) |
||
1722 | filterManager.addFilter(pfp.getFilterClass(), pfp.getFilterParam()); |
||
1723 | } |
||
1724 | } catch (FilterTypeException e) {
|
||
1725 | exc.add(e); |
||
1726 | } catch (FilterManagerException e) {
|
||
1727 | exc.add(e); |
||
1728 | } |
||
1729 | } |
||
1730 | |||
1731 | if(exc.size() != 0) { |
||
1732 | throw new PersistenceException("error_adding_filters", exc.get(0)); |
||
1733 | } |
||
1734 | 753 | nbrodin | } |
1735 | |||
1736 | /*
|
||
1737 | * (non-Javadoc)
|
||
1738 | * @see org.gvsig.raster.impl.store.AbstractRasterDataStore#saveToState(org.gvsig.tools.persistence.PersistentState)
|
||
1739 | */
|
||
1740 | public void saveToState(PersistentState state) throws PersistenceException { |
||
1741 | state.set("parameters", provider.getDataParameters());
|
||
1742 | state.set("bandList", bandList);
|
||
1743 | 758 | nbrodin | state.set("metadata", metadata);
|
1744 | state.set("render", getRender());
|
||
1745 | 762 | nbrodin | state.set("filterList", getRender().getFilterList());
|
1746 | 758 | nbrodin | |
1747 | 762 | nbrodin | RasterFilterList list = getRender().getFilterList(); |
1748 | ArrayList<PersistencyFilterParam> filters = new ArrayList<PersistencyFilterParam>(); |
||
1749 | for (int i = 0; i < list.lenght(); i++) { |
||
1750 | RasterFilter f = list.get(i); |
||
1751 | Params uipar = f.getUIParams(f.getName()); |
||
1752 | PersistencyFilterParam param = new PersistencyFilterParam();
|
||
1753 | param.setFilterParam(uipar); |
||
1754 | param.setFilterClass(f.getClass()); |
||
1755 | param.setFilterName(f.getName()); |
||
1756 | filters.add(param); |
||
1757 | } |
||
1758 | state.set("paramlist", filters);
|
||
1759 | |||
1760 | 753 | nbrodin | } |
1761 | |||
1762 | public static void registerPersistence() { |
||
1763 | PersistenceManager manager = ToolsLocator.getPersistenceManager(); |
||
1764 | DynStruct definition = manager.getDefinition(PERSISTENT_NAME); |
||
1765 | if( definition == null ) { |
||
1766 | definition = manager.addDefinition( |
||
1767 | DefaultRasterStore.class, |
||
1768 | PERSISTENT_NAME, |
||
1769 | PERSISTENT_DESCRIPTION, |
||
1770 | null,
|
||
1771 | null
|
||
1772 | ); |
||
1773 | |||
1774 | definition.addDynFieldObject("parameters").setClassOfValue(RasterDataParameters.class).setMandatory(true); |
||
1775 | definition.addDynFieldObject("bandList").setClassOfValue(BandList.class).setMandatory(false); |
||
1776 | definition.addDynFieldObject("metadata").setClassOfValue(Metadata.class).setMandatory(false); |
||
1777 | 758 | nbrodin | definition.addDynFieldObject("render").setClassOfValue(Render.class).setMandatory(true); |
1778 | 762 | nbrodin | |
1779 | definition.addDynFieldObject("filterList").setClassOfValue(RasterFilterList.class).setMandatory(false); |
||
1780 | definition.addDynFieldList("paramlist").setClassOfItems(PersistencyFilterParam.class).setMandatory(false); |
||
1781 | 753 | nbrodin | } |
1782 | } |
||
1783 | 1055 | nbrodin | |
1784 | /*
|
||
1785 | * (non-Javadoc)
|
||
1786 | * @see org.gvsig.fmap.dal.coverage.store.RasterDataStore#close()
|
||
1787 | */
|
||
1788 | public void close() { |
||
1789 | if(provider != null) |
||
1790 | provider.close(); |
||
1791 | if(bandList != null) |
||
1792 | bandList.clear(); |
||
1793 | provider = null;
|
||
1794 | bandList = null;
|
||
1795 | super.close();
|
||
1796 | try {
|
||
1797 | finalize(); |
||
1798 | } catch (Throwable e) { |
||
1799 | } |
||
1800 | } |
||
1801 | |||
1802 | /*
|
||
1803 | * (non-Javadoc)
|
||
1804 | * @see java.lang.Object#finalize()
|
||
1805 | */
|
||
1806 | protected void finalize() throws Throwable { |
||
1807 | provider = null;
|
||
1808 | bandList = null;
|
||
1809 | metadata = null;
|
||
1810 | rManager = null;
|
||
1811 | super.finalize();
|
||
1812 | } |
||
1813 | 689 | nbrodin | } |