Revision 318 2.0/trunk/org.gvsig.gvsig3d/org.gvsig.gvsig3d.lib/org.gvsig.gvsig3d.lib.impl/src/main/java/org/gvsig/gvsig3d/impl/map3d/MapContext3DImpl.java
| MapContext3DImpl.java | ||
|---|---|---|
| 26 | 26 |
import java.awt.Graphics2D; |
| 27 | 27 |
import java.awt.geom.AffineTransform; |
| 28 | 28 |
import java.awt.image.BufferedImage; |
| 29 |
import java.awt.image.DataBuffer; |
|
| 30 | 29 |
import java.awt.image.ImagingOpException; |
| 31 | 30 |
import java.io.File; |
| 32 | 31 |
import java.io.IOException; |
| ... | ... | |
| 44 | 43 |
import org.gvsig.fmap.dal.coverage.exception.RasterDriverException; |
| 45 | 44 |
import org.gvsig.fmap.dal.coverage.store.RasterDataStore; |
| 46 | 45 |
import org.gvsig.fmap.dal.coverage.store.RasterQuery; |
| 46 |
import org.gvsig.fmap.dal.coverage.store.props.ColorInterpretation; |
|
| 47 | 47 |
import org.gvsig.fmap.dal.exception.ReadException; |
| 48 | 48 |
import org.gvsig.fmap.geom.Geometry; |
| 49 | 49 |
import org.gvsig.fmap.geom.GeometryLocator; |
| ... | ... | |
| 79 | 79 |
import org.gvsig.gvsig3d.map3d.Layer3DProps; |
| 80 | 80 |
import org.gvsig.gvsig3d.map3d.MapContext3D; |
| 81 | 81 |
import org.gvsig.gvsig3d.map3d.layers.FLayers3D; |
| 82 |
import org.gvsig.osgvp.core.osg.Image; |
|
| 82 | 83 |
import org.gvsig.gvsig3d.symbology3d.I3DSymbol; |
| 83 | 84 |
import org.gvsig.osgvp.core.osg.Matrix; |
| 84 | 85 |
import org.gvsig.osgvp.core.osg.Node; |
| ... | ... | |
| 115 | 116 |
import org.gvsig.raster.cache.tile.provider.CacheStruct; |
| 116 | 117 |
import org.gvsig.raster.fmap.layers.DefaultFLyrRaster; |
| 117 | 118 |
import org.gvsig.raster.impl.provider.DefaultRasterProvider; |
| 119 |
import org.gvsig.raster.impl.provider.tile.FileTileServer; |
|
| 118 | 120 |
import org.gvsig.raster.netcdf.io.NetCDFDataParameters; |
| 119 | 121 |
import org.gvsig.tools.ToolsLocator; |
| 120 | 122 |
import org.gvsig.tools.dynobject.DynStruct; |
| ... | ... | |
| 158 | 160 |
TileCacheManager tileMan = TileCacheLocator.getManager(); |
| 159 | 161 |
TileCache tileCache = tileMan.getTileCache(RasterLibrary.pathTileCache); |
| 160 | 162 |
|
| 163 |
int maxBands = 3; |
|
| 164 |
|
|
| 161 | 165 |
public MapContext3DImpl() {
|
| 162 | 166 |
} |
| 163 | 167 |
|
| ... | ... | |
| 493 | 497 |
hLayer.setMaxLevel(100); |
| 494 | 498 |
hLayer.setMaxResolution(100); |
| 495 | 499 |
// Esto esta hardcodeado |
| 496 |
hLayer.setScaleFactor(1);
|
|
| 500 |
hLayer.setScaleFactor(props.getVerticalEx());
|
|
| 497 | 501 |
|
| 498 | 502 |
hLayer.setValidDataValues(new Vec2(-9999, 9999)); |
| 499 | 503 |
// _logger.warn("computed optimum level = "
|
| ... | ... | |
| 761 | 765 |
// work |
| 762 | 766 |
((DefaultFLyrRaster) layer).init(); |
| 763 | 767 |
props3D.setType(Layer3DProps.layer3DImage); |
| 764 |
} catch (LoadLayerException e) {
|
|
| 768 |
} catch (LoadLayerException e) {
|
|
| 765 | 769 |
// TODO Auto-generated catch block |
| 766 | 770 |
e.printStackTrace(); |
| 767 | 771 |
} catch (FilePaletteException e) {
|
| ... | ... | |
| 828 | 832 |
if (proj != null) |
| 829 | 833 |
epsg = proj.getAbrev(); |
| 830 | 834 |
|
| 831 |
int resolution = 512;
|
|
| 835 |
int resolution = 256;
|
|
| 832 | 836 |
|
| 833 | 837 |
int type = getLayer3DProps(layer).getType(); |
| 834 | 838 |
|
| ... | ... | |
| 842 | 846 |
.toRectangle2D(), provider.getCellSize(), resolution, |
| 843 | 847 |
resolution, provider.getFullName(), |
| 844 | 848 |
TileCacheLibrary.DEFAULT_STRUCTURE, |
| 845 |
RasterLibrary.pathTileCache, "jpg", epsg, provider
|
|
| 849 |
RasterLibrary.pathTileCache, "png", epsg, provider
|
|
| 846 | 850 |
.getFileSize()); |
| 847 | 851 |
|
| 848 | 852 |
return struct; |
| ... | ... | |
| 1079 | 1083 |
ude.copyDataFromRequest(rde); |
| 1080 | 1084 |
if (layer instanceof DefaultFLyrRaster) {
|
| 1081 | 1085 |
DefaultFLyrRaster rLayer = (DefaultFLyrRaster) layer; |
| 1082 |
boolean hasCache = true; |
|
| 1083 |
if (rLayer.getDataStore().getInternalParameters() instanceof NetCDFDataParameters) |
|
| 1084 |
hasCache = false; |
|
| 1085 | 1086 |
|
| 1086 |
if (hasCache) {
|
|
| 1087 |
if (rLayer.getDataStore().isTiled()) {
|
|
| 1087 | 1088 |
|
| 1088 | 1089 |
rLayer = (DefaultFLyrRaster) layer; |
| 1090 |
|
|
| 1089 | 1091 |
boolean exists = _cachedLayers.containsKey(rLayer); |
| 1090 | 1092 |
|
| 1091 | 1093 |
if (!exists) {
|
| ... | ... | |
| 1107 | 1109 |
envelope.getLowerCorner().getY()); |
| 1108 | 1110 |
|
| 1109 | 1111 |
query.setTileParameters(rde.getTileLevel(), rde.getTileX(), |
| 1110 |
rde.getTileY(), extent, cacheStruct);
|
|
| 1112 |
rde.getTileY(), extent, null);
|
|
| 1111 | 1113 |
|
| 1112 | 1114 |
// query.setAreaOfInterest(extent, 512, 512); |
| 1113 | 1115 |
|
| 1114 |
// System.out.println("Tile Parameters:");
|
|
| 1115 |
// System.out.println("TileLevel: " + rde.getTileLevel());
|
|
| 1116 |
// System.out.println("TileX = " + rde.getTileX());
|
|
| 1117 |
// System.out.println("TileY = " + rde.getTileY());
|
|
| 1118 |
// System.out.println("Extent = " + extent.getULX() + " "
|
|
| 1119 |
// + extent.getULY() + " " + extent.getLRX() + " "
|
|
| 1120 |
// + extent.getLRY());
|
|
| 1116 |
// System.out.println("Tile Parameters:");
|
|
| 1117 |
// System.out.println("TileLevel: " + rde.getTileLevel());
|
|
| 1118 |
// System.out.println("TileX = " + rde.getTileX());
|
|
| 1119 |
// System.out.println("TileY = " + rde.getTileY());
|
|
| 1120 |
// System.out.println("Extent = " + extent.getULX() + " "
|
|
| 1121 |
// + extent.getULY() + " " + extent.getLRX() + " "
|
|
| 1122 |
// + extent.getLRY());
|
|
| 1121 | 1123 |
|
| 1122 | 1124 |
try {
|
| 1123 | 1125 |
Object[] result = rLayer.getDataStore().queryArray(query); |
| 1124 | 1126 |
Buffer rBuff = (Buffer) result[0]; |
| 1125 | 1127 |
Buffer transparencyBuffer; |
| 1128 |
int suma = 0; |
|
| 1126 | 1129 |
|
| 1127 |
if (result.length < 2) |
|
| 1128 |
transparencyBuffer = null; |
|
| 1129 |
else |
|
| 1130 |
transparencyBuffer = (Buffer) result[1]; |
|
| 1130 |
transparencyBuffer = (Buffer) result[1]; |
|
| 1131 | 1131 |
|
| 1132 |
// int numBands = rBuff.getBandCount(); |
|
| 1133 |
int numBands = rLayer.getDataStore().getBandCount(); |
|
| 1134 |
|
|
| 1135 |
// System.out.println("Tile ancho: " + rBuff.getWidth()
|
|
| 1136 |
// + " alto: " + rBuff.getHeight() |
|
| 1137 |
// + " bandas totales incluyendo alpha (si tiene): " |
|
| 1138 |
// + numBands); |
|
| 1139 |
|
|
| 1140 |
byte[] data = new byte[rBuff.getWidth() * rBuff.getHeight() |
|
| 1141 |
* numBands]; |
|
| 1142 |
|
|
| 1143 |
int dataType = convertDataType(rBuff.getDataType()); |
|
| 1144 |
int pixelFormat = convertPixelFormat(numBands); |
|
| 1145 |
|
|
| 1146 |
int colorBands = numBands; |
|
| 1147 |
|
|
| 1148 | 1132 |
if (transparencyBuffer != null) |
| 1149 |
colorBands--;
|
|
| 1133 |
suma = 1;
|
|
| 1150 | 1134 |
|
| 1151 |
int cont = 0; |
|
| 1135 |
// int bufferBands = rBuff.getBandCount(); |
|
| 1136 |
// Si el numero de bandas es mayor que 3 (RGB) no se pueden |
|
| 1137 |
// dibujar todas |
|
| 1138 |
int numBands = rLayer.getDataStore().getBandCount(); |
|
| 1152 | 1139 |
|
| 1153 |
for (int i = 0; i < rBuff.getWidth(); i++) {
|
|
| 1140 |
if (numBands > (maxBands + suma)) |
|
| 1141 |
numBands = maxBands + suma; |
|
| 1154 | 1142 |
|
| 1155 |
for (int j = 0; j < rBuff.getHeight(); j++) {
|
|
| 1143 |
ColorInterpretation cInt = rLayer.getDataStore() |
|
| 1144 |
.getColorInterpretation(); |
|
| 1156 | 1145 |
|
| 1157 |
for (int k = 0; k < colorBands; k++) {
|
|
| 1146 |
int rgba[] = {0,1,2,3};
|
|
| 1147 |
|
|
| 1148 |
rgba = setBandsInColors(cInt); |
|
| 1158 | 1149 |
|
| 1159 |
switch (rBuff.getDataType()) {
|
|
| 1160 |
case Buffer.TYPE_BYTE: |
|
| 1161 |
data[cont] = (byte) (rBuff.getElemByte(i, |
|
| 1162 |
j, k)); |
|
| 1163 |
cont++; |
|
| 1164 |
break; |
|
| 1165 |
case Buffer.TYPE_DOUBLE: |
|
| 1166 |
data[cont] = (byte) (Math.round(rBuff |
|
| 1167 |
.getElemDouble(i, j, k))); |
|
| 1168 |
cont++; |
|
| 1169 |
break; |
|
| 1170 |
case Buffer.TYPE_FLOAT: |
|
| 1171 |
data[cont] = (byte) (Math.round(rBuff |
|
| 1172 |
.getElemFloat(i, j, k))); |
|
| 1173 |
cont++; |
|
| 1174 |
break; |
|
| 1175 |
case Buffer.TYPE_INT: |
|
| 1176 |
data[cont] = (byte) (rBuff.getElemInt(i, j, |
|
| 1177 |
k) & 0xffffffff); |
|
| 1178 |
cont++; |
|
| 1179 |
break; |
|
| 1180 |
case Buffer.TYPE_SHORT: |
|
| 1181 |
case Buffer.TYPE_USHORT: |
|
| 1182 |
data[cont] = (byte) (rBuff.getElemShort(i, |
|
| 1183 |
j, k) & 0xffff); |
|
| 1184 |
cont++; |
|
| 1185 |
break; |
|
| 1186 |
} |
|
| 1187 |
} |
|
| 1150 |
int pixelFormat = convertPixelFormat(numBands); |
|
| 1188 | 1151 |
|
| 1189 |
if (transparencyBuffer != null) {
|
|
| 1152 |
// System.out.println("Tile ancho: " + rBuff.getWidth()
|
|
| 1153 |
// + " alto: " + rBuff.getHeight() |
|
| 1154 |
// + " bandas totales incluyendo alpha (si tiene): " |
|
| 1155 |
// + numBands); |
|
| 1190 | 1156 |
|
| 1191 |
switch (transparencyBuffer.getDataType()) {
|
|
| 1192 |
case Buffer.TYPE_BYTE: |
|
| 1193 |
|
|
| 1194 |
if (transparencyBuffer.getElemByte(i, j, 0) == 0) |
|
| 1195 |
data[cont] = (byte) (0); |
|
| 1196 |
else |
|
| 1197 |
data[cont] = (byte) (255); |
|
| 1198 |
cont++; |
|
| 1199 |
break; |
|
| 1200 |
case Buffer.TYPE_DOUBLE: |
|
| 1201 |
data[cont] = (byte) (Math |
|
| 1202 |
.round(transparencyBuffer |
|
| 1203 |
.getElemInt(i, j, 0))); |
|
| 1204 |
cont++; |
|
| 1205 |
break; |
|
| 1206 |
case Buffer.TYPE_FLOAT: |
|
| 1207 |
data[cont] = (byte) (Math |
|
| 1208 |
.round(transparencyBuffer |
|
| 1209 |
.getElemFloat(i, j, 0))); |
|
| 1210 |
cont++; |
|
| 1211 |
break; |
|
| 1212 |
case Buffer.TYPE_INT: |
|
| 1213 |
data[cont] = (byte) (transparencyBuffer |
|
| 1214 |
.getElemInt(i, j, 0) & 0xffffffff); |
|
| 1215 |
cont++; |
|
| 1216 |
break; |
|
| 1217 |
case Buffer.TYPE_SHORT: |
|
| 1218 |
case Buffer.TYPE_USHORT: |
|
| 1219 |
data[cont] = (byte) (transparencyBuffer |
|
| 1220 |
.getElemShort(i, j, 0) & 0xffff); |
|
| 1221 |
cont++; |
|
| 1222 |
break; |
|
| 1223 |
} |
|
| 1224 |
|
|
| 1225 |
} |
|
| 1226 |
|
|
| 1227 |
} |
|
| 1228 |
|
|
| 1157 |
switch (rBuff.getDataType()) {
|
|
| 1158 |
case Buffer.TYPE_BYTE: |
|
| 1159 |
ude.setRasterData( |
|
| 1160 |
buildByteBuffer(ude, rBuff, transparencyBuffer, |
|
| 1161 |
numBands,rgba), rBuff.getWidth(), rBuff |
|
| 1162 |
.getHeight(), numBands, pixelFormat, |
|
| 1163 |
Image.DataType.GL_UNSIGNED_BYTE); |
|
| 1164 |
break; |
|
| 1165 |
case Buffer.TYPE_SHORT: |
|
| 1166 |
ude.setRasterData( |
|
| 1167 |
buildShortBuffer(ude, rBuff, |
|
| 1168 |
transparencyBuffer, numBands), rBuff |
|
| 1169 |
.getWidth(), rBuff.getHeight(), |
|
| 1170 |
numBands, pixelFormat, Image.DataType.GL_SHORT); |
|
| 1171 |
break; |
|
| 1172 |
case Buffer.TYPE_USHORT: |
|
| 1173 |
ude.setRasterData( |
|
| 1174 |
buildShortBuffer(ude, rBuff, |
|
| 1175 |
transparencyBuffer, numBands), rBuff |
|
| 1176 |
.getWidth(), rBuff.getHeight(), |
|
| 1177 |
numBands, pixelFormat, |
|
| 1178 |
Image.DataType.GL_UNSIGNED_SHORT); |
|
| 1179 |
break; |
|
| 1180 |
case Buffer.TYPE_INT: |
|
| 1181 |
ude.setRasterData( |
|
| 1182 |
buildIntBuffer(ude, rBuff, transparencyBuffer, |
|
| 1183 |
numBands), rBuff.getWidth(), rBuff |
|
| 1184 |
.getHeight(), numBands, pixelFormat, |
|
| 1185 |
Image.DataType.GL_INT); |
|
| 1186 |
break; |
|
| 1187 |
case Buffer.TYPE_FLOAT: |
|
| 1188 |
ude.setRasterData( |
|
| 1189 |
buildFloatBuffer(ude, rBuff, |
|
| 1190 |
transparencyBuffer, numBands), rBuff |
|
| 1191 |
.getWidth(), rBuff.getHeight(), |
|
| 1192 |
numBands, pixelFormat, Image.DataType.GL_FLOAT); |
|
| 1193 |
break; |
|
| 1194 |
case Buffer.TYPE_DOUBLE: |
|
| 1195 |
ude.setRasterData( |
|
| 1196 |
buildDoubleBuffer(ude, rBuff, |
|
| 1197 |
transparencyBuffer, numBands), rBuff |
|
| 1198 |
.getWidth(), rBuff.getHeight(), |
|
| 1199 |
numBands, pixelFormat, Image.DataType.GL_DOUBLE); |
|
| 1200 |
break; |
|
| 1229 | 1201 |
} |
| 1230 |
ude.setRasterData( |
|
| 1231 |
data, |
|
| 1232 |
rBuff.getWidth(), |
|
| 1233 |
rBuff.getHeight(), |
|
| 1234 |
numBands, |
|
| 1235 |
pixelFormat, |
|
| 1236 |
org.gvsig.osgvp.core.osg.Image.DataType.GL_UNSIGNED_BYTE); |
|
| 1237 | 1202 |
|
| 1238 | 1203 |
// ude.setRasterData(getLayerDrawImage(layer, envelope)); |
| 1239 | 1204 |
|
| ... | ... | |
| 1241 | 1206 |
// TODO Auto-generated catch block |
| 1242 | 1207 |
e.printStackTrace(); |
| 1243 | 1208 |
} catch (RasterDriverException e) {
|
| 1244 |
e.printStackTrace(); |
|
| 1209 |
System.out.println("QueryArray failed");
|
|
| 1210 |
//e.printStackTrace(); |
|
| 1245 | 1211 |
} catch (InvalidSetViewException e) {
|
| 1246 | 1212 |
// TODO Auto-generated catch block |
| 1247 | 1213 |
e.printStackTrace(); |
| 1248 | 1214 |
} catch (NullPointerException e) {
|
| 1249 | 1215 |
// ude.setFailData(); |
| 1250 |
// System.out.println("Problem getting the tile");
|
|
| 1216 |
System.out.println("Problem getting the tile. NullPointer");
|
|
| 1251 | 1217 |
} |
| 1252 | 1218 |
|
| 1253 | 1219 |
} |
| 1254 |
// No cache
|
|
| 1220 |
// Not tiled raster
|
|
| 1255 | 1221 |
else {
|
| 1256 | 1222 |
ude.setRasterData(getLayerDrawImage(layer, envelope)); |
| 1257 | 1223 |
} |
| ... | ... | |
| 1267 | 1233 |
ude.setFailData(); |
| 1268 | 1234 |
} |
| 1269 | 1235 |
|
| 1236 |
// System.out.println("Returning UDE");
|
|
| 1237 |
|
|
| 1270 | 1238 |
return ude; |
| 1271 | 1239 |
} |
| 1272 | 1240 |
|
| ... | ... | |
| 1405 | 1373 |
float[] data = new float[(rBuff.getWidth() * rBuff |
| 1406 | 1374 |
.getHeight()) / 64]; |
| 1407 | 1375 |
|
| 1408 |
int dataType = convertDataType(rBuff.getDataType()); |
|
| 1409 | 1376 |
int pixelFormat = convertPixelFormat(numBands); |
| 1410 | 1377 |
|
| 1411 | 1378 |
// K hay que setearlo en el dialogo |
| 1412 |
int cont = 0, k = 0;
|
|
| 1379 |
int cont = 0; |
|
| 1413 | 1380 |
|
| 1381 |
int k = getLayer3DProps(rLayer).getElevationBand(); |
|
| 1382 |
|
|
| 1414 | 1383 |
for (int i = rBuff.getWidth() - 1; i >= 0; i = i - 8) {
|
| 1415 | 1384 |
// Vertical Flip needed |
| 1416 | 1385 |
for (int j = 0; j < rBuff.getHeight(); j = j + 8) {
|
| ... | ... | |
| 1485 | 1454 |
|
| 1486 | 1455 |
} |
| 1487 | 1456 |
|
| 1488 |
protected int convertDataType(int type) {
|
|
| 1457 |
protected byte[] buildByteBuffer(UpdateDataEvent ude, Buffer rBuff, |
|
| 1458 |
Buffer transparencyBuffer, int numBands, int[] rgba) {
|
|
| 1489 | 1459 |
|
| 1490 |
switch (type) {
|
|
| 1460 |
int cont = 0; |
|
| 1461 |
int colorBands = numBands; |
|
| 1491 | 1462 |
|
| 1492 |
case DataBuffer.TYPE_BYTE: |
|
| 1493 |
return org.gvsig.osgvp.core.osg.Image.DataType.GL_BYTE; |
|
| 1463 |
if (transparencyBuffer != null) {
|
|
| 1464 |
colorBands--; |
|
| 1465 |
} |
|
| 1494 | 1466 |
|
| 1495 |
case DataBuffer.TYPE_DOUBLE: |
|
| 1496 |
return org.gvsig.osgvp.core.osg.Image.DataType.GL_DOUBLE; |
|
| 1467 |
byte[] data = new byte[rBuff.getWidth() * rBuff.getHeight() * numBands]; |
|
| 1497 | 1468 |
|
| 1498 |
case DataBuffer.TYPE_FLOAT: |
|
| 1499 |
return org.gvsig.osgvp.core.osg.Image.DataType.GL_FLOAT; |
|
| 1469 |
for (int i = 0; i < rBuff.getWidth(); i++) {
|
|
| 1500 | 1470 |
|
| 1501 |
case DataBuffer.TYPE_INT: |
|
| 1502 |
return org.gvsig.osgvp.core.osg.Image.DataType.GL_INT; |
|
| 1471 |
for (int j = 0; j < rBuff.getHeight(); j++) {
|
|
| 1503 | 1472 |
|
| 1504 |
case DataBuffer.TYPE_SHORT: |
|
| 1505 |
return org.gvsig.osgvp.core.osg.Image.DataType.GL_SHORT; |
|
| 1473 |
for (int k = 0; k < colorBands; k++) {
|
|
| 1474 |
// En lugar de k se deben usar las bandas asociadas al |
|
| 1475 |
// componente |
|
| 1476 |
data[cont] = (byte) rBuff.getElemByte(i, j, rgba[k]); |
|
| 1477 |
cont++; |
|
| 1506 | 1478 |
|
| 1507 |
case DataBuffer.TYPE_USHORT: |
|
| 1508 |
return org.gvsig.osgvp.core.osg.Image.DataType.GL_UNSIGNED_SHORT; |
|
| 1479 |
} |
|
| 1480 |
if (transparencyBuffer != null) {
|
|
| 1481 |
if (transparencyBuffer.getElemByte(i, j, 0) == 0) |
|
| 1482 |
data[cont] = (byte) 0; |
|
| 1483 |
else |
|
| 1484 |
data[cont] = (byte) 255; |
|
| 1485 |
//data[cont] = transparencyBuffer.getElemByte(i, j, 0); |
|
| 1509 | 1486 |
|
| 1487 |
cont++; |
|
| 1488 |
|
|
| 1489 |
} |
|
| 1490 |
} |
|
| 1510 | 1491 |
} |
| 1511 | 1492 |
|
| 1512 |
return org.gvsig.osgvp.core.osg.Image.DataType.GL_BYTE; |
|
| 1493 |
return data; |
|
| 1494 |
} |
|
| 1513 | 1495 |
|
| 1496 |
protected short[] buildShortBuffer(UpdateDataEvent ude, Buffer rBuff, |
|
| 1497 |
Buffer transparencyBuffer, int numBands) {
|
|
| 1498 |
short[] data = new short[rBuff.getWidth() * rBuff.getHeight() |
|
| 1499 |
* numBands]; |
|
| 1500 |
|
|
| 1501 |
int cont = 0; |
|
| 1502 |
int colorBands = numBands; |
|
| 1503 |
|
|
| 1504 |
if (transparencyBuffer != null) |
|
| 1505 |
colorBands--; |
|
| 1506 |
|
|
| 1507 |
for (int i = 0; i < rBuff.getWidth(); i++) {
|
|
| 1508 |
|
|
| 1509 |
for (int j = 0; j < rBuff.getHeight(); j++) {
|
|
| 1510 |
|
|
| 1511 |
for (int k = 0; k < colorBands; k++) {
|
|
| 1512 |
data[cont] = (short) (rBuff.getElemShort(i, j, k) & 0xffff); |
|
| 1513 |
cont++; |
|
| 1514 |
} |
|
| 1515 |
if (transparencyBuffer != null) {
|
|
| 1516 |
data[cont] = (short) (rBuff.getElemShort(i, j, 0) & 0xffff); |
|
| 1517 |
cont++; |
|
| 1518 |
} |
|
| 1519 |
} |
|
| 1520 |
} |
|
| 1521 |
|
|
| 1522 |
return data; |
|
| 1514 | 1523 |
} |
| 1515 | 1524 |
|
| 1525 |
protected int[] buildIntBuffer(UpdateDataEvent ude, Buffer rBuff, |
|
| 1526 |
Buffer transparencyBuffer, int numBands) {
|
|
| 1527 |
int[] data = new int[rBuff.getWidth() * rBuff.getHeight() * numBands]; |
|
| 1528 |
|
|
| 1529 |
int cont = 0; |
|
| 1530 |
int colorBands = numBands; |
|
| 1531 |
|
|
| 1532 |
if (transparencyBuffer != null) |
|
| 1533 |
colorBands--; |
|
| 1534 |
|
|
| 1535 |
for (int i = 0; i < rBuff.getWidth(); i++) {
|
|
| 1536 |
|
|
| 1537 |
for (int j = 0; j < rBuff.getHeight(); j++) {
|
|
| 1538 |
|
|
| 1539 |
for (int k = 0; k < colorBands; k++) {
|
|
| 1540 |
data[cont] = (int) (rBuff.getElemByte(i, j, k) & 0xffffffff); |
|
| 1541 |
cont++; |
|
| 1542 |
} |
|
| 1543 |
if (transparencyBuffer != null) {
|
|
| 1544 |
data[cont] = (int) (rBuff.getElemByte(i, j, 0) & 0xffffffff); |
|
| 1545 |
cont++; |
|
| 1546 |
} |
|
| 1547 |
} |
|
| 1548 |
} |
|
| 1549 |
|
|
| 1550 |
return data; |
|
| 1551 |
} |
|
| 1552 |
|
|
| 1553 |
protected float[] buildFloatBuffer(UpdateDataEvent ude, Buffer rBuff, |
|
| 1554 |
Buffer transparencyBuffer, int numBands) {
|
|
| 1555 |
float[] data = new float[rBuff.getWidth() * rBuff.getHeight() |
|
| 1556 |
* numBands]; |
|
| 1557 |
|
|
| 1558 |
int cont = 0; |
|
| 1559 |
int colorBands = numBands; |
|
| 1560 |
|
|
| 1561 |
if (transparencyBuffer != null) |
|
| 1562 |
colorBands--; |
|
| 1563 |
|
|
| 1564 |
for (int i = 0; i < rBuff.getWidth(); i++) {
|
|
| 1565 |
|
|
| 1566 |
for (int j = 0; j < rBuff.getHeight(); j++) {
|
|
| 1567 |
|
|
| 1568 |
for (int k = 0; k < colorBands; k++) {
|
|
| 1569 |
data[cont] = rBuff.getElemByte(i, j, k); |
|
| 1570 |
cont++; |
|
| 1571 |
} |
|
| 1572 |
if (transparencyBuffer != null) {
|
|
| 1573 |
data[cont] = rBuff.getElemByte(i, j, 0); |
|
| 1574 |
cont++; |
|
| 1575 |
} |
|
| 1576 |
} |
|
| 1577 |
} |
|
| 1578 |
|
|
| 1579 |
return data; |
|
| 1580 |
} |
|
| 1581 |
|
|
| 1582 |
protected double[] buildDoubleBuffer(UpdateDataEvent ude, Buffer rBuff, |
|
| 1583 |
Buffer transparencyBuffer, int numBands) {
|
|
| 1584 |
double[] data = new double[rBuff.getWidth() * rBuff.getHeight() |
|
| 1585 |
* numBands]; |
|
| 1586 |
|
|
| 1587 |
int cont = 0; |
|
| 1588 |
int colorBands = numBands; |
|
| 1589 |
|
|
| 1590 |
if (transparencyBuffer != null) |
|
| 1591 |
colorBands--; |
|
| 1592 |
|
|
| 1593 |
for (int i = 0; i < rBuff.getWidth(); i++) {
|
|
| 1594 |
|
|
| 1595 |
for (int j = 0; j < rBuff.getHeight(); j++) {
|
|
| 1596 |
|
|
| 1597 |
for (int k = 0; k < colorBands; k++) {
|
|
| 1598 |
data[cont] = rBuff.getElemByte(i, j, k); |
|
| 1599 |
cont++; |
|
| 1600 |
} |
|
| 1601 |
if (transparencyBuffer != null) {
|
|
| 1602 |
data[cont] = rBuff.getElemByte(i, j, 0); |
|
| 1603 |
cont++; |
|
| 1604 |
} |
|
| 1605 |
} |
|
| 1606 |
} |
|
| 1607 |
|
|
| 1608 |
return data; |
|
| 1609 |
} |
|
| 1610 |
|
|
| 1516 | 1611 |
protected int convertPixelFormat(int type) {
|
| 1517 | 1612 |
|
| 1518 | 1613 |
switch (type) {
|
| ... | ... | |
| 1535 | 1630 |
|
| 1536 | 1631 |
} |
| 1537 | 1632 |
|
| 1633 |
protected int[] setBandsInColors(ColorInterpretation cInt) {
|
|
| 1634 |
|
|
| 1635 |
int rgba[] = new int[4]; |
|
| 1636 |
|
|
| 1637 |
rgba[0] = cInt.getBand(ColorInterpretation.RED_BAND); |
|
| 1638 |
if(rgba[0]==-1) rgba[0]=0; |
|
| 1639 |
rgba[1] = cInt.getBand(ColorInterpretation.GREEN_BAND); |
|
| 1640 |
if(rgba[1]==-1) rgba[1]=1; |
|
| 1641 |
rgba[2] = cInt.getBand(ColorInterpretation.BLUE_BAND); |
|
| 1642 |
if(rgba[2]==-1) rgba[2]=2; |
|
| 1643 |
rgba[3] = cInt.getBand(ColorInterpretation.ALPHA_BAND); |
|
| 1644 |
if(rgba[3]==-1) rgba[3]=3; |
|
| 1645 |
|
|
| 1646 |
return rgba; |
|
| 1647 |
|
|
| 1648 |
} |
|
| 1649 |
|
|
| 1538 | 1650 |
protected class MyCancel implements Cancellable {
|
| 1539 | 1651 |
private boolean cancel = false; |
| 1540 | 1652 |
|
| ... | ... | |
| 1631 | 1743 |
} |
| 1632 | 1744 |
|
| 1633 | 1745 |
public void removeLayerToTerrain(FLayer layer) {
|
| 1634 |
// TODO Auto-generated method stub |
|
| 1635 |
Layer3DProps props3D = getLayer3DProps(layer); |
|
| 1636 | 1746 |
|
| 1637 |
if (props3D.getType() == Layer3DProps.layer3DVector) {
|
|
| 1638 |
// DeleteVectors(layer, props3D); |
|
| 1639 |
} else if (props3D.getType() == Layer3DProps.layer3DOSG) {
|
|
| 1640 |
DeleteOSGLayer(layer, props3D); |
|
| 1641 |
} else {
|
|
| 1642 |
Layer terrainLayer = _terrainFLayerMap.get(layer); |
|
| 1643 |
if (terrainLayer != null) {
|
|
| 1644 |
// FLayerCacheService cacheService = (FLayerCacheService) |
|
| 1645 |
// props3D |
|
| 1646 |
// .getCacheService(); |
|
| 1647 |
// if (cacheService != null) |
|
| 1648 |
// try {
|
|
| 1649 |
// cacheService.free(); |
|
| 1650 |
// } catch (Throwable e) {
|
|
| 1651 |
// // TODO Auto-generated catch block |
|
| 1652 |
// e.printStackTrace(); |
|
| 1653 |
// } |
|
| 1654 |
_terrainLayerMap.remove(terrainLayer.getLayerID()); |
|
| 1655 |
_terrainFLayerMap.remove(layer); |
|
| 1747 |
Layer terrainLayer = _terrainFLayerMap.get(layer); |
|
| 1748 |
if (terrainLayer != null) {
|
|
| 1656 | 1749 |
|
| 1657 |
try {
|
|
| 1658 |
_terrainLayerManager.removeLayer(terrainLayer); |
|
| 1659 |
} catch (LayerManagementException e) {
|
|
| 1660 |
// TODO Auto-generated catch block |
|
| 1661 |
e.printStackTrace(); |
|
| 1662 |
} |
|
| 1750 |
_terrainLayerMap.remove(terrainLayer.getLayerID()); |
|
| 1751 |
_terrainFLayerMap.remove(layer); |
|
| 1752 |
|
|
| 1753 |
try {
|
|
| 1754 |
_terrainLayerManager.removeLayer(terrainLayer); |
|
| 1755 |
} catch (LayerManagementException e) {
|
|
| 1756 |
// TODO Auto-generated catch block |
|
| 1757 |
e.printStackTrace(); |
|
| 1663 | 1758 |
} |
| 1664 | 1759 |
} |
| 1665 | 1760 |
|
Also available in: Unified diff