root / trunk / libraries / libRaster / src / org / gvsig / raster / dataaccess / buffer / RasterMemoryBuffer.java @ 11065
History | View | Annotate | Download (41.5 KB)
1 | 10740 | 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.dataaccess.buffer; |
||
20 | |||
21 | 10939 | nacho | import org.gvsig.raster.dataset.IBuffer; |
22 | 10740 | nacho | |
23 | /**
|
||
24 | * Implementaci?n del buffer de datos en memoria. Contiene las operaciones necesarias
|
||
25 | * para acceso a datos raster implementando IBuffer y su almacenamiento de datos est? basado
|
||
26 | * en arrays tridimensionales. Existe un array para cada tipo de dato pero al instanciarse
|
||
27 | * solo se usar? uno de ellos, el que corresponda al tipo de dato del raster manejado.
|
||
28 | * Esto quiere decir que cada RasterMemoryBuffer solo puede contener bandas de un solo tipo de
|
||
29 | * dato donde la variable dataType especificar? de que tipo de dato se trata.
|
||
30 | *
|
||
31 | * @author Nacho Brodin (nachobrodin@gmail.com)
|
||
32 | *
|
||
33 | */
|
||
34 | 10996 | bsanchez | public class RasterMemoryBuffer extends RasterBuffer { |
35 | 10740 | nacho | private ByteBand[] byteBuf = null; |
36 | private ShortBand[] shortBuf = null; |
||
37 | private IntBand[] intBuf = null; |
||
38 | private FloatBand[] floatBuf = null; |
||
39 | private DoubleBand[] doubleBuf = null; |
||
40 | |||
41 | public class ByteBand extends RasterBand{ |
||
42 | public byte[][] buf = null; |
||
43 | |||
44 | public ByteBand(int height, int width, boolean malloc){ |
||
45 | super(height, width);
|
||
46 | if(malloc)
|
||
47 | buf = new byte[height][width]; |
||
48 | } |
||
49 | |||
50 | public Object getLine(int line) { |
||
51 | return buf[line];
|
||
52 | } |
||
53 | |||
54 | public void setLine(int line, Object value){ |
||
55 | buf[line] = (byte[])value; |
||
56 | } |
||
57 | |||
58 | public Object getBuf(){ |
||
59 | return buf;
|
||
60 | } |
||
61 | } |
||
62 | |||
63 | public class ShortBand extends RasterBand{ |
||
64 | public short[][] buf = null; |
||
65 | |||
66 | public ShortBand(int height, int width, boolean malloc){ |
||
67 | super(height, width);
|
||
68 | if(malloc)
|
||
69 | buf = new short[height][width]; |
||
70 | } |
||
71 | |||
72 | public Object getLine(int line) { |
||
73 | return buf[line];
|
||
74 | } |
||
75 | |||
76 | public void setLine(int line, Object value){ |
||
77 | buf[line] = (short[])value; |
||
78 | } |
||
79 | |||
80 | public Object getBuf(){ |
||
81 | return buf;
|
||
82 | } |
||
83 | } |
||
84 | |||
85 | public class IntBand extends RasterBand{ |
||
86 | public int[][] buf = null; |
||
87 | |||
88 | public IntBand(int height, int width, boolean malloc){ |
||
89 | super(height, width);
|
||
90 | if(malloc)
|
||
91 | buf = new int[height][width]; |
||
92 | } |
||
93 | |||
94 | public Object getLine(int line) { |
||
95 | return buf[line];
|
||
96 | } |
||
97 | |||
98 | public void setLine(int line, Object value){ |
||
99 | buf[line] = (int[])value; |
||
100 | } |
||
101 | |||
102 | public Object getBuf(){ |
||
103 | return buf;
|
||
104 | } |
||
105 | } |
||
106 | |||
107 | public class FloatBand extends RasterBand{ |
||
108 | public float[][] buf = null; |
||
109 | |||
110 | public FloatBand(int height, int width, boolean malloc){ |
||
111 | super(height, width);
|
||
112 | if(malloc)
|
||
113 | buf = new float[height][width]; |
||
114 | } |
||
115 | |||
116 | public Object getLine(int line) { |
||
117 | return buf[line];
|
||
118 | } |
||
119 | |||
120 | public void setLine(int line, Object value){ |
||
121 | buf[line] = (float[])value; |
||
122 | } |
||
123 | |||
124 | public Object getBuf(){ |
||
125 | return buf;
|
||
126 | } |
||
127 | } |
||
128 | |||
129 | public class DoubleBand extends RasterBand{ |
||
130 | public double[][] buf = null; |
||
131 | |||
132 | public DoubleBand(int height, int width, boolean malloc){ |
||
133 | super(height, width);
|
||
134 | if(malloc)
|
||
135 | buf = new double[height][width]; |
||
136 | } |
||
137 | |||
138 | public Object getLine(int line) { |
||
139 | return buf[line];
|
||
140 | } |
||
141 | |||
142 | public void setLine(int line, Object value){ |
||
143 | buf[line] = (double[])value; |
||
144 | } |
||
145 | |||
146 | public Object getBuf(){ |
||
147 | return buf;
|
||
148 | } |
||
149 | } |
||
150 | |||
151 | /**
|
||
152 | * Constructor
|
||
153 | */
|
||
154 | public RasterMemoryBuffer() {
|
||
155 | |||
156 | } |
||
157 | |||
158 | 10785 | nacho | /*
|
159 | * (non-Javadoc)
|
||
160 | * @see org.gvsig.raster.driver.IBuffer#isBandSwitchable()
|
||
161 | */
|
||
162 | public boolean isBandSwitchable(){ |
||
163 | return true; |
||
164 | } |
||
165 | |||
166 | 10740 | nacho | /**
|
167 | * Constructor
|
||
168 | * @param dataType Tipo de dato
|
||
169 | * @param width Ancho
|
||
170 | * @param height Alto
|
||
171 | * @param bandNr Banda
|
||
172 | * @param orig
|
||
173 | */
|
||
174 | public RasterMemoryBuffer(int dataType, int width, int height, int bandNr, boolean malloc) { |
||
175 | if(malloc)
|
||
176 | malloc(dataType, width, height, bandNr); |
||
177 | else
|
||
178 | loadVariables(dataType, width, height, bandNr); |
||
179 | } |
||
180 | |||
181 | /*
|
||
182 | * (non-Javadoc)
|
||
183 | * @see org.gvsig.fmap.dataaccess.buffer.RasterBuffer#malloc(int, int, int, int)
|
||
184 | */
|
||
185 | public void malloc(int dataType, int width, int height, int bandNr) { |
||
186 | this.dataType = dataType;
|
||
187 | this.width = width;
|
||
188 | this.height = height;
|
||
189 | this.nBands = bandNr;
|
||
190 | |||
191 | if (dataType == TYPE_BYTE) {
|
||
192 | byteBuf = new ByteBand[bandNr];
|
||
193 | for(int i = 0; i < bandNr; i++) |
||
194 | byteBuf[i] = new ByteBand(height, width, true); |
||
195 | } else if ((dataType == TYPE_SHORT) | (dataType == TYPE_USHORT)) { |
||
196 | shortBuf = new ShortBand[bandNr];
|
||
197 | for(int i = 0; i < bandNr; i++) |
||
198 | shortBuf[i] = new ShortBand(height, width, true); |
||
199 | } else if (dataType == TYPE_INT) { |
||
200 | intBuf = new IntBand[bandNr];
|
||
201 | for(int i = 0; i < bandNr; i++) |
||
202 | intBuf[i] = new IntBand(height, width, true); |
||
203 | } else if (dataType == TYPE_FLOAT) { |
||
204 | floatBuf = new FloatBand[bandNr];
|
||
205 | for(int i = 0; i < bandNr; i++) |
||
206 | floatBuf[i] = new FloatBand(height, width, true); |
||
207 | } else if (dataType == TYPE_DOUBLE) { |
||
208 | doubleBuf = new DoubleBand[bandNr];
|
||
209 | for(int i = 0; i < bandNr; i++) |
||
210 | doubleBuf[i] = new DoubleBand(height, width, true); |
||
211 | } |
||
212 | |||
213 | } |
||
214 | |||
215 | /*
|
||
216 | * (non-Javadoc)
|
||
217 | * @see org.gvsig.fmap.dataaccess.buffer.RasterBuffer#mallocOneBand(int, int, int, int)
|
||
218 | */
|
||
219 | public void mallocOneBand(int dataType, int width, int height, int band){ |
||
220 | this.dataType = dataType;
|
||
221 | this.width = width;
|
||
222 | this.height = height;
|
||
223 | |||
224 | if (dataType == TYPE_BYTE) {
|
||
225 | if(byteBuf == null) |
||
226 | byteBuf = new ByteBand[nBands];
|
||
227 | byteBuf[band] = new ByteBand(height, width, true); |
||
228 | } else if ((dataType == TYPE_SHORT) | (dataType == TYPE_USHORT)) { |
||
229 | if(shortBuf == null) |
||
230 | shortBuf = new ShortBand[nBands];
|
||
231 | shortBuf[band] = new ShortBand(height, width, true); |
||
232 | } else if (dataType == TYPE_INT) { |
||
233 | if(intBuf == null) |
||
234 | intBuf = new IntBand[nBands];
|
||
235 | intBuf[band] = new IntBand(height, width, true); |
||
236 | } else if (dataType == TYPE_FLOAT) { |
||
237 | if(floatBuf == null) |
||
238 | floatBuf = new FloatBand[nBands];
|
||
239 | floatBuf[band] = new FloatBand(height, width, true); |
||
240 | } else if (dataType == TYPE_DOUBLE) { |
||
241 | if(doubleBuf == null) |
||
242 | doubleBuf = new DoubleBand[nBands];
|
||
243 | doubleBuf[band] = new DoubleBand(height, width, true); |
||
244 | } |
||
245 | } |
||
246 | |||
247 | /**
|
||
248 | * Carga las variables del rasterBuf
|
||
249 | * @param dataType Tipo de dato
|
||
250 | * @param width Ancho
|
||
251 | * @param height Alto
|
||
252 | * @param bandNr Banda
|
||
253 | * @param orig
|
||
254 | */
|
||
255 | private void loadVariables(int dataType, int width, int height, int bandNr) { |
||
256 | this.dataType = dataType;
|
||
257 | this.width = width;
|
||
258 | this.height = height;
|
||
259 | this.nBands = bandNr;
|
||
260 | |||
261 | if (dataType == TYPE_BYTE) {
|
||
262 | byteBuf = new ByteBand[bandNr];
|
||
263 | for(int i = 0; i < bandNr; i ++) |
||
264 | byteBuf[i] = new ByteBand(height, 0, true); |
||
265 | } else if ((dataType == TYPE_SHORT) | (dataType == TYPE_USHORT)) { |
||
266 | shortBuf = new ShortBand[bandNr];
|
||
267 | for(int i = 0; i < bandNr; i ++) |
||
268 | shortBuf[i] = new ShortBand(height, 0, true); |
||
269 | } else if (dataType == TYPE_INT) { |
||
270 | intBuf = new IntBand[bandNr];
|
||
271 | for(int i = 0; i < bandNr; i ++) |
||
272 | intBuf[i] = new IntBand(height, 0, true); |
||
273 | } else if (dataType == TYPE_FLOAT) { |
||
274 | floatBuf = new FloatBand[bandNr];
|
||
275 | for(int i = 0; i < bandNr; i ++) |
||
276 | floatBuf[i] = new FloatBand(height, 0, true); |
||
277 | } else if (dataType == TYPE_DOUBLE) { |
||
278 | doubleBuf = new DoubleBand[bandNr];
|
||
279 | for(int i = 0; i < bandNr; i ++) |
||
280 | doubleBuf[i] = new DoubleBand(height, 0, true); |
||
281 | } |
||
282 | |||
283 | } |
||
284 | |||
285 | /*
|
||
286 | * (non-Javadoc)
|
||
287 | * @see org.gvsig.fmap.driver.IBuffer#getWidth()
|
||
288 | */
|
||
289 | public int getWidth() { |
||
290 | return width;
|
||
291 | } |
||
292 | |||
293 | /*
|
||
294 | * (non-Javadoc)
|
||
295 | * @see org.gvsig.fmap.driver.IBuffer#getHeight()
|
||
296 | */
|
||
297 | public int getHeight() { |
||
298 | return height;
|
||
299 | } |
||
300 | |||
301 | /*
|
||
302 | * (non-Javadoc)
|
||
303 | * @see org.gvsig.fmap.driver.IBuffer#getBandCount()
|
||
304 | */
|
||
305 | public int getBandCount() { |
||
306 | return nBands;
|
||
307 | } |
||
308 | |||
309 | /**
|
||
310 | * Obtiene el tipo de dato. Los tipos de dato posibles est?n definidos en IRaster.
|
||
311 | * @return tipo de datos
|
||
312 | */
|
||
313 | public int getDataType() { |
||
314 | return dataType;
|
||
315 | } |
||
316 | |||
317 | /**
|
||
318 | * Asigna el tipo de dato. Los tipos de dato posibles est?n definidos en IRaster.
|
||
319 | * @param dataType Tipo de dato del buffer
|
||
320 | */
|
||
321 | public void setDataType(int dataType) { |
||
322 | this.dataType = dataType;
|
||
323 | } |
||
324 | |||
325 | /**
|
||
326 | * Obtiene el tama?o del tipo de dato en bytes
|
||
327 | * @return Tipo de dato
|
||
328 | */
|
||
329 | public int getDataSize() { |
||
330 | if (dataType == TYPE_BYTE) {
|
||
331 | return 1; |
||
332 | } else if ((dataType == TYPE_SHORT) | (dataType == TYPE_USHORT)) { |
||
333 | return 2; |
||
334 | } else if (dataType == TYPE_INT) { |
||
335 | return 4; |
||
336 | }else if (dataType == TYPE_FLOAT) { |
||
337 | return 8; |
||
338 | }else if (dataType == TYPE_DOUBLE) { |
||
339 | return 16; |
||
340 | } |
||
341 | |||
342 | return 0; |
||
343 | } |
||
344 | |||
345 | /**
|
||
346 | * Obtiene el tama?o del buffer
|
||
347 | * @return tama?o del buffer
|
||
348 | */
|
||
349 | 10883 | nacho | public long sizeof() { |
350 | 10740 | nacho | return getDataSize() * width * height * nBands;
|
351 | } |
||
352 | |||
353 | //***********************************************
|
||
354 | //Obtiene una linea de datos con todas las bandas
|
||
355 | |||
356 | public byte[][] getLineByte(int line) { |
||
357 | byte[][] r = new byte[nBands][]; |
||
358 | for(int iBand = 0; iBand < nBands; iBand ++) |
||
359 | r[iBand] = (byte[])byteBuf[iBand].getLine(line); |
||
360 | return r;
|
||
361 | } |
||
362 | |||
363 | public short[][] getLineShort(int line) { |
||
364 | short[][] r = new short[nBands][]; |
||
365 | for(int iBand = 0; iBand < nBands; iBand ++) |
||
366 | r[iBand] = (short[])shortBuf[iBand].getLine(line); |
||
367 | return r;
|
||
368 | } |
||
369 | |||
370 | public int[][] getLineInt(int line) { |
||
371 | int[][] r = new int[nBands][]; |
||
372 | for(int iBand = 0; iBand < nBands; iBand ++) |
||
373 | r[iBand] = (int[])intBuf[iBand].getLine(line); |
||
374 | return r;
|
||
375 | } |
||
376 | |||
377 | public float[][] getLineFloat(int line) { |
||
378 | float[][] r = new float[nBands][]; |
||
379 | for(int iBand = 0; iBand < nBands; iBand ++) |
||
380 | r[iBand] = (float[])floatBuf[iBand].getLine(line); |
||
381 | return r;
|
||
382 | } |
||
383 | |||
384 | public double[][] getLineDouble(int line) { |
||
385 | double[][] r = new double[nBands][]; |
||
386 | for(int iBand = 0; iBand < nBands; iBand ++) |
||
387 | r[iBand] = (double[])doubleBuf[iBand].getLine(line); |
||
388 | return r;
|
||
389 | } |
||
390 | |||
391 | //***********************************************
|
||
392 | //Asigna una linea de datos a todas las bandas
|
||
393 | |||
394 | public void setLineByte(byte[][] data, int line) { |
||
395 | for(int iBand = 0; iBand < nBands; iBand ++) |
||
396 | byteBuf[iBand].setLine(line, data[iBand]); |
||
397 | } |
||
398 | |||
399 | public void setLineShort(short[][] data, int line) { |
||
400 | for(int iBand = 0; iBand < nBands; iBand ++) |
||
401 | shortBuf[iBand].setLine(line, data[iBand]); |
||
402 | } |
||
403 | |||
404 | public void setLineInt(int[][] data, int line) { |
||
405 | for(int iBand = 0; iBand < nBands; iBand ++) |
||
406 | intBuf[iBand].setLine(line, data[iBand]); |
||
407 | } |
||
408 | |||
409 | public void setLineFloat(float[][] data, int line) { |
||
410 | for(int iBand = 0; iBand < nBands; iBand ++) |
||
411 | floatBuf[iBand].setLine(line, data[iBand]); |
||
412 | } |
||
413 | |||
414 | public void setLineDouble(double[][] data, int line) { |
||
415 | for(int iBand = 0; iBand < nBands; iBand ++) |
||
416 | doubleBuf[iBand].setLine(line, data[iBand]); |
||
417 | } |
||
418 | |||
419 | //***********************************************
|
||
420 | //Obtiene una linea de datos de una banda
|
||
421 | |||
422 | public byte[] getLineFromBandByte(int line, int band) { |
||
423 | return (byte[])byteBuf[band].getLine(line); |
||
424 | } |
||
425 | |||
426 | public short[] getLineFromBandShort(int line, int band) { |
||
427 | return (short[])shortBuf[band].getLine(line); |
||
428 | } |
||
429 | |||
430 | public int[] getLineFromBandInt(int line, int band) { |
||
431 | return (int[])intBuf[band].getLine(line); |
||
432 | } |
||
433 | |||
434 | public float[] getLineFromBandFloat(int line, int band) { |
||
435 | return (float[])floatBuf[band].getLine(line); |
||
436 | } |
||
437 | |||
438 | public double[] getLineFromBandDouble(int line, int band) { |
||
439 | return (double[])doubleBuf[band].getLine(line); |
||
440 | } |
||
441 | |||
442 | //***********************************************
|
||
443 | //Asigna una linea de datos a una banda
|
||
444 | |||
445 | public void setLineInBandByte(byte[] data, int line, int band) { |
||
446 | byteBuf[band].setLine(line, data); |
||
447 | } |
||
448 | |||
449 | public void setLineInBandShort(short[] data, int line, int band) { |
||
450 | shortBuf[band].setLine(line, data); |
||
451 | } |
||
452 | |||
453 | public void setLineInBandInt(int[] data, int line, int band) { |
||
454 | intBuf[band].setLine(line, data); |
||
455 | } |
||
456 | |||
457 | public void setLineInBandFloat(float[] data, int line, int band) { |
||
458 | floatBuf[band].setLine(line, data); |
||
459 | } |
||
460 | |||
461 | public void setLineInBandDouble(double[] data, int line, int band) { |
||
462 | doubleBuf[band].setLine(line, data); |
||
463 | } |
||
464 | |||
465 | //***********************************************
|
||
466 | //Obtiene un elemento de la matriz
|
||
467 | |||
468 | public byte getElemByte(int line, int col, int band) { |
||
469 | return byteBuf[band].buf[line][col];
|
||
470 | } |
||
471 | |||
472 | public short getElemShort(int line, int col, int band) { |
||
473 | return shortBuf[band].buf[line][col];
|
||
474 | } |
||
475 | |||
476 | public int getElemInt(int line, int col, int band) { |
||
477 | return intBuf[band].buf[line][col];
|
||
478 | } |
||
479 | |||
480 | public float getElemFloat(int line, int col, int band) { |
||
481 | return floatBuf[band].buf[line][col];
|
||
482 | } |
||
483 | |||
484 | public double getElemDouble(int line, int col, int band) { |
||
485 | return doubleBuf[band].buf[line][col];
|
||
486 | } |
||
487 | |||
488 | //**********************************************
|
||
489 | //Asigna un elemento de la matriz
|
||
490 | |||
491 | public void setElem(int line, int col, int band, byte data) { |
||
492 | byteBuf[band].buf[line][col] = data; |
||
493 | } |
||
494 | |||
495 | public void setElem(int line, int col, int band, short data) { |
||
496 | shortBuf[band].buf[line][col] = data; |
||
497 | } |
||
498 | |||
499 | public void setElem(int line, int col, int band, int data) { |
||
500 | intBuf[band].buf[line][col] = data; |
||
501 | } |
||
502 | |||
503 | public void setElem(int line, int col, int band, float data) { |
||
504 | floatBuf[band].buf[line][col] = data; |
||
505 | } |
||
506 | |||
507 | public void setElem(int line, int col, int band, double data) { |
||
508 | doubleBuf[band].buf[line][col] = data; |
||
509 | } |
||
510 | |||
511 | //***********************************************
|
||
512 | //Copia un elemento de todas la bandas en el buffer pasado por par?metro
|
||
513 | |||
514 | public void getElemByte(int line, int col, byte[] data) { |
||
515 | for (int iBand = 0; (iBand < nBands && iBand < data.length); iBand++) |
||
516 | data[iBand] = byteBuf[iBand].buf[line][col]; |
||
517 | } |
||
518 | |||
519 | public void getElemShort(int line, int col, short[] data) { |
||
520 | for (int iBand = 0; (iBand < nBands && iBand < data.length); iBand++) |
||
521 | data[iBand] = shortBuf[iBand].buf[line][col]; |
||
522 | } |
||
523 | |||
524 | public void getElemInt(int line, int col, int[] data) { |
||
525 | for (int iBand = 0; (iBand < nBands && iBand < data.length); iBand++) |
||
526 | data[iBand] = intBuf[iBand].buf[line][col]; |
||
527 | } |
||
528 | |||
529 | public void getElemFloat(int line, int col, float[] data) { |
||
530 | for (int iBand = 0; (iBand < nBands && iBand < data.length); iBand++) |
||
531 | data[iBand] = floatBuf[iBand].buf[line][col]; |
||
532 | } |
||
533 | |||
534 | public void getElemDouble(int line, int col, double[] data) { |
||
535 | for (int iBand = 0; (iBand < nBands && iBand < data.length); iBand++) |
||
536 | data[iBand] = doubleBuf[iBand].buf[line][col]; |
||
537 | } |
||
538 | |||
539 | //***********************************************
|
||
540 | //Asigna un elemento a todas la bandas en el buffer pasado por par?metro
|
||
541 | |||
542 | public void setElemByte(int line, int col, byte[] data) { |
||
543 | for (int iBand = 0; (iBand < nBands && iBand < data.length); iBand++) |
||
544 | byteBuf[iBand].buf[line][col] = data[iBand]; |
||
545 | } |
||
546 | |||
547 | public void setElemShort(int line, int col, short[] data) { |
||
548 | for (int iBand = 0; (iBand < nBands && iBand < data.length); iBand++) |
||
549 | shortBuf[iBand].buf[line][col] = data[iBand]; |
||
550 | } |
||
551 | |||
552 | public void setElemInt(int line, int col, int[] data) { |
||
553 | for (int iBand = 0; (iBand < nBands && iBand < data.length); iBand++) |
||
554 | intBuf[iBand].buf[line][col] = data[iBand]; |
||
555 | } |
||
556 | |||
557 | public void setElemFloat(int line, int col, float[] data) { |
||
558 | for (int iBand = 0; (iBand < nBands && iBand < data.length); iBand++) |
||
559 | floatBuf[iBand].buf[line][col] = data[iBand]; |
||
560 | } |
||
561 | |||
562 | public void setElemDouble(int line, int col, double[] data) { |
||
563 | for (int iBand = 0; (iBand < nBands && iBand < data.length); iBand++) |
||
564 | doubleBuf[iBand].buf[line][col] = data[iBand]; |
||
565 | } |
||
566 | |||
567 | //***********************************************
|
||
568 | //Obtiene una banda entera
|
||
569 | |||
570 | public IBand getBand(int band){ |
||
571 | if (dataType == TYPE_BYTE) {
|
||
572 | return byteBuf[band];
|
||
573 | } else if ((dataType == TYPE_SHORT) | (dataType == TYPE_USHORT)) { |
||
574 | return shortBuf[band];
|
||
575 | } else if (dataType == TYPE_INT) { |
||
576 | return intBuf[band];
|
||
577 | }else if (dataType == TYPE_FLOAT) { |
||
578 | return floatBuf[band];
|
||
579 | }else if (dataType == TYPE_DOUBLE) { |
||
580 | return doubleBuf[band];
|
||
581 | } |
||
582 | return null; |
||
583 | } |
||
584 | |||
585 | /*
|
||
586 | * (non-Javadoc)
|
||
587 | * @see org.gvsig.fmap.driver.IBuffer#getBandBuffer(int)
|
||
588 | */
|
||
589 | public IBuffer getBandBuffer(int iBand){ |
||
590 | RasterMemoryBuffer rmb = new RasterMemoryBuffer(dataType, width, height, 1, false); |
||
591 | if (dataType == TYPE_BYTE)
|
||
592 | rmb.byteBuf[0].buf = byteBuf[iBand].buf;
|
||
593 | else if ((dataType == TYPE_SHORT) | (dataType == TYPE_USHORT)) |
||
594 | rmb.shortBuf[0].buf = shortBuf[iBand].buf;
|
||
595 | else if (dataType == TYPE_INT) |
||
596 | rmb.intBuf[0].buf = intBuf[iBand].buf;
|
||
597 | else if (dataType == TYPE_FLOAT) |
||
598 | rmb.floatBuf[0].buf = floatBuf[iBand].buf;
|
||
599 | else if (dataType == TYPE_DOUBLE) |
||
600 | rmb.doubleBuf[0].buf = doubleBuf[iBand].buf;
|
||
601 | return rmb;
|
||
602 | } |
||
603 | //***********************************************
|
||
604 | //Inicializa una banda a un valor pasado por par?metro
|
||
605 | |||
606 | public void assign(int band, byte value) { |
||
607 | for(int line = 0; line < height; line ++) |
||
608 | for(int col = 0; col < width; col ++) |
||
609 | byteBuf[band].buf[line][col] = value; |
||
610 | } |
||
611 | |||
612 | public void assign(int band, short value) { |
||
613 | for(int line = 0; line < height; line ++) |
||
614 | for(int col = 0; col < width; col ++) |
||
615 | shortBuf[band].buf[line][col] = value; |
||
616 | } |
||
617 | |||
618 | public void assign(int band, int value) { |
||
619 | for(int line = 0; line < height; line ++) |
||
620 | for(int col = 0; col < width; col ++) |
||
621 | intBuf[band].buf[line][col] = value; |
||
622 | } |
||
623 | |||
624 | public void assign(int band, float value) { |
||
625 | for(int line = 0; line < height; line ++) |
||
626 | for(int col = 0; col < width; col ++) |
||
627 | floatBuf[band].buf[line][col] = value; |
||
628 | } |
||
629 | |||
630 | public void assign(int band, double value) { |
||
631 | for(int line = 0; line < height; line ++) |
||
632 | for(int col = 0; col < width; col ++) |
||
633 | doubleBuf[band].buf[line][col] = value; |
||
634 | } |
||
635 | |||
636 | //***********************************************
|
||
637 | //Crea un buffer banda inicializado con el valor pasado por par?metro
|
||
638 | |||
639 | |||
640 | public IBand createBand(byte defaultValue){ |
||
641 | switch(getDataType()){
|
||
642 | case RasterBuffer.TYPE_BYTE:ByteBand bb = new ByteBand(width, height, false); |
||
643 | bb.buf = createByteBand(width, height, defaultValue); |
||
644 | return bb;
|
||
645 | case RasterBuffer.TYPE_SHORT: ShortBand sb = new ShortBand(width, height, false); |
||
646 | sb.buf = createShortBand(width, height, defaultValue); |
||
647 | return sb;
|
||
648 | case RasterBuffer.TYPE_INT: IntBand ib = new IntBand(width, height, false); |
||
649 | ib.buf = createIntBand(width, height, defaultValue); |
||
650 | return ib;
|
||
651 | case RasterBuffer.TYPE_FLOAT: FloatBand fb = new FloatBand(width, height, false); |
||
652 | fb.buf = createFloatBand(width, height, defaultValue); |
||
653 | return fb;
|
||
654 | case RasterBuffer.TYPE_DOUBLE: DoubleBand db = new DoubleBand(width, height, false); |
||
655 | db.buf = createDoubleBand(width, height, defaultValue); |
||
656 | return db;
|
||
657 | } |
||
658 | return null; |
||
659 | } |
||
660 | |||
661 | public byte[][] createByteBand(int width, int height, byte defaultValue){ |
||
662 | byte[][] band = new byte[height][width]; |
||
663 | if(defaultValue != 0){ |
||
664 | for(int line = 0; line < height; line ++) |
||
665 | for(int col = 0; col < width; col ++) |
||
666 | band[line][col] = defaultValue; |
||
667 | } |
||
668 | return band;
|
||
669 | } |
||
670 | |||
671 | public short[][] createShortBand(int width, int height, short defaultValue){ |
||
672 | short[][] band = new short[height][width]; |
||
673 | if(defaultValue != 0){ |
||
674 | for(int line = 0; line < height; line ++) |
||
675 | for(int col = 0; col < width; col ++) |
||
676 | band[line][col] = defaultValue; |
||
677 | } |
||
678 | return band;
|
||
679 | } |
||
680 | |||
681 | public int[][] createIntBand(int width, int height, int defaultValue){ |
||
682 | int[][] band = new int[height][width]; |
||
683 | if(defaultValue != 0){ |
||
684 | for(int line = 0; line < height; line ++) |
||
685 | for(int col = 0; col < width; col ++) |
||
686 | band[line][col] = defaultValue; |
||
687 | } |
||
688 | return band;
|
||
689 | } |
||
690 | |||
691 | public float[][] createFloatBand(int width, int height, float defaultValue){ |
||
692 | float[][] band = new float[height][width]; |
||
693 | if(defaultValue != 0){ |
||
694 | for(int line = 0; line < height; line ++) |
||
695 | for(int col = 0; col < width; col ++) |
||
696 | band[line][col] = defaultValue; |
||
697 | } |
||
698 | return band;
|
||
699 | } |
||
700 | |||
701 | public double[][] createDoubleBand(int width, int height, double defaultValue){ |
||
702 | double[][] band = new double[height][width]; |
||
703 | if(defaultValue != 0){ |
||
704 | for(int line = 0; line < height; line ++) |
||
705 | for(int col = 0; col < width; col ++) |
||
706 | band[line][col] = defaultValue; |
||
707 | } |
||
708 | return band;
|
||
709 | } |
||
710 | |||
711 | //***********************************************
|
||
712 | //A?ade una banda entera. Los datos son asignados por referencia
|
||
713 | |||
714 | private void addBandByte(int pos, IBand data) { |
||
715 | if(pos < 0) |
||
716 | return;
|
||
717 | ByteBand[] tmp = null; |
||
718 | if(pos >= byteBuf.length){
|
||
719 | tmp = new ByteBand[pos + 1]; |
||
720 | for(int iBand = 0; iBand < byteBuf.length; iBand ++) |
||
721 | tmp[iBand] = byteBuf[iBand]; |
||
722 | tmp[pos] = (ByteBand)data; |
||
723 | }else{
|
||
724 | tmp = new ByteBand[byteBuf.length + 1]; |
||
725 | for(int iBand = 0; iBand < pos; iBand ++) |
||
726 | tmp[iBand] = byteBuf[iBand]; |
||
727 | tmp[pos] = (ByteBand)data; |
||
728 | for(int iBand = pos + 1; iBand <= byteBuf.length; iBand ++) |
||
729 | tmp[iBand] = byteBuf[iBand - 1];
|
||
730 | } |
||
731 | nBands = tmp.length; |
||
732 | byteBuf = tmp; |
||
733 | } |
||
734 | |||
735 | private void addBandShort(int pos, IBand data) { |
||
736 | if(pos < 0) |
||
737 | return;
|
||
738 | ShortBand[] tmp = null; |
||
739 | if(pos >= shortBuf.length){
|
||
740 | tmp = new ShortBand[pos + 1]; |
||
741 | for(int iBand = 0; iBand < shortBuf.length; iBand ++) |
||
742 | tmp[iBand] = shortBuf[iBand]; |
||
743 | tmp[pos] = (ShortBand)data; |
||
744 | }else{
|
||
745 | tmp = new ShortBand[shortBuf.length + 1]; |
||
746 | for(int iBand = 0; iBand < pos; iBand ++) |
||
747 | tmp[iBand] = shortBuf[iBand]; |
||
748 | tmp[pos] = (ShortBand)data; |
||
749 | for(int iBand = pos + 1; iBand < shortBuf.length; iBand ++) |
||
750 | tmp[iBand] = shortBuf[iBand - 1];
|
||
751 | } |
||
752 | nBands = tmp.length; |
||
753 | shortBuf = tmp; |
||
754 | } |
||
755 | |||
756 | private void addBandInt(int pos, IBand data) { |
||
757 | if(pos < 0) |
||
758 | return;
|
||
759 | IntBand[] tmp = null; |
||
760 | if(pos >= intBuf.length){
|
||
761 | tmp = new IntBand[pos + 1]; |
||
762 | for(int iBand = 0; iBand < intBuf.length; iBand ++) |
||
763 | tmp[iBand] = intBuf[iBand]; |
||
764 | tmp[pos] = (IntBand)data; |
||
765 | }else{
|
||
766 | tmp = new IntBand[intBuf.length + 1]; |
||
767 | for(int iBand = 0; iBand < pos; iBand ++) |
||
768 | tmp[iBand] = intBuf[iBand]; |
||
769 | tmp[pos] = (IntBand)data; |
||
770 | for(int iBand = pos + 1; iBand < intBuf.length; iBand ++) |
||
771 | tmp[iBand] = intBuf[iBand - 1];
|
||
772 | } |
||
773 | nBands = tmp.length; |
||
774 | intBuf = tmp; |
||
775 | } |
||
776 | |||
777 | private void addBandFloat(int pos, IBand data) { |
||
778 | if(pos < 0) |
||
779 | return;
|
||
780 | FloatBand[] tmp = null; |
||
781 | if(pos >= floatBuf.length){
|
||
782 | tmp = new FloatBand[pos + 1]; |
||
783 | for(int iBand = 0; iBand < floatBuf.length; iBand ++) |
||
784 | tmp[iBand] = floatBuf[iBand]; |
||
785 | tmp[pos] = (FloatBand)data; |
||
786 | }else{
|
||
787 | tmp = new FloatBand[floatBuf.length + 1]; |
||
788 | for(int iBand = 0; iBand < pos; iBand ++) |
||
789 | tmp[iBand] = floatBuf[iBand]; |
||
790 | tmp[pos] = (FloatBand)data; |
||
791 | for(int iBand = pos + 1; iBand < floatBuf.length; iBand ++) |
||
792 | tmp[iBand] = floatBuf[iBand - 1];
|
||
793 | } |
||
794 | nBands = tmp.length; |
||
795 | floatBuf = tmp; |
||
796 | } |
||
797 | |||
798 | private void addBandDouble(int pos, IBand data) { |
||
799 | if(pos < 0) |
||
800 | return;
|
||
801 | DoubleBand[] tmp = null; |
||
802 | if(pos >= doubleBuf.length){
|
||
803 | tmp = new DoubleBand[pos + 1]; |
||
804 | for(int iBand = 0; iBand < doubleBuf.length; iBand ++) |
||
805 | tmp[iBand] = doubleBuf[iBand]; |
||
806 | tmp[pos] = (DoubleBand)data; |
||
807 | }else{
|
||
808 | tmp = new DoubleBand[doubleBuf.length + 1]; |
||
809 | for(int iBand = 0; iBand < pos; iBand ++) |
||
810 | tmp[iBand] = doubleBuf[iBand]; |
||
811 | tmp[pos] = (DoubleBand)data; |
||
812 | for(int iBand = pos + 1; iBand < doubleBuf.length; iBand ++) |
||
813 | tmp[iBand] = doubleBuf[iBand - 1];
|
||
814 | } |
||
815 | nBands = tmp.length; |
||
816 | doubleBuf = tmp; |
||
817 | } |
||
818 | |||
819 | //***********************************************
|
||
820 | //Reemplaza una banda entera. Los datos son reemplazados por referencia
|
||
821 | |||
822 | /* public void replaceBandByte(int pos, byte[][] data) {
|
||
823 | if(pos >= byteBuf.length)
|
||
824 | return;
|
||
825 | byteBuf[pos] = data;
|
||
826 | }
|
||
827 | |||
828 | public void replaceBandShort(int pos, short[][] data) {
|
||
829 | if(pos >= shortBuf.length)
|
||
830 | return;
|
||
831 | shortBuf[pos] = data;
|
||
832 | }
|
||
833 | |||
834 | public void replaceBandInt(int pos, int[][] data) {
|
||
835 | if(pos >= intBuf.length)
|
||
836 | return;
|
||
837 | intBuf[pos] = data;
|
||
838 | }
|
||
839 | |||
840 | public void replaceBandFloat(int pos, float[][] data) {
|
||
841 | if(pos >= floatBuf.length)
|
||
842 | return;
|
||
843 | floatBuf[pos] = data;
|
||
844 | }
|
||
845 | |||
846 | public void replaceBandDouble(int pos, double[][] data) {
|
||
847 | if(pos >= doubleBuf.length)
|
||
848 | return;
|
||
849 | doubleBuf[pos] = data;
|
||
850 | }*/
|
||
851 | |||
852 | /**
|
||
853 | * Replica la banda de una posici?n sobre otra. Si la banda de destino no existe
|
||
854 | * se crea nueva. Si la posici?n de la banda de destino est? intercalada entre bandas
|
||
855 | * que ya existen las otras se desplazan hacia abajo, NO se machacan los datos de ninguna.
|
||
856 | * Los datos se replican por referencia por lo que al modificar la banda original las
|
||
857 | * del resto quedar?n afectadas.
|
||
858 | * @param orig. Posici?n de la banda de origen.
|
||
859 | * @param dest. Posici?n de la banda destino
|
||
860 | */
|
||
861 | public void replicateBand(int orig, int dest){ |
||
862 | switch(getDataType()){
|
||
863 | case RasterBuffer.TYPE_BYTE: if(orig >= byteBuf.length) |
||
864 | return;
|
||
865 | addBandByte(dest, getBand(orig)); |
||
866 | break;
|
||
867 | case RasterBuffer.TYPE_SHORT: if(orig >= shortBuf.length) |
||
868 | return;
|
||
869 | addBandShort(dest, getBand(orig)); |
||
870 | break;
|
||
871 | case RasterBuffer.TYPE_INT: if(orig >= intBuf.length) |
||
872 | return;
|
||
873 | addBandInt(dest, getBand(orig)); |
||
874 | break;
|
||
875 | case RasterBuffer.TYPE_FLOAT: if(orig >= floatBuf.length) |
||
876 | return;
|
||
877 | addBandFloat(dest, getBand(orig)); |
||
878 | break;
|
||
879 | case RasterBuffer.TYPE_DOUBLE: if(orig >= doubleBuf.length) |
||
880 | return;
|
||
881 | addBandDouble(dest, getBand(orig)); |
||
882 | break;
|
||
883 | } |
||
884 | } |
||
885 | |||
886 | /*
|
||
887 | * (non-Javadoc)
|
||
888 | * @see org.gvsig.fmap.dataaccess.buffer.RasterBuffer#switchBands(int[])
|
||
889 | */
|
||
890 | public void switchBands(int[] bandPosition){ |
||
891 | if(bandPosition.length != this.getBandCount()) |
||
892 | return;
|
||
893 | for(int i = 0; i < bandPosition.length; i++) |
||
894 | if(bandPosition[i] >= bandPosition.length || bandPosition[i] < 0) |
||
895 | return;
|
||
896 | |||
897 | switch (getDataType()) {
|
||
898 | case RasterBuffer.TYPE_BYTE:
|
||
899 | ByteBand[] bufB = new ByteBand[this.getBandCount()]; |
||
900 | for(int i = 0; i < bandPosition.length; i++) |
||
901 | bufB[i] = byteBuf[bandPosition[i]]; |
||
902 | byteBuf = bufB; |
||
903 | break;
|
||
904 | case RasterBuffer.TYPE_DOUBLE:
|
||
905 | DoubleBand[] bufD = new DoubleBand[this.getBandCount()]; |
||
906 | for(int i = 0; i < bandPosition.length; i++) |
||
907 | bufD[i] = doubleBuf[bandPosition[i]]; |
||
908 | doubleBuf = bufD; |
||
909 | break;
|
||
910 | case RasterBuffer.TYPE_FLOAT:
|
||
911 | FloatBand[] bufF = new FloatBand[this.getBandCount()]; |
||
912 | for(int i = 0; i < bandPosition.length; i++) |
||
913 | bufF[i] = floatBuf[bandPosition[i]]; |
||
914 | floatBuf = bufF; |
||
915 | break;
|
||
916 | case RasterBuffer.TYPE_INT:
|
||
917 | IntBand[] bufI = new IntBand[this.getBandCount()]; |
||
918 | for(int i = 0; i < bandPosition.length; i++) |
||
919 | bufI[i] = intBuf[bandPosition[i]]; |
||
920 | intBuf = bufI; |
||
921 | break;
|
||
922 | case RasterBuffer.TYPE_USHORT:
|
||
923 | case RasterBuffer.TYPE_SHORT:
|
||
924 | ShortBand[] bufS = new ShortBand[this.getBandCount()]; |
||
925 | for(int i = 0; i < bandPosition.length; i++) |
||
926 | bufS[i] = shortBuf[bandPosition[i]]; |
||
927 | shortBuf = bufS; |
||
928 | break;
|
||
929 | } |
||
930 | } |
||
931 | |||
932 | /*
|
||
933 | * (non-Javadoc)
|
||
934 | * @see org.gvsig.fmap.driver.IBuffer#copyBand(int, org.gvsig.fmap.dataaccess.buffer.IBand)
|
||
935 | */
|
||
936 | public void copyBand(int nBand, IBand band) { |
||
937 | switch (band.getDataType()) {
|
||
938 | case RasterBuffer.TYPE_BYTE:
|
||
939 | byteBuf[nBand] = new ByteBand(band.getHeight(), band.getWidth(), true); |
||
940 | byte[][] bb = ((ByteBand)band).buf; |
||
941 | for(int i = 0; i < bb.length; i ++) |
||
942 | for(int j = 0; j < bb[i].length; j ++) |
||
943 | byteBuf[nBand].buf[i][j] = bb[i][j]; |
||
944 | break;
|
||
945 | case RasterBuffer.TYPE_DOUBLE:
|
||
946 | doubleBuf[nBand] = new DoubleBand(band.getHeight(), band.getWidth(), true); |
||
947 | double[][] db = ((DoubleBand)band).buf; |
||
948 | for(int i = 0; i < db.length; i ++) |
||
949 | for(int j = 0; j < db[i].length; j ++) |
||
950 | doubleBuf[nBand].buf[i][j] = db[i][j]; |
||
951 | break;
|
||
952 | case RasterBuffer.TYPE_FLOAT:
|
||
953 | floatBuf[nBand] = new FloatBand(band.getHeight(), band.getWidth(), true); |
||
954 | float[][] fb = ((FloatBand)band).buf; |
||
955 | for(int i = 0; i < fb.length; i ++) |
||
956 | for(int j = 0; j < fb[i].length; j ++) |
||
957 | floatBuf[nBand].buf[i][j] = fb[i][j]; |
||
958 | break;
|
||
959 | case RasterBuffer.TYPE_INT:
|
||
960 | intBuf[nBand] = new IntBand(band.getHeight(), band.getWidth(), true); |
||
961 | int[][] ib = ((IntBand)band).buf; |
||
962 | for(int i = 0; i < ib.length; i ++) |
||
963 | for(int j = 0; j < ib[i].length; j ++) |
||
964 | intBuf[nBand].buf[i][j] = ib[i][j]; |
||
965 | break;
|
||
966 | case RasterBuffer.TYPE_USHORT:
|
||
967 | case RasterBuffer.TYPE_SHORT:
|
||
968 | shortBuf[nBand] = new ShortBand(band.getHeight(), band.getWidth(), true); |
||
969 | short[][] sb = ((ShortBand)band).buf; |
||
970 | for(int i = 0; i < sb.length; i ++) |
||
971 | for(int j = 0; j < sb[i].length; j ++) |
||
972 | shortBuf[nBand].buf[i][j] = sb[i][j]; |
||
973 | break;
|
||
974 | } |
||
975 | } |
||
976 | |||
977 | /*
|
||
978 | * (non-Javadoc)
|
||
979 | * @see org.gvsig.fmap.driver.IBuffer#assignBand(int, org.gvsig.fmap.dataaccess.buffer.IBand)
|
||
980 | */
|
||
981 | public void assignBand(int nBand, IBand band) { |
||
982 | switch (getDataType()) {
|
||
983 | case RasterBuffer.TYPE_BYTE:
|
||
984 | byteBuf[nBand] = ((ByteBand)band); |
||
985 | break;
|
||
986 | case RasterBuffer.TYPE_DOUBLE:
|
||
987 | doubleBuf[nBand] = ((DoubleBand)band); |
||
988 | break;
|
||
989 | case RasterBuffer.TYPE_FLOAT:
|
||
990 | floatBuf[nBand] = ((FloatBand)band); |
||
991 | break;
|
||
992 | case RasterBuffer.TYPE_INT:
|
||
993 | intBuf[nBand] = ((IntBand)band); |
||
994 | break;
|
||
995 | case RasterBuffer.TYPE_USHORT:
|
||
996 | case RasterBuffer.TYPE_SHORT:
|
||
997 | shortBuf[nBand] = ((ShortBand)band); |
||
998 | break;
|
||
999 | } |
||
1000 | } |
||
1001 | |||
1002 | /*
|
||
1003 | * (non-Javadoc)
|
||
1004 | * @see org.gvsig.fmap.driver.IBuffer#cloneBuffer()
|
||
1005 | */
|
||
1006 | public IBuffer cloneBuffer(){
|
||
1007 | boolean malloc = false; |
||
1008 | if(byteBuf != null || shortBuf != null || intBuf != null || floatBuf != null || doubleBuf != null) |
||
1009 | malloc = true;
|
||
1010 | RasterMemoryBuffer rmb = new RasterMemoryBuffer(dataType, width, height, nBands, malloc);
|
||
1011 | for(int iBand = 0; iBand < nBands; iBand ++){ |
||
1012 | for(int row = 0; row < height; row ++){ |
||
1013 | for(int col = 0; col < width; col ++){ |
||
1014 | if(byteBuf != null) |
||
1015 | rmb.setElem(row, col, iBand, getElemByte(row, col, iBand)); |
||
1016 | if(shortBuf != null) |
||
1017 | rmb.setElem(row, col, iBand, getElemShort(row, col, iBand)); |
||
1018 | if(intBuf != null) |
||
1019 | rmb.setElem(row, col, iBand, getElemInt(row, col, iBand)); |
||
1020 | if(floatBuf != null) |
||
1021 | rmb.setElem(row, col, iBand, getElemFloat(row, col, iBand)); |
||
1022 | if(doubleBuf != null) |
||
1023 | rmb.setElem(row, col, iBand, getElemDouble(row, col, iBand)); |
||
1024 | } |
||
1025 | } |
||
1026 | } |
||
1027 | |||
1028 | return rmb;
|
||
1029 | } |
||
1030 | |||
1031 | /*
|
||
1032 | * (non-Javadoc)
|
||
1033 | * @see org.gvsig.fmap.driver.IBuffer#interchangeBands(int, int)
|
||
1034 | */
|
||
1035 | public void interchangeBands(int band1, int band2){ |
||
1036 | switch (getDataType()) {
|
||
1037 | case RasterBuffer.TYPE_BYTE:
|
||
1038 | ByteBand auxByte = byteBuf[band1]; |
||
1039 | byteBuf[band1] = byteBuf[band2]; |
||
1040 | byteBuf[band2] = auxByte; |
||
1041 | break;
|
||
1042 | case RasterBuffer.TYPE_DOUBLE:
|
||
1043 | DoubleBand auxDouble = doubleBuf[band1]; |
||
1044 | doubleBuf[band1] = doubleBuf[band2]; |
||
1045 | doubleBuf[band2] = auxDouble; |
||
1046 | break;
|
||
1047 | case RasterBuffer.TYPE_FLOAT:
|
||
1048 | FloatBand auxFloat = floatBuf[band1]; |
||
1049 | floatBuf[band1] = floatBuf[band2]; |
||
1050 | floatBuf[band2] = auxFloat; |
||
1051 | break;
|
||
1052 | case RasterBuffer.TYPE_INT:
|
||
1053 | IntBand auxInt = intBuf[band1]; |
||
1054 | intBuf[band1] = intBuf[band2]; |
||
1055 | intBuf[band2] = auxInt; |
||
1056 | break;
|
||
1057 | case RasterBuffer.TYPE_USHORT:
|
||
1058 | case RasterBuffer.TYPE_SHORT:
|
||
1059 | ShortBand auxShort = shortBuf[band1]; |
||
1060 | shortBuf[band1] = shortBuf[band2]; |
||
1061 | shortBuf[band2] = auxShort; |
||
1062 | break;
|
||
1063 | } |
||
1064 | } |
||
1065 | |||
1066 | /**
|
||
1067 | * Convierte un tipo de dato a cadena
|
||
1068 | * @param type Tipo de dato
|
||
1069 | * @return cadena que representa el tipo de dato
|
||
1070 | */
|
||
1071 | public static String typesToString(int type) { |
||
1072 | switch (type) {
|
||
1073 | case RasterBuffer.TYPE_IMAGE:
|
||
1074 | return new String("Image"); |
||
1075 | |||
1076 | case RasterBuffer.TYPE_BYTE:
|
||
1077 | return new String("Byte"); |
||
1078 | |||
1079 | case RasterBuffer.TYPE_DOUBLE:
|
||
1080 | return new String("Double"); |
||
1081 | |||
1082 | case RasterBuffer.TYPE_FLOAT:
|
||
1083 | return new String("Float"); |
||
1084 | |||
1085 | case RasterBuffer.TYPE_INT:
|
||
1086 | return new String("Integer"); |
||
1087 | |||
1088 | case RasterBuffer.TYPE_USHORT:
|
||
1089 | case RasterBuffer.TYPE_SHORT:
|
||
1090 | return new String("Short"); |
||
1091 | } |
||
1092 | |||
1093 | return null; |
||
1094 | } |
||
1095 | |||
1096 | /*
|
||
1097 | * (non-Javadoc)
|
||
1098 | * @see org.gvsig.fmap.buffer.raster.RasterBuffer#adjustRasterNearestNeighbourInterpolation(int, int, int[])
|
||
1099 | */
|
||
1100 | public RasterBuffer adjustRasterNearestNeighbourInterpolation(int w, int h, int[] bands){ |
||
1101 | double stepX = (double)w / (double)width; |
||
1102 | double stepY = (double)h / (double)height; |
||
1103 | RasterBuffer rasterBuf = new RasterMemoryBuffer(getDataType(), w, h, getBandCount(), true); |
||
1104 | |||
1105 | //Si bands == null las bandas a copiar son todas las de la imagen
|
||
1106 | if(bands == null){ |
||
1107 | bands = new int[rasterBuf.getBandCount()]; |
||
1108 | for(int iBand = 0; iBand < rasterBuf.getBandCount(); iBand ++) |
||
1109 | bands[iBand] = iBand; |
||
1110 | } |
||
1111 | |||
1112 | switch (dataType) {
|
||
1113 | case RasterBuffer.TYPE_IMAGE:
|
||
1114 | |||
1115 | case RasterBuffer.TYPE_BYTE:
|
||
1116 | for(int iBand = 0; iBand < bands.length; iBand ++){ |
||
1117 | if(w <= width){ //submuestreo |
||
1118 | for(int iRow = 0; iRow < height; iRow ++) |
||
1119 | for(int iCol = 0; iCol < width; iCol ++) |
||
1120 | rasterBuf.setElem((int)(iRow * stepY), (int)(iCol * stepX), bands[iBand], getElemByte(iRow, iCol, iBand)); |
||
1121 | }else{ //supermuestreo |
||
1122 | for(int iRow = 0; iRow < h; iRow ++) |
||
1123 | for(int iCol = 0; iCol < w; iCol ++) |
||
1124 | rasterBuf.setElem(iRow, iCol, bands[iBand], getElemByte((int)(iRow / stepY), (int)(iCol / stepX), iBand)); |
||
1125 | } |
||
1126 | } |
||
1127 | break;
|
||
1128 | case RasterBuffer.TYPE_DOUBLE:
|
||
1129 | for(int iBand = 0; iBand < bands.length; iBand ++){ |
||
1130 | if(w <= width){ //submuestreo |
||
1131 | for(int iRow = 0; iRow < height; iRow ++) |
||
1132 | for(int iCol = 0; iCol < width; iCol ++) |
||
1133 | rasterBuf.setElem((int)(iRow * stepY), (int)(iCol * stepX), bands[iBand], getElemDouble(iRow, iCol, iBand)); |
||
1134 | }else{ //supermuestreo |
||
1135 | for(int iRow = 0; iRow < h; iRow ++) |
||
1136 | for(int iCol = 0; iCol < w; iCol ++) |
||
1137 | rasterBuf.setElem(iRow, iCol, bands[iBand], getElemDouble((int)(iRow / stepY), (int)(iCol / stepX), iBand)); |
||
1138 | } |
||
1139 | } |
||
1140 | break;
|
||
1141 | case RasterBuffer.TYPE_FLOAT:
|
||
1142 | for(int iBand = 0; iBand < bands.length; iBand ++){ |
||
1143 | if(w <= width){ //submuestreo |
||
1144 | for(int iRow = 0; iRow < height; iRow ++) |
||
1145 | for(int iCol = 0; iCol < width; iCol ++) |
||
1146 | rasterBuf.setElem((int)(iRow * stepY), (int)(iCol * stepX), bands[iBand], getElemFloat(iRow, iCol, iBand)); |
||
1147 | }else{ //supermuestreo |
||
1148 | for(int iRow = 0; iRow < h; iRow ++) |
||
1149 | for(int iCol = 0; iCol < w; iCol ++) |
||
1150 | rasterBuf.setElem(iRow, iCol, bands[iBand], getElemFloat((int)(iRow / stepY), (int)(iCol / stepX), iBand)); |
||
1151 | } |
||
1152 | } |
||
1153 | break;
|
||
1154 | case RasterBuffer.TYPE_INT:
|
||
1155 | for(int iBand = 0; iBand < bands.length; iBand ++){ |
||
1156 | if(w <= width){ //submuestreo |
||
1157 | for(int iRow = 0; iRow < height; iRow ++) |
||
1158 | for(int iCol = 0; iCol < width; iCol ++) |
||
1159 | rasterBuf.setElem((int)(iRow * stepY), (int)(iCol * stepX), bands[iBand], getElemInt(iRow, iCol, iBand)); |
||
1160 | }else{ //supermuestreo |
||
1161 | for(int iRow = 0; iRow < h; iRow ++) |
||
1162 | for(int iCol = 0; iCol < w; iCol ++) |
||
1163 | rasterBuf.setElem(iRow, iCol, bands[iBand], getElemInt((int)(iRow / stepY), (int)(iCol / stepX), iBand)); |
||
1164 | } |
||
1165 | } |
||
1166 | break;
|
||
1167 | case RasterBuffer.TYPE_USHORT:
|
||
1168 | case RasterBuffer.TYPE_SHORT:
|
||
1169 | for(int iBand = 0; iBand < bands.length; iBand ++){ |
||
1170 | if(w <= width){ //submuestreo |
||
1171 | for(int iRow = 0; iRow < height; iRow ++) |
||
1172 | for(int iCol = 0; iCol < width; iCol ++) |
||
1173 | rasterBuf.setElem((int)(iRow * stepY), (int)(iCol * stepX), bands[iBand], getElemShort(iRow, iCol, iBand)); |
||
1174 | }else{ //supermuestreo |
||
1175 | for(int iRow = 0; iRow < h; iRow ++) |
||
1176 | for(int iCol = 0; iCol < w; iCol ++) |
||
1177 | rasterBuf.setElem(iRow, iCol, bands[iBand], getElemShort((int)(iRow / stepY), (int)(iCol / stepX), iBand)); |
||
1178 | } |
||
1179 | } |
||
1180 | break;
|
||
1181 | } |
||
1182 | return rasterBuf;
|
||
1183 | } |
||
1184 | |||
1185 | /*
|
||
1186 | * (non-Javadoc)
|
||
1187 | * @see org.gvsig.fmap.buffer.raster.RasterBuffer#adjustRasterBilinearInterpolation(int, int, int[])
|
||
1188 | */
|
||
1189 | public RasterBuffer adjustRasterBilinearInterpolation(int w, int h, int[] bands) { |
||
1190 | return null; |
||
1191 | } |
||
1192 | |||
1193 | /*
|
||
1194 | * (non-Javadoc)
|
||
1195 | * @see org.gvsig.fmap.buffer.raster.RasterBuffer#adjustRasterInverseDistanceInterpolation(int, int, int[])
|
||
1196 | */
|
||
1197 | public RasterBuffer adjustRasterInverseDistanceInterpolation(int w, int h, int[] bands) { |
||
1198 | return null; |
||
1199 | } |
||
1200 | |||
1201 | /*
|
||
1202 | * (non-Javadoc)
|
||
1203 | * @see org.gvsig.fmap.buffer.raster.RasterBuffer#adjustRasterBicubicSplineInterpolation(int, int, int[])
|
||
1204 | */
|
||
1205 | public RasterBuffer adjustRasterBicubicSplineInterpolation(int w, int h, int[] bands) { |
||
1206 | return null; |
||
1207 | } |
||
1208 | |||
1209 | /*
|
||
1210 | * (non-Javadoc)
|
||
1211 | * @see org.gvsig.fmap.buffer.raster.RasterBuffer#adjustRasterBSplineInterpolation(int, int, int[])
|
||
1212 | */
|
||
1213 | public RasterBuffer adjustRasterBSplineInterpolation(int w, int h, int[] bands) { |
||
1214 | return null; |
||
1215 | } |
||
1216 | |||
1217 | private ByteBand byteNotValid;
|
||
1218 | private ShortBand shortNotValid;
|
||
1219 | private IntBand intNotValid;
|
||
1220 | private FloatBand floatNotValid;
|
||
1221 | private DoubleBand doubleNotValid;
|
||
1222 | |||
1223 | /*
|
||
1224 | * (non-Javadoc)
|
||
1225 | * @see org.gvsig.fmap.driver.IBuffer#assignBandToNotValid(int)
|
||
1226 | */
|
||
1227 | public void assignBandToNotValid(int iBand){ |
||
1228 | switch(getDataType()){
|
||
1229 | case IBuffer.TYPE_BYTE: if(byteNotValid == null){ |
||
1230 | byteNotValid = new ByteBand(getHeight(), getWidth(), true); |
||
1231 | for(int i = 0 ; i < getWidth(); i ++) |
||
1232 | for(int j = 0 ; j < getHeight(); j ++) |
||
1233 | byteNotValid.buf[j][i] = (byte)getNotValidValue();
|
||
1234 | } |
||
1235 | byteBuf[iBand] = byteNotValid; |
||
1236 | break;
|
||
1237 | case IBuffer.TYPE_SHORT: if(shortNotValid == null){ |
||
1238 | shortNotValid = new ShortBand(getHeight(), getWidth(), true); |
||
1239 | for(int i = 0 ; i < getWidth(); i ++) |
||
1240 | for(int j = 0 ; j < getHeight(); j ++) |
||
1241 | shortNotValid.buf[j][i] = (short)getNotValidValue();
|
||
1242 | } |
||
1243 | shortBuf[iBand] = shortNotValid; |
||
1244 | break;
|
||
1245 | case IBuffer.TYPE_INT: if(intNotValid == null){ |
||
1246 | intNotValid = new IntBand(getHeight(), getWidth(), true); |
||
1247 | for(int i = 0 ; i < getWidth(); i ++) |
||
1248 | for(int j = 0 ; j < getHeight(); j ++) |
||
1249 | intNotValid.buf[j][i] = (int)getNotValidValue();
|
||
1250 | } |
||
1251 | intBuf[iBand] = intNotValid; |
||
1252 | break;
|
||
1253 | case IBuffer.TYPE_FLOAT: if(floatNotValid == null){ |
||
1254 | floatNotValid = new FloatBand(getHeight(), getWidth(), true); |
||
1255 | for(int i = 0 ; i < getWidth(); i ++) |
||
1256 | for(int j = 0 ; j < getHeight(); j ++) |
||
1257 | floatNotValid.buf[j][i] = (float)getNotValidValue();
|
||
1258 | } |
||
1259 | floatBuf[iBand] = floatNotValid; |
||
1260 | break;
|
||
1261 | case IBuffer.TYPE_DOUBLE: if(doubleNotValid == null){ |
||
1262 | doubleNotValid = new DoubleBand(getHeight(), getWidth(), true); |
||
1263 | for(int i = 0 ; i < getWidth(); i ++) |
||
1264 | for(int j = 0 ; j < getHeight(); j ++) |
||
1265 | doubleNotValid.buf[j][i] = (double)getNotValidValue();
|
||
1266 | } |
||
1267 | doubleBuf[iBand] = doubleNotValid; |
||
1268 | break;
|
||
1269 | } |
||
1270 | } |
||
1271 | 11065 | bsanchez | } |