svn-gvsig-desktop / branches / org.gvsig.desktop-2018a / org.gvsig.desktop.library / org.gvsig.raster / org.gvsig.raster.lib / org.gvsig.raster.lib.buffer.impl / src / main / java / org / gvsig / raster / lib / buffer / impl / DefaultBufferManager.java @ 43863
History | View | Annotate | Download (26.4 KB)
1 |
package org.gvsig.raster.lib.buffer.impl; |
---|---|
2 |
|
3 |
import java.awt.Color; |
4 |
import java.awt.image.BufferedImage; |
5 |
import java.awt.image.DataBuffer; |
6 |
import java.awt.image.Raster; |
7 |
import java.awt.image.SampleModel; |
8 |
import java.io.File; |
9 |
import java.io.IOException; |
10 |
import java.util.ArrayList; |
11 |
import java.util.HashMap; |
12 |
import java.util.List; |
13 |
import java.util.Map; |
14 |
import java.util.Map.Entry; |
15 |
|
16 |
import org.cresques.cts.IProjection; |
17 |
import org.slf4j.Logger; |
18 |
import org.slf4j.LoggerFactory; |
19 |
|
20 |
import org.gvsig.fmap.geom.Geometry; |
21 |
import org.gvsig.fmap.geom.exception.CreateEnvelopeException; |
22 |
import org.gvsig.fmap.geom.operation.GeometryOperationException; |
23 |
import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException; |
24 |
import org.gvsig.fmap.geom.primitive.Envelope; |
25 |
import org.gvsig.raster.lib.buffer.api.Band; |
26 |
import org.gvsig.raster.lib.buffer.api.BandInfo; |
27 |
import org.gvsig.raster.lib.buffer.api.BandPageManager; |
28 |
import org.gvsig.raster.lib.buffer.api.BandTileManager; |
29 |
import org.gvsig.raster.lib.buffer.api.Buffer; |
30 |
import org.gvsig.raster.lib.buffer.api.BufferDimensions; |
31 |
import org.gvsig.raster.lib.buffer.api.BufferManager; |
32 |
import org.gvsig.raster.lib.buffer.api.Kernel; |
33 |
import org.gvsig.raster.lib.buffer.api.NoData; |
34 |
import org.gvsig.raster.lib.buffer.api.OperationManager; |
35 |
import org.gvsig.raster.lib.buffer.api.PageManager; |
36 |
import org.gvsig.raster.lib.buffer.api.exceptions.BandException; |
37 |
import org.gvsig.raster.lib.buffer.api.exceptions.BufferException; |
38 |
import org.gvsig.raster.lib.buffer.api.exceptions.BufferOperationException; |
39 |
import org.gvsig.raster.lib.buffer.api.operations.Operation; |
40 |
import org.gvsig.raster.lib.buffer.api.operations.OperationFactory; |
41 |
import org.gvsig.raster.lib.buffer.api.operations.OperationList; |
42 |
import org.gvsig.raster.lib.buffer.api.operations.OperationListEntry; |
43 |
import org.gvsig.raster.lib.buffer.impl.exceptions.CreateBandTypeException; |
44 |
import org.gvsig.raster.lib.buffer.impl.exceptions.CreateBufferException; |
45 |
import org.gvsig.raster.lib.buffer.impl.operations.DefaultOperationList; |
46 |
import org.gvsig.raster.lib.buffer.impl.operations.DefaultOperationListEntry; |
47 |
import org.gvsig.tools.ToolsLocator; |
48 |
import org.gvsig.tools.dataTypes.CoercionException; |
49 |
import org.gvsig.tools.dataTypes.DataTypes; |
50 |
import org.gvsig.tools.dataTypes.DataTypesManager; |
51 |
import org.gvsig.tools.dataTypes.DataTypesManager.Coercion; |
52 |
import org.gvsig.tools.dataTypes.impl.coercion.CoerceToDouble; |
53 |
import org.gvsig.tools.dataTypes.impl.coercion.CoerceToFloat; |
54 |
import org.gvsig.tools.dataTypes.impl.coercion.CoerceToInt; |
55 |
import org.gvsig.tools.dynobject.DynObject; |
56 |
import org.gvsig.tools.folders.FoldersManager; |
57 |
import org.gvsig.tools.locator.LocatorException; |
58 |
import org.gvsig.tools.task.TaskStatus; |
59 |
|
60 |
/**
|
61 |
* @author fdiaz
|
62 |
*
|
63 |
*/
|
64 |
public class DefaultBufferManager implements BufferManager, OperationManager { |
65 |
|
66 |
private static final Logger logger = LoggerFactory.getLogger(DefaultBufferManager.class); |
67 |
private File lastFolderUsedToSave; |
68 |
private int simplePaginatedCounter; |
69 |
private Map<String, OperationFactory> operationFactoriesRegister; |
70 |
|
71 |
|
72 |
public DefaultBufferManager() {
|
73 |
simplePaginatedCounter = 0;
|
74 |
operationFactoriesRegister = new HashMap<String, OperationFactory>(); |
75 |
} |
76 |
|
77 |
@Override
|
78 |
public NoData createNoData(Number value, Number defaultValue) { |
79 |
NoData noData = new DefaultNoData(defaultValue);
|
80 |
noData.setValue(value); |
81 |
return noData;
|
82 |
} |
83 |
|
84 |
@Override
|
85 |
public Band createBand(int dataType, int rows, int columns, NoData noData, |
86 |
PageManager pageManager) throws CreateBandTypeException {
|
87 |
if (pageManager == null) { |
88 |
switch (dataType) {
|
89 |
case BufferManager.TYPE_BYTE:
|
90 |
return new MemoryBandByte(rows, columns, noData); |
91 |
case BufferManager.TYPE_SHORT:
|
92 |
return new MemoryBandShort(rows, columns, noData); |
93 |
case BufferManager.TYPE_INT:
|
94 |
return new MemoryBandInt(rows, columns, noData); |
95 |
case BufferManager.TYPE_FLOAT:
|
96 |
return new MemoryBandFloat(rows, columns, noData); |
97 |
case BufferManager.TYPE_DOUBLE:
|
98 |
return new MemoryBandDouble(rows, columns, noData); |
99 |
default:
|
100 |
throw new CreateBandTypeException(dataType); |
101 |
} |
102 |
} else if (pageManager instanceof BandPageManager) { |
103 |
switch (dataType) {
|
104 |
case BufferManager.TYPE_BYTE:
|
105 |
return new PaginatedBandByte(rows, columns, noData, (BandPageManager) pageManager); |
106 |
case BufferManager.TYPE_SHORT:
|
107 |
return new PaginatedBandShort(rows, columns, noData, (BandPageManager) pageManager); |
108 |
case BufferManager.TYPE_INT:
|
109 |
return new PaginatedBandInt(rows, columns, noData, (BandPageManager) pageManager); |
110 |
case BufferManager.TYPE_FLOAT:
|
111 |
return new PaginatedBandFloat(rows, columns, noData, (BandPageManager) pageManager); |
112 |
case BufferManager.TYPE_DOUBLE:
|
113 |
return new PaginatedBandDouble(rows, columns, noData, (BandPageManager) pageManager); |
114 |
default:
|
115 |
throw new CreateBandTypeException(dataType); |
116 |
} |
117 |
}else if(pageManager instanceof BandTileManager ){ |
118 |
//FIXME
|
119 |
switch (dataType) {
|
120 |
case BufferManager.TYPE_BYTE:
|
121 |
return new TiledBandByte(rows, columns, noData, (BandTileManager) pageManager); |
122 |
case BufferManager.TYPE_USHORT:
|
123 |
case BufferManager.TYPE_SHORT:
|
124 |
return new TiledBandShort(rows, columns, noData, (BandTileManager) pageManager); |
125 |
case BufferManager.TYPE_INT:
|
126 |
return new TiledBandInt(rows, columns, noData, (BandTileManager) pageManager); |
127 |
case BufferManager.TYPE_FLOAT:
|
128 |
return new TiledBandFloat(rows, columns, noData, (BandTileManager) pageManager); |
129 |
case BufferManager.TYPE_DOUBLE:
|
130 |
return new TiledBandDouble(rows, columns, noData, (BandTileManager) pageManager); |
131 |
default:
|
132 |
throw new CreateBandTypeException(dataType); |
133 |
} |
134 |
} |
135 |
return null; |
136 |
} |
137 |
|
138 |
@Override
|
139 |
public Buffer createBuffer(int rows, int columns, int[] bandDataTypes, IProjection projection) |
140 |
throws BufferException {
|
141 |
return new DefaultBuffer(rows, columns, bandDataTypes, null, projection, null, null); |
142 |
} |
143 |
|
144 |
@Override
|
145 |
public Buffer createBuffer(int rows, int columns, int[] bandDataTypes, NoData[] bandNoData, |
146 |
IProjection projection) throws CreateBufferException {
|
147 |
return new DefaultBuffer(rows, columns, bandDataTypes, bandNoData, projection, null, null); |
148 |
} |
149 |
|
150 |
@Override
|
151 |
public Buffer createBuffer(int rows, int columns, int[] bandDataTypes, NoData[] bandNoData, |
152 |
IProjection projection, Envelope envelope) throws BufferException {
|
153 |
return new DefaultBuffer(rows, columns, bandDataTypes, bandNoData, projection, envelope, |
154 |
null);
|
155 |
} |
156 |
|
157 |
@Override
|
158 |
public Buffer createBuffer(int rows, int columns, int[] bandDataTypes, NoData[] bandNoData, |
159 |
IProjection projection, Envelope envelope, List<PageManager> pageManagers)
|
160 |
throws BufferException {
|
161 |
return new DefaultBuffer(rows, columns, bandDataTypes, bandNoData, projection, envelope, |
162 |
pageManagers); |
163 |
} |
164 |
|
165 |
@Override
|
166 |
public BandPageManager createSimpleBandPageManager(File file, int rows, int columns, |
167 |
int dataType) throws IOException { |
168 |
return new SimpleBandPageManager(file, rows, columns, dataType); |
169 |
} |
170 |
|
171 |
|
172 |
public int getDataTypeSize(int dataType) { |
173 |
switch (dataType) {
|
174 |
case BufferManager.TYPE_BYTE:
|
175 |
return 1; |
176 |
case BufferManager.TYPE_SHORT:
|
177 |
return 2; |
178 |
case BufferManager.TYPE_INT:
|
179 |
return 4; |
180 |
case BufferManager.TYPE_FLOAT:
|
181 |
return 4; |
182 |
case BufferManager.TYPE_DOUBLE:
|
183 |
return 8; |
184 |
default:
|
185 |
throw new IllegalArgumentException("Data Type " + dataType + " not supported."); |
186 |
} |
187 |
|
188 |
} |
189 |
|
190 |
@Override
|
191 |
public List<PageManager> createSimpleBandPageManagerList(File[] files, int rows, int columns, |
192 |
int[] dataType) throws IOException { |
193 |
|
194 |
if (files == null) { |
195 |
files = new File[dataType.length]; |
196 |
} |
197 |
if (dataType.length != files.length) {
|
198 |
throw new IllegalArgumentException( |
199 |
"Length files array has to be same as length dataType array.");
|
200 |
} |
201 |
List<PageManager> pageManagers = new ArrayList<PageManager>(); |
202 |
for (int i = 0; i < dataType.length; i++) { |
203 |
pageManagers |
204 |
.add(this.createSimpleBandPageManager(files[i], rows, columns, dataType[i]));
|
205 |
} |
206 |
|
207 |
return pageManagers;
|
208 |
} |
209 |
|
210 |
@Override
|
211 |
public Buffer createClippedBuffer(Buffer buffer, Envelope envelope) throws BufferException { |
212 |
|
213 |
if(buffer==null){ |
214 |
try{
|
215 |
throw new IllegalArgumentException("Can't clip a null buffer"); |
216 |
} catch (IllegalArgumentException e){ |
217 |
logger.warn(e.getMessage(), e); |
218 |
throw e;
|
219 |
} |
220 |
} |
221 |
|
222 |
if(envelope==null){ |
223 |
try{
|
224 |
throw new IllegalArgumentException("Null envelope"); |
225 |
} catch (IllegalArgumentException e){ |
226 |
logger.warn(e.getMessage(), e); |
227 |
throw e;
|
228 |
} |
229 |
} |
230 |
|
231 |
Envelope bufferEnvelope = null;
|
232 |
try {
|
233 |
bufferEnvelope = buffer.getEnvelope(); |
234 |
} catch (Exception e) { |
235 |
logger.warn("Can't get buffer envelope", e);
|
236 |
throw new BufferException(e); |
237 |
} |
238 |
if (!bufferEnvelope.intersects(envelope)) {
|
239 |
return null; |
240 |
} |
241 |
try {
|
242 |
Geometry intersection = bufferEnvelope.getGeometry().intersection(envelope.getGeometry()); |
243 |
if (intersection == null) { |
244 |
return null; |
245 |
} |
246 |
} catch (GeometryOperationNotSupportedException | GeometryOperationException e1) {
|
247 |
logger.warn("Can't get intersection between two envelopes", e1);
|
248 |
return null; |
249 |
} |
250 |
|
251 |
return new ClippedBuffer(buffer, envelope); |
252 |
} |
253 |
|
254 |
@Override
|
255 |
public Buffer createConvertedTypeBuffer(Buffer buffer, int type) throws BufferException { |
256 |
return new ConvertedTypeBuffer(buffer, type); |
257 |
} |
258 |
|
259 |
@Override
|
260 |
public Band createClippedBand(Buffer buffer, Band band) throws CreateBandTypeException { |
261 |
int dataType = band.getDataType();
|
262 |
switch (dataType) {
|
263 |
case BufferManager.TYPE_BYTE:
|
264 |
return new ClippedBandByte(buffer, band); |
265 |
case BufferManager.TYPE_SHORT:
|
266 |
return new ClippedBandShort(buffer, band); |
267 |
case BufferManager.TYPE_INT:
|
268 |
return new ClippedBandInt(buffer, band); |
269 |
case BufferManager.TYPE_FLOAT:
|
270 |
return new ClippedBandFloat(buffer, band); |
271 |
case BufferManager.TYPE_DOUBLE:
|
272 |
return new ClippedBandDouble(buffer, band); |
273 |
default:
|
274 |
throw new CreateBandTypeException(dataType); |
275 |
} |
276 |
} |
277 |
|
278 |
@Override
|
279 |
public Band createConvertedTypeBand(Buffer buffer, Band band, int type) throws BandException { |
280 |
switch (type) {
|
281 |
case BufferManager.TYPE_BYTE:
|
282 |
return new ConvertedTypeBandByte(buffer, band); |
283 |
case BufferManager.TYPE_SHORT:
|
284 |
case BufferManager.TYPE_USHORT:
|
285 |
return new ConvertedTypeBandShort(buffer, band); |
286 |
case BufferManager.TYPE_INT:
|
287 |
return new ConvertedTypeBandInt(buffer, band); |
288 |
case BufferManager.TYPE_FLOAT:
|
289 |
return new ConvertedTypeBandFloat(buffer, band); |
290 |
case BufferManager.TYPE_DOUBLE:
|
291 |
return new ConvertedTypeBandDouble(buffer, band); |
292 |
default:
|
293 |
throw new CreateBandTypeException(type); |
294 |
} |
295 |
} |
296 |
|
297 |
@Override
|
298 |
public BandInfo createBandInfo(int band, String name, String description, int dataType, |
299 |
List<Entry<Object, Object>> values) { |
300 |
return new DefaultBandInfo(band, name, description, dataType, values); |
301 |
} |
302 |
|
303 |
@Override
|
304 |
public Buffer createBuffer(Buffer buffer, boolean paginated) throws BufferException { |
305 |
List<PageManager> pageManagers = null; |
306 |
try {
|
307 |
if (paginated) {
|
308 |
pageManagers = createPageManagerList(buffer.getBandCount(), buffer.getRows(), buffer.getColumns(), buffer.getBandTypes()); |
309 |
} |
310 |
Buffer newBuffer =
|
311 |
createBuffer(buffer.getRows(), buffer.getColumns(), buffer.getBandTypes(), buffer.getBandNoData(), |
312 |
buffer.getProjection(), buffer.getEnvelope(), pageManagers); |
313 |
for (int i = 0; i < newBuffer.getBandCount(); i++) { |
314 |
newBuffer.getBand(i).copyFrom(buffer.getBand(i)); |
315 |
} |
316 |
return newBuffer;
|
317 |
} catch (IOException | BandException | LocatorException | CreateEnvelopeException e) { |
318 |
throw new CreateBufferException(e); |
319 |
} |
320 |
} |
321 |
|
322 |
@Override
|
323 |
public BandPageManager createAwtRasterBandPageManager(Raster img, int band) { |
324 |
return new AwtRasterBandPageManager(img, band); |
325 |
} |
326 |
|
327 |
@Override
|
328 |
public List<PageManager> createAwtRasterBandPageManagerList(Raster img) throws IOException { |
329 |
List<PageManager> pageManagers;
|
330 |
pageManagers = new ArrayList<PageManager>(); |
331 |
for (int i = 0; i <img.getNumBands(); i++) { |
332 |
PageManager pageManager = |
333 |
createAwtRasterBandPageManager(img, i); |
334 |
pageManagers.add(pageManager); |
335 |
} |
336 |
return pageManagers;
|
337 |
} |
338 |
|
339 |
/**
|
340 |
* @param buffer
|
341 |
* @return
|
342 |
* @throws IOException
|
343 |
*/
|
344 |
private List<PageManager> createPageManagerList(int bands, int rows, int columns, int[] bandTypes) throws IOException { |
345 |
List<PageManager> pageManagers;
|
346 |
pageManagers = new ArrayList<PageManager>(); |
347 |
FoldersManager foldersManager = ToolsLocator.getFoldersManager(); |
348 |
File file;
|
349 |
for (int i = 0; i <bands; i++) { |
350 |
String filename = "temp-buffer-"+this.simplePaginatedCounter+"-band-"+i+".tmp"; |
351 |
file = foldersManager.getUniqueTemporaryFile(filename); |
352 |
PageManager pageManager = |
353 |
createSimpleBandPageManager(file, rows, columns, bandTypes[i]); |
354 |
pageManagers.add(pageManager); |
355 |
} |
356 |
this.simplePaginatedCounter++;
|
357 |
return pageManagers;
|
358 |
} |
359 |
|
360 |
public List<Buffer> createOneBufferPerBand(Buffer buffer, boolean paginated) throws BufferException { |
361 |
ArrayList<Buffer> buffers = new ArrayList<Buffer>(); |
362 |
try {
|
363 |
for (int i = 0; i < buffer.getBandCount(); i++) { |
364 |
int[] dataType = {buffer.getBandTypes()[i]}; |
365 |
List<PageManager> pageManagers = null; |
366 |
if (paginated) {
|
367 |
pageManagers = createPageManagerList(1, buffer.getRows(), buffer.getColumns(), dataType);
|
368 |
} |
369 |
int[] bandTypes = new int[1]; |
370 |
bandTypes[0] = dataType[0]; |
371 |
NoData[] bandNoDatas = new NoData[1]; |
372 |
bandNoDatas[0] = buffer.getBandNoData()[i]; //.getBand(i).getNoData(); |
373 |
Buffer newBuffer =
|
374 |
createBuffer(buffer.getRows(), buffer.getColumns(), bandTypes, bandNoDatas, buffer.getProjection(), |
375 |
buffer.getEnvelope(), pageManagers); |
376 |
newBuffer.getBand(0).copyFrom(buffer.getBand(i));
|
377 |
buffers.add(newBuffer); |
378 |
} |
379 |
} catch (IOException | BandException | LocatorException | CreateEnvelopeException e) { |
380 |
throw new CreateBufferException(e); |
381 |
} |
382 |
return buffers;
|
383 |
} |
384 |
|
385 |
/**
|
386 |
* @param raster
|
387 |
* @return
|
388 |
*/
|
389 |
public int getBufferTypeFromAwtRaster(Raster raster) { |
390 |
int bufferType;
|
391 |
int dataType = raster.getSampleModel().getDataType();
|
392 |
switch (dataType) {
|
393 |
case java.awt.image.DataBuffer.TYPE_BYTE:
|
394 |
bufferType = BufferManager.TYPE_BYTE; |
395 |
break;
|
396 |
case java.awt.image.DataBuffer.TYPE_USHORT:
|
397 |
bufferType = BufferManager.TYPE_USHORT; |
398 |
break;
|
399 |
case java.awt.image.DataBuffer.TYPE_SHORT:
|
400 |
bufferType = BufferManager.TYPE_SHORT; |
401 |
break;
|
402 |
case java.awt.image.DataBuffer.TYPE_INT:
|
403 |
bufferType = BufferManager.TYPE_INT; |
404 |
break;
|
405 |
case java.awt.image.DataBuffer.TYPE_FLOAT:
|
406 |
bufferType = BufferManager.TYPE_FLOAT; |
407 |
break;
|
408 |
case java.awt.image.DataBuffer.TYPE_DOUBLE:
|
409 |
bufferType = BufferManager.TYPE_DOUBLE; |
410 |
break;
|
411 |
// case java.awt.image.DataBuffer.TYPE_UNDEFINED:
|
412 |
// bufferType = BufferManager.TYPE_UNDEFINED;
|
413 |
// break;
|
414 |
default:
|
415 |
throw new UnsupportedOperationException("DataBuffer type '" + dataType + "' no yet supported."); |
416 |
} |
417 |
return bufferType;
|
418 |
} |
419 |
|
420 |
private Buffer createBuffer(BufferedImage img, IProjection projection, Envelope envelope) throws BufferException { |
421 |
return createBuffer(img, projection, envelope, false); |
422 |
} |
423 |
|
424 |
private Buffer createBuffer(BufferedImage img, IProjection projection, Envelope envelope, boolean paginated) throws BufferException { |
425 |
SampleModel sampleModel = img.getSampleModel();
|
426 |
|
427 |
int dataType = sampleModel.getDataType();
|
428 |
int bufferType;
|
429 |
|
430 |
bufferType = getBufferTypeFromAwtRaster(img.getRaster()); |
431 |
|
432 |
int bands = sampleModel.getNumBands();
|
433 |
int[] bandDataTypes = new int[bands]; |
434 |
NoData[] bandNoData = new NoData[bands]; |
435 |
for (int i = 0; i < bandDataTypes.length; i++) { |
436 |
bandDataTypes[i] = bufferType; |
437 |
bandNoData[i] = null;
|
438 |
} |
439 |
|
440 |
List<PageManager> pageManagers = null; |
441 |
if (paginated) {
|
442 |
try {
|
443 |
pageManagers = createPageManagerList(bands, img.getHeight(), img.getWidth(), bandDataTypes); |
444 |
} catch (IOException e) { |
445 |
throw new CreateBufferException(e); |
446 |
} |
447 |
} |
448 |
Buffer buffer =
|
449 |
createBuffer(img.getHeight(), img.getWidth(), bandDataTypes, bandNoData, projection, envelope, pageManagers); |
450 |
|
451 |
Raster raster = img.getData();
|
452 |
DataBuffer dataBuffer = raster.getDataBuffer();
|
453 |
for (int i = 0; i < bands; i++) { |
454 |
Band band = buffer.getBand(i); |
455 |
|
456 |
if (bufferType == BufferManager.TYPE_BYTE) {
|
457 |
byte[] rowBuffer = (byte[]) band.createRowBuffer(); |
458 |
int[] intRowBuffer = new int[rowBuffer.length]; |
459 |
for (int row = 0; row < img.getHeight(); row++) { |
460 |
sampleModel.getSamples(0, row, img.getWidth(), 1, i, intRowBuffer, dataBuffer); |
461 |
for (int c = 0; c < rowBuffer.length; c++) { |
462 |
rowBuffer[c] = (byte) intRowBuffer[c];
|
463 |
} |
464 |
band.putRow(row, rowBuffer); |
465 |
} |
466 |
} else if (bufferType == BufferManager.TYPE_INT) { |
467 |
int[] rowBuffer = (int[]) band.createRowBuffer(); |
468 |
for (int row = 0; row < img.getHeight(); row++) { |
469 |
sampleModel.getSamples(0, row, img.getWidth(), 1, i, rowBuffer, dataBuffer); |
470 |
band.putRow(row, rowBuffer); |
471 |
} |
472 |
} |
473 |
} |
474 |
return buffer;
|
475 |
} |
476 |
|
477 |
@Override
|
478 |
public Buffer createRGBABuffer(BufferedImage img, IProjection projection, Envelope envelope) throws BufferException { |
479 |
|
480 |
int imageType = img.getType();
|
481 |
if(imageType == BufferedImage.TYPE_4BYTE_ABGR || imageType == BufferedImage.TYPE_4BYTE_ABGR_PRE) { |
482 |
return createBuffer(img, projection, envelope);
|
483 |
} |
484 |
|
485 |
int bands = 4; |
486 |
int[] bandDataTypes = new int[bands]; |
487 |
NoData[] bandNoData = new NoData[bands]; |
488 |
for (int i = 0; i < bandDataTypes.length; i++) { |
489 |
bandDataTypes[i] = BufferManager.TYPE_BYTE; |
490 |
bandNoData[i] = null;
|
491 |
} |
492 |
|
493 |
Buffer buffer = null; |
494 |
buffer = |
495 |
createBuffer(img.getHeight(), img.getWidth(), bandDataTypes, bandNoData, projection, envelope); |
496 |
|
497 |
for (int r = 0; r < img.getHeight(); r++) { |
498 |
for (int c = 0; c < img.getWidth(); c++) { |
499 |
int color = img.getRGB(c, r);
|
500 |
|
501 |
Color awtColor = new Color(color, true); |
502 |
buffer.getBandByte(0).set(r, c, (byte)awtColor.getRed()); // RED |
503 |
buffer.getBandByte(1).set(r, c, (byte)awtColor.getGreen()); // GREEN |
504 |
buffer.getBandByte(2).set(r, c, (byte)awtColor.getBlue()); // BLUE |
505 |
buffer.getBandByte(3).set(r, c, (byte)awtColor.getAlpha()); // ALPHA |
506 |
|
507 |
} |
508 |
} |
509 |
return buffer;
|
510 |
} |
511 |
|
512 |
@Override
|
513 |
public Buffer createRGBBuffer(BufferedImage img, IProjection projection, Envelope envelope) throws BufferException { |
514 |
|
515 |
int imageType = img.getType();
|
516 |
if(imageType == BufferedImage.TYPE_3BYTE_BGR) { |
517 |
return createBuffer(img, projection, envelope);
|
518 |
} |
519 |
|
520 |
int bands = 3; |
521 |
int[] bandDataTypes = new int[bands]; |
522 |
NoData[] bandNoData = new NoData[bands]; |
523 |
for (int i = 0; i < bandDataTypes.length; i++) { |
524 |
bandDataTypes[i] = BufferManager.TYPE_BYTE; |
525 |
bandNoData[i] = null;
|
526 |
} |
527 |
|
528 |
Buffer buffer = null; |
529 |
buffer = |
530 |
createBuffer(img.getHeight(), img.getWidth(), bandDataTypes, bandNoData, projection, envelope); |
531 |
|
532 |
for (int r = 0; r < img.getHeight(); r++) { |
533 |
for (int c = 0; c < img.getWidth(); c++) { |
534 |
int color = img.getRGB(c, r);
|
535 |
|
536 |
Color awtColor = new Color(color, true); |
537 |
buffer.getBandByte(0).set(r, c, (byte)awtColor.getRed()); // RED |
538 |
buffer.getBandByte(1).set(r, c, (byte)awtColor.getGreen()); // GREEN |
539 |
buffer.getBandByte(2).set(r, c, (byte)awtColor.getBlue()); // BLUE |
540 |
} |
541 |
} |
542 |
return buffer;
|
543 |
} |
544 |
|
545 |
@Override
|
546 |
public String getTypeName(int type) { |
547 |
DataTypesManager dtManager = ToolsLocator.getDataTypesManager(); |
548 |
String[] names = { |
549 |
dtManager.getTypeName(DataTypes.BYTE), |
550 |
"UShort",
|
551 |
"Short",
|
552 |
dtManager.getTypeName(DataTypes.INT), |
553 |
dtManager.getTypeName(DataTypes.FLOAT), |
554 |
dtManager.getTypeName(DataTypes.DOUBLE), |
555 |
}; |
556 |
if(type<=5){ |
557 |
return names[type];
|
558 |
} |
559 |
if(type==32){ |
560 |
return "Undefined"; |
561 |
} |
562 |
|
563 |
return "Unknow"; |
564 |
} |
565 |
|
566 |
public String getBufferTypeName(int dataType) { |
567 |
|
568 |
// FIXME
|
569 |
switch (dataType) {
|
570 |
case BufferManager.TYPE_BYTE:
|
571 |
return "Byte"; |
572 |
case BufferManager.TYPE_USHORT:
|
573 |
return "Unsigned short"; |
574 |
case BufferManager.TYPE_SHORT:
|
575 |
return "Short"; |
576 |
case BufferManager.TYPE_INT:
|
577 |
return "Integer"; |
578 |
case BufferManager.TYPE_FLOAT:
|
579 |
return "Float"; |
580 |
case BufferManager.TYPE_DOUBLE:
|
581 |
return "Double"; |
582 |
default:
|
583 |
throw new IllegalArgumentException(); |
584 |
} |
585 |
} |
586 |
|
587 |
@Override
|
588 |
public Object coerce(int dataType, Object value) throws CoercionException { |
589 |
Coercion coercion = null;
|
590 |
switch (dataType) {
|
591 |
case BufferManager.TYPE_BYTE:
|
592 |
// coercion = new CoerceToByte();
|
593 |
// return coercion.coerce(value);
|
594 |
coercion = new CoerceToInt();
|
595 |
return new Integer(Math.abs(0xFF & ((Integer) coercion.coerce(value)).intValue())).byteValue(); |
596 |
case BufferManager.TYPE_USHORT:
|
597 |
case BufferManager.TYPE_SHORT:
|
598 |
coercion = new CoerceToInt();
|
599 |
return 0xFFFF & ((Integer) coercion.coerce(value)).intValue(); |
600 |
case BufferManager.TYPE_INT:
|
601 |
coercion = new CoerceToInt();
|
602 |
return coercion.coerce(value);
|
603 |
case BufferManager.TYPE_FLOAT:
|
604 |
coercion = new CoerceToFloat();
|
605 |
return coercion.coerce(value);
|
606 |
case BufferManager.TYPE_DOUBLE:
|
607 |
coercion = new CoerceToDouble();
|
608 |
return coercion.coerce(value);
|
609 |
default:
|
610 |
throw new IllegalArgumentException("Unknow data type."); |
611 |
} |
612 |
} |
613 |
|
614 |
@Override
|
615 |
public BufferDimensions createBufferDimensions(int rows, int columns, Envelope envelope) { |
616 |
return new DefaultBufferDimensions(rows, columns, envelope); |
617 |
} |
618 |
|
619 |
@Override
|
620 |
public File getLastFolderUsedToSaveRaster() { |
621 |
return this.lastFolderUsedToSave; |
622 |
} |
623 |
|
624 |
@Override
|
625 |
public void setLastFolderUsedToSaveRaster(File folder) { |
626 |
this.lastFolderUsedToSave = folder;
|
627 |
} |
628 |
|
629 |
@Override
|
630 |
public Operation createOperation(String name) { |
631 |
OperationFactory factory = getOperationFactory(name); |
632 |
return factory.create();
|
633 |
} |
634 |
|
635 |
@Override
|
636 |
public DynObject createOperationParameters(String name) { |
637 |
OperationFactory factory = getOperationFactory(name); |
638 |
return factory.createParameters();
|
639 |
} |
640 |
|
641 |
@Override
|
642 |
public void registerOperationFactory(OperationFactory factory) { |
643 |
factory.getName(); |
644 |
this.operationFactoriesRegister.put(factory.getName(), factory);
|
645 |
} |
646 |
|
647 |
@Override
|
648 |
public List<OperationFactory> getOperationFactories() { |
649 |
return new ArrayList<OperationFactory>(this.operationFactoriesRegister.values()); |
650 |
} |
651 |
|
652 |
@Override
|
653 |
public OperationFactory getOperationFactory(String name) { |
654 |
return this.operationFactoriesRegister.get(name); |
655 |
} |
656 |
|
657 |
@Override
|
658 |
public Buffer execute(TaskStatus status, String name, Buffer buffer, DynObject parameters) throws BufferOperationException { |
659 |
OperationFactory factory = getOperationFactory(name); |
660 |
Operation operation = factory.create();
|
661 |
return operation.execute(status, buffer, parameters);
|
662 |
} |
663 |
|
664 |
@Override
|
665 |
public Kernel createKernel(double[][] k) { |
666 |
return new DefaultKernel(k); |
667 |
} |
668 |
|
669 |
@Override
|
670 |
public Kernel createKernel(double[][] k, double divisor) { |
671 |
return new DefaultKernel(k, divisor); |
672 |
} |
673 |
|
674 |
@Override
|
675 |
public OperationListEntry createOperationListEntry(Operation operation, DynObject parameters) { |
676 |
return new DefaultOperationListEntry(operation, parameters); |
677 |
} |
678 |
|
679 |
@Override
|
680 |
public OperationList createOperationList() {
|
681 |
return new DefaultOperationList(); |
682 |
} |
683 |
|
684 |
@Override
|
685 |
public Buffer createBufferFromAwtRaster(Raster raster, IProjection projection, Envelope envelope) |
686 |
throws IOException, BufferException { |
687 |
List<PageManager> pageManagers = createAwtRasterBandPageManagerList(raster);
|
688 |
int[] dataTypes = new int[(raster.getNumBands())]; |
689 |
for (int i = 0; i < dataTypes.length; i++) { |
690 |
dataTypes[i] = getBufferTypeFromAwtRaster(raster); |
691 |
} |
692 |
return createBuffer(raster.getHeight(), raster.getWidth(), dataTypes, null, projection, envelope, pageManagers); |
693 |
} |
694 |
|
695 |
|
696 |
} |