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