root / trunk / libraries / libRaster / src / org / gvsig / raster / dataset / IBuffer.java @ 10973
History | View | Annotate | Download (13.6 KB)
1 | 10939 | nacho | /* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana
|
---|---|---|---|
2 | *
|
||
3 | * Copyright (C) 2006 IVER T.I. and Generalitat Valenciana.
|
||
4 | *
|
||
5 | * This program is free software; you can redistribute it and/or
|
||
6 | * modify it under the terms of the GNU General Public License
|
||
7 | * as published by the Free Software Foundation; either version 2
|
||
8 | * of the License, or (at your option) any later version.
|
||
9 | *
|
||
10 | * This program is distributed in the hope that it will be useful,
|
||
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
13 | * GNU General Public License for more details.
|
||
14 | *
|
||
15 | * You should have received a copy of the GNU General Public License
|
||
16 | * along with this program; if not, write to the Free Software
|
||
17 | * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,USA.
|
||
18 | */
|
||
19 | package org.gvsig.raster.dataset; |
||
20 | |||
21 | import java.awt.image.DataBuffer; |
||
22 | |||
23 | import org.gvsig.raster.dataaccess.buffer.IBand; |
||
24 | import org.gvsig.raster.util.IHistogramable; |
||
25 | |||
26 | /**
|
||
27 | * Interfaz que contiene las operaciones que debe soportar un buffer de datos.
|
||
28 | * @author Nacho Brodin (nachobrodin@gmail.com)
|
||
29 | *
|
||
30 | */
|
||
31 | public interface IBuffer extends IHistogramable{ |
||
32 | public final static int TYPE_UNDEFINED = DataBuffer.TYPE_UNDEFINED; |
||
33 | public final static int TYPE_BYTE = DataBuffer.TYPE_BYTE; |
||
34 | public final static int TYPE_SHORT = DataBuffer.TYPE_SHORT; |
||
35 | public final static int TYPE_USHORT = DataBuffer.TYPE_USHORT; |
||
36 | public final static int TYPE_INT = DataBuffer.TYPE_INT; |
||
37 | public final static int TYPE_FLOAT = DataBuffer.TYPE_FLOAT; |
||
38 | public final static int TYPE_DOUBLE = DataBuffer.TYPE_DOUBLE; |
||
39 | public final static int TYPE_IMAGE = -1; |
||
40 | |||
41 | /**
|
||
42 | * Ancho del raster
|
||
43 | * @return Entero con el ancho del raster
|
||
44 | */
|
||
45 | public int getWidth(); |
||
46 | |||
47 | /**
|
||
48 | * Alto del raster
|
||
49 | * @return Entero con el alto del raster
|
||
50 | */
|
||
51 | public int getHeight(); |
||
52 | |||
53 | /**
|
||
54 | * N?mero de bandas
|
||
55 | * @return Entero con el n?mero de bandas
|
||
56 | */
|
||
57 | public int getBandCount(); |
||
58 | |||
59 | /**
|
||
60 | * Obtiene el tipo de dato. Los tipos de dato posibles est?n definidos en IRaster.
|
||
61 | * @return tipo de datos
|
||
62 | */
|
||
63 | public int getDataType(); |
||
64 | |||
65 | /**
|
||
66 | * Asigna el tipo de dato. Los tipos de dato posibles est?n definidos en IRaster.
|
||
67 | * @param dataType Tipo de dato del buffer
|
||
68 | */
|
||
69 | public void setDataType(int dataType); |
||
70 | |||
71 | /**
|
||
72 | * Obtiene el valor NoData del buffer
|
||
73 | * @return Valor NoData del buffer
|
||
74 | */
|
||
75 | public double getNoDataValue(); |
||
76 | |||
77 | /**
|
||
78 | * Obtiene el valor NoData del buffer
|
||
79 | * @return Valor NoData del buffer
|
||
80 | */
|
||
81 | public byte getByteNoDataValue(); |
||
82 | |||
83 | /**
|
||
84 | * Obtiene el valor NoData del buffer
|
||
85 | * @return Valor NoData del buffer
|
||
86 | */
|
||
87 | public short getShortNoDataValue(); |
||
88 | |||
89 | /**
|
||
90 | * Obtiene el valor NoData del buffer
|
||
91 | * @return Valor NoData del buffer
|
||
92 | */
|
||
93 | public int getIntNoDataValue(); |
||
94 | |||
95 | /**
|
||
96 | * Obtiene el valor NoData del buffer
|
||
97 | * @return Valor NoData del buffer
|
||
98 | */
|
||
99 | public float getFloatNoDataValue(); |
||
100 | |||
101 | /**
|
||
102 | * Asigna el valor NoData
|
||
103 | * @param nd Valor NoData
|
||
104 | */
|
||
105 | public void setNoDataValue(double nd); |
||
106 | |||
107 | /**
|
||
108 | * Reserva de memoria para el rasterbuf solo en la banda solicitada
|
||
109 | * @param dataType Tipo de dato
|
||
110 | * @param width Ancho
|
||
111 | * @param height Alto
|
||
112 | * @param band N?mero de banda
|
||
113 | * @param orig
|
||
114 | */
|
||
115 | public void mallocOneBand(int dataType, int width, int height, int band); |
||
116 | |||
117 | /**
|
||
118 | * Informa de si el buffer tiene la capacidad de intercambio de bandas o
|
||
119 | * no la tiene.
|
||
120 | * @return Devuelve true si tiene la capacidad de intercambio de bandas y
|
||
121 | * false si no la tiene.
|
||
122 | */
|
||
123 | public boolean isBandSwitchable(); |
||
124 | |||
125 | //***********************************************
|
||
126 | //Obtiene una linea de datos de todas las bandas
|
||
127 | |||
128 | /**
|
||
129 | * Obtiene una l?nea de datos con todas las bandas para buffers con tipo
|
||
130 | * de dato byte.
|
||
131 | * @param line N?mero de l?nea del buffer a recuperar
|
||
132 | * @return Array bidimensional conteniendo la l?nea de datos donde la primera
|
||
133 | * dimensi?n representa las bandas y la segunda la posici?n en la l?nea
|
||
134 | */
|
||
135 | public byte[][] getLineByte(int line); |
||
136 | |||
137 | /**
|
||
138 | * Obtiene una l?nea de datos con todas las bandas para buffers con tipo
|
||
139 | * de dato short.
|
||
140 | * @param line N?mero de l?nea del buffer a recuperar
|
||
141 | * @return Array bidimensional conteniendo la l?nea de datos donde la primera
|
||
142 | * dimensi?n representa las bandas y la segunda la posici?n en la l?nea
|
||
143 | */
|
||
144 | public short[][] getLineShort(int line); |
||
145 | |||
146 | /**
|
||
147 | * Obtiene una l?nea de datos con todas las bandas para buffers con tipo
|
||
148 | * de dato int.
|
||
149 | * @param line N?mero de l?nea del buffer a recuperar
|
||
150 | * @return Array bidimensional conteniendo la l?nea de datos donde la primera
|
||
151 | * dimensi?n representa las bandas y la segunda la posici?n en la l?nea
|
||
152 | */
|
||
153 | public int[][] getLineInt(int line); |
||
154 | |||
155 | /**
|
||
156 | * Obtiene una l?nea de datos con todas las bandas para buffers con tipo
|
||
157 | * de dato float.
|
||
158 | * @param line N?mero de l?nea del buffer a recuperar
|
||
159 | * @return Array bidimensional conteniendo la l?nea de datos donde la primera
|
||
160 | * dimensi?n representa las bandas y la segunda la posici?n en la l?nea
|
||
161 | */
|
||
162 | public float[][] getLineFloat(int line); |
||
163 | |||
164 | /**
|
||
165 | * Obtiene una l?nea de datos con todas las bandas para buffers con tipo
|
||
166 | * de dato double.
|
||
167 | * @param line N?mero de l?nea del buffer a recuperar
|
||
168 | * @return Array bidimensional conteniendo la l?nea de datos donde la primera
|
||
169 | * dimensi?n representa las bandas y la segunda la posici?n en la l?nea
|
||
170 | */
|
||
171 | public double[][] getLineDouble(int line); |
||
172 | |||
173 | //***********************************************
|
||
174 | //Obtiene una linea de datos de una banda
|
||
175 | |||
176 | /**
|
||
177 | * Obtiene una l?nea de datos de la banda solicitada para buffers con tipo
|
||
178 | * de dato byte.
|
||
179 | * @param line N?mero de l?nea del buffer a recuperar
|
||
180 | * @param band N?mero de banda a recuperar
|
||
181 | * @return Array unidimensional que representa la l?nea de datos.
|
||
182 | */
|
||
183 | public byte[] getLineFromBandByte(int line, int band); |
||
184 | |||
185 | /**
|
||
186 | * Obtiene una l?nea de datos de la banda solicitada para buffers con tipo
|
||
187 | * de dato short.
|
||
188 | * @param line N?mero de l?nea del buffer a recuperar
|
||
189 | * @param band N?mero de banda a recuperar
|
||
190 | * @return Array unidimensional que representa la l?nea de datos.
|
||
191 | */
|
||
192 | public short[] getLineFromBandShort(int line, int band); |
||
193 | |||
194 | /**
|
||
195 | * Obtiene una l?nea de datos de la banda solicitada para buffers con tipo
|
||
196 | * de dato int.
|
||
197 | * @param line N?mero de l?nea del buffer a recuperar
|
||
198 | * @param band N?mero de banda a recuperar
|
||
199 | * @return Array unidimensional que representa la l?nea de datos.
|
||
200 | */
|
||
201 | public int[] getLineFromBandInt(int line, int band); |
||
202 | |||
203 | /**
|
||
204 | * Obtiene una l?nea de datos de la banda solicitada para buffers con tipo
|
||
205 | * de dato float.
|
||
206 | * @param line N?mero de l?nea del buffer a recuperar
|
||
207 | * @param band N?mero de banda a recuperar
|
||
208 | * @return Array unidimensional que representa la l?nea de datos.
|
||
209 | */
|
||
210 | public float[] getLineFromBandFloat(int line, int band); |
||
211 | |||
212 | /**
|
||
213 | * Obtiene una l?nea de datos de la banda solicitada para buffers con tipo
|
||
214 | * de dato double.
|
||
215 | * @param line N?mero de l?nea del buffer a recuperar
|
||
216 | * @param band N?mero de banda a recuperar
|
||
217 | * @return Array unidimensional que representa la l?nea de datos.
|
||
218 | */
|
||
219 | public double[] getLineFromBandDouble(int line, int band); |
||
220 | |||
221 | //***********************************************
|
||
222 | //Obtiene un elemento de la matriz
|
||
223 | |||
224 | public byte getElemByte(int line, int col, int band); |
||
225 | |||
226 | public short getElemShort(int line, int col, int band); |
||
227 | |||
228 | public int getElemInt(int line, int col, int band); |
||
229 | |||
230 | public float getElemFloat(int line, int col, int band); |
||
231 | |||
232 | public double getElemDouble(int line, int col, int band); |
||
233 | |||
234 | //***********************************************
|
||
235 | //Copia un elemento de todas la bandas en el buffer pasado por par?metro
|
||
236 | |||
237 | public void getElemByte(int line, int col, byte[] data); |
||
238 | |||
239 | public void getElemShort(int line, int col, short[] data); |
||
240 | |||
241 | public void getElemInt(int line, int col, int[] data); |
||
242 | |||
243 | public void getElemFloat(int line, int col, float[] data); |
||
244 | |||
245 | public void getElemDouble(int line, int col, double[] data); |
||
246 | |||
247 | //***********************************************
|
||
248 | |||
249 | /**
|
||
250 | * Sustituye una banda completa copiando los datos de la que se pasa por par?metro
|
||
251 | * @param nBand N?mero de banda a sustituir
|
||
252 | * @param banda a copiar
|
||
253 | */
|
||
254 | public void copyBand(int nBand, IBand band); |
||
255 | |||
256 | /**
|
||
257 | * Sustituye una banda completa que se asigna por referencia
|
||
258 | * @param nBand N?mero de banda a sustituir
|
||
259 | * @param banda a asignar por referencia
|
||
260 | */
|
||
261 | public void assignBand(int nBand, IBand band); |
||
262 | |||
263 | /**
|
||
264 | * Obtiene una banda completa del raster
|
||
265 | * @param nBand N?mero de banda
|
||
266 | */
|
||
267 | public IBand getBand(int nBand); |
||
268 | |||
269 | /**
|
||
270 | * Obtiene una banda completa del raster
|
||
271 | * @param nBand N?mero de banda
|
||
272 | */
|
||
273 | public IBuffer getBandBuffer(int nBand); |
||
274 | |||
275 | //***********************************************
|
||
276 | //Asigna una linea de datos a una banda
|
||
277 | |||
278 | public void setLineInBandByte(byte[] data, int line, int band); |
||
279 | |||
280 | public void setLineInBandShort(short[] data, int line, int band); |
||
281 | |||
282 | public void setLineInBandInt(int[] data, int line, int band); |
||
283 | |||
284 | public void setLineInBandFloat(float[] data, int line, int band); |
||
285 | |||
286 | public void setLineInBandDouble(double[] data, int line, int band); |
||
287 | |||
288 | //***********************************************
|
||
289 | //Asigna una linea de datos a todas las bandas
|
||
290 | |||
291 | public void setLineByte(byte[][] data, int line); |
||
292 | |||
293 | public void setLineShort(short[][] data, int line); |
||
294 | |||
295 | public void setLineInt(int[][] data, int line); |
||
296 | |||
297 | public void setLineFloat(float[][] data, int line); |
||
298 | |||
299 | public void setLineDouble(double[][] data, int line); |
||
300 | |||
301 | //**********************************************
|
||
302 | //Asigna un elemento de la matriz
|
||
303 | |||
304 | public void setElem(int line, int col, int band, byte data); |
||
305 | |||
306 | public void setElem(int line, int col, int band, short data); |
||
307 | |||
308 | public void setElem(int line, int col, int band, int data); |
||
309 | |||
310 | public void setElem(int line, int col, int band, float data); |
||
311 | |||
312 | public void setElem(int line, int col, int band, double data); |
||
313 | |||
314 | //***********************************************
|
||
315 | //Asigna un elemento a todas la bandas en el buffer pasado por par?metro
|
||
316 | |||
317 | public void setElemByte(int line, int col, byte[] data); |
||
318 | |||
319 | public void setElemShort(int line, int col, short[] data); |
||
320 | |||
321 | public void setElemInt(int line, int col, int[] data); |
||
322 | |||
323 | public void setElemFloat(int line, int col, float[] data); |
||
324 | |||
325 | public void setElemDouble(int line, int col, double[] data); |
||
326 | |||
327 | //***********************************************
|
||
328 | //Inicializa una banda a un valor pasado por par?metro
|
||
329 | |||
330 | public void assign(int band, byte value); |
||
331 | |||
332 | public void assign(int band, short value); |
||
333 | |||
334 | public void assign(int band, int value); |
||
335 | |||
336 | public void assign(int band, float value); |
||
337 | |||
338 | public void assign(int band, double value); |
||
339 | |||
340 | //***********************************************
|
||
341 | |||
342 | /**
|
||
343 | * Crea un buffer banda inicializado con el valor pasado por par?metro. Las dimensiones
|
||
344 | * corresponden a las del buffer existente.
|
||
345 | * @param defaultValue Valor con el que se inicializa la banda creada
|
||
346 | */
|
||
347 | public IBand createBand(byte defaultValue); |
||
348 | |||
349 | /**
|
||
350 | * Replica la banda de una posici?n sobre otra. Si la banda de destino no existe
|
||
351 | * se crea nueva. Si la posici?n de la banda de destino est? intercalada entre bandas
|
||
352 | * que ya existen las otras se desplazan hacia abajo, NO se machacan los datos de ninguna.
|
||
353 | * Los datos se replican por referencia por lo que al modificar la banda original las
|
||
354 | * del resto quedar?n afectadas.
|
||
355 | * @param orig. Posici?n de la banda de origen.
|
||
356 | * @param dest. Posici?n de la banda destino
|
||
357 | */
|
||
358 | public void replicateBand(int orig, int dest); |
||
359 | |||
360 | /**
|
||
361 | * Clona el buffer actual y devuelve el clone
|
||
362 | * @return Buffer clonado
|
||
363 | */
|
||
364 | public IBuffer cloneBuffer();
|
||
365 | |||
366 | /**
|
||
367 | * Intercambia dos bandas.
|
||
368 | * @param band1 Banda 1 a intercambiar
|
||
369 | * @param band2 Banda 2 a intercambiar
|
||
370 | */
|
||
371 | public void interchangeBands(int band1, int band2); |
||
372 | |||
373 | /**
|
||
374 | * Intercambia la posici?n de las bandas. La nueva posici?n viene dada por el vector
|
||
375 | * pasado por par?metro. Cada posici?n del vector es una banda del buffer y el contenido de
|
||
376 | * esa posici?n es la banda que se dibujar? sobre ese buffer.
|
||
377 | * <P>
|
||
378 | * Por ejemplo un array con los valores:
|
||
379 | * [2, 0, 1] significa que la banda que ocupa ahora la posici?n 2 pasar? a ocupar la 0, la que
|
||
380 | * tiene la posici?n 0 pasa a ocupar la 1 y la que tiene la posici?n 1 pasa a ocupar la 2.
|
||
381 | * </P>
|
||
382 | * @param bands Array con la nueva distribuci?n de bandas
|
||
383 | */
|
||
384 | public void switchBands(int[] bands); |
||
385 | |||
386 | /**
|
||
387 | * Asigna el valor de no valido.
|
||
388 | * @param value
|
||
389 | */
|
||
390 | public void setNotValidValue(double value); |
||
391 | |||
392 | /**
|
||
393 | * Obtiene el valor de no valido.
|
||
394 | * @return value
|
||
395 | */
|
||
396 | public double getNotValidValue(); |
||
397 | |||
398 | /**
|
||
399 | * Asigna una banda al valor especificado como no valido. Esta banda es com?n para todas las bandas
|
||
400 | * del buffer, es decir se asigna por referencia. No tiene el mismo resultado que asignar una banda
|
||
401 | * a un valor fijo.
|
||
402 | * @param iBand N?mero de banda
|
||
403 | */
|
||
404 | public void assignBandToNotValid(int iBand); |
||
405 | } |