Revision 12749
| trunk/libraries/libRaster/src/org/gvsig/raster/dataset/RasterDataset.java | ||
|---|---|---|
| 357 | 357 |
* Obtiene una ventana de datos de la imagen a partir de coordenadas reales. |
| 358 | 358 |
* No aplica supersampleo ni subsampleo sino que devuelve una matriz de igual tama?o a los |
| 359 | 359 |
* pixeles de disco. |
| 360 |
* @param ulx Posici?n X superior izquierda |
|
| 361 |
* @param uly Posici?n Y superior izquierda |
|
| 362 |
* @param lrx Posici?n X inferior derecha |
|
| 363 |
* @param lry Posici?n Y inferior derecha |
|
| 364 |
* @param rasterBuf Buffer de datos |
|
| 365 |
* @param bandList |
|
| 366 |
* @return Buffer de datos |
|
| 367 |
*/ |
|
| 368 |
abstract public IBuffer getWindowRaster(double ulx, double uly, double lrx, double lry, BandList bandList, IBuffer rasterBuf); |
|
| 369 |
|
|
| 370 |
/** |
|
| 371 |
* Obtiene una ventana de datos de la imagen a partir de coordenadas reales. |
|
| 372 |
* No aplica supersampleo ni subsampleo sino que devuelve una matriz de igual tama?o a los |
|
| 373 |
* pixeles de disco. |
|
| 360 | 374 |
* @param x Posici?n X superior izquierda |
| 361 | 375 |
* @param y Posici?n Y superior izquierda |
| 362 | 376 |
* @param w Ancho en coordenadas reales |
| trunk/libraries/libRaster/src/org/gvsig/raster/dataset/MultiRasterDataset.java | ||
|---|---|---|
| 331 | 331 |
} |
| 332 | 332 |
} |
| 333 | 333 |
} |
| 334 |
|
|
| 335 |
/** |
|
| 336 |
* Obtiene una ventana de datos de la imagen a partir de coordenadas reales. |
|
| 337 |
* No aplica supersampleo ni subsampleo sino que devuelve una matriz de igual tama?o a los |
|
| 338 |
* pixeles de disco. |
|
| 339 |
* @param x Posici?n X superior izquierda |
|
| 340 |
* @param y Posici?n Y superior izquierda |
|
| 341 |
* @param w Ancho en coordenadas reales |
|
| 342 |
* @param h Alto en coordenadas reales |
|
| 343 |
* @param adjustToExtent Flag que dice si el extent solicitado debe ajustarse al extent del raster o no. |
|
| 344 |
* @param bandList |
|
| 345 |
* @return Buffer de datos |
|
| 346 |
*/ |
|
| 347 |
public IBuffer getWindowRaster(double ulx, double uly, double lrx, double lry) throws InvalidSetViewException {
|
|
| 348 |
Extent selectedExtent = new Extent(ulx, uly, lrx, lry); |
|
| 349 |
|
|
| 350 |
//Leemos pixels completos aunque el valor obtenido sea decimal. Esto se consigue redondeando |
|
| 351 |
//por arriba el m?s alto y por abajo el menor y luego restandolos |
|
| 352 |
|
|
| 353 |
Point2D p1 = ((RasterDataset)files.get(0)).worldToRaster(new Point2D.Double(ulx, uly)); |
|
| 354 |
Point2D p2 = ((RasterDataset)files.get(0)).worldToRaster(new Point2D.Double(lrx, lry)); |
|
| 355 |
int width = (int)Math.abs(Math.ceil(p2.getX()) - Math.floor(p1.getX())); |
|
| 356 |
int height = (int)Math.abs(Math.floor(p1.getY()) - Math.ceil(p2.getY())); |
|
| 357 |
|
|
| 358 |
//Ajustamos por si nos hemos salido del raster |
|
| 359 |
while(((int)(p1.getX() + width)) > getWidth()[0]) |
|
| 360 |
width --; |
|
| 361 |
while(((int)(p1.getY() + height)) > getHeight()[0]) |
|
| 362 |
height --; |
|
| 363 |
|
|
| 364 |
if(p1.getX() < 0) |
|
| 365 |
p1.setLocation(0, p1.getY()); |
|
| 366 |
if(p1.getY() < 0) |
|
| 367 |
p1.setLocation(p1.getX(), 0); |
|
| 368 |
if(p2.getX() > getWidth()[0]) |
|
| 369 |
p2.setLocation(getWidth()[0], p2.getY()); |
|
| 370 |
if(p1.getY() > getHeight()[0]) |
|
| 371 |
p1.setLocation(p2.getX(), getHeight()[0]); |
|
| 372 |
|
|
| 373 |
int mallocNBands = 0; |
|
| 374 |
if(bandList.getDrawableBands() != null) |
|
| 375 |
mallocNBands = bandList.getDrawableBands().length; |
|
| 376 |
else |
|
| 377 |
mallocNBands = bandList.getDrawableBandsCount(); |
|
| 378 |
|
|
| 379 |
IBuffer raster = RasterBuffer.getBuffer(getDataType()[0], width, height, mallocNBands, false); |
|
| 380 |
|
|
| 381 |
//Caso en el que un buffer no se puedan conmutar las bandas (t?picamente RasterReadOnlyHugeBuffer) |
|
| 382 |
if(!raster.isBandSwitchable()) {
|
|
| 383 |
RasterBuffer rb = RasterBuffer.getBuffer(getDataType()[0], width, height, getDataset(0).getBandCount(), false); |
|
| 384 |
if(rb instanceof RasterReadOnlyHugeBuffer) {
|
|
| 385 |
try {
|
|
| 386 |
((RasterReadOnlyHugeBuffer)rb).setBufferParams(getDataset(0).getFName(), selectedExtent); |
|
| 387 |
} catch (FileNotExistsException e) {
|
|
| 388 |
//Esto no debe darse ya que se comprueba al hacer el open |
|
| 389 |
} catch (NotSupportedExtensionException e) {
|
|
| 390 |
//Esto no debe darse ya que se comprueba al hacer el open |
|
| 391 |
} |
|
| 392 |
return rb; |
|
| 393 |
} |
|
| 394 |
} |
|
| 395 |
|
|
| 396 |
for(int iBand = 0; iBand < raster.getBandCount(); iBand ++) |
|
| 397 |
raster.assignBandToNotValid(iBand); |
|
| 398 |
|
|
| 399 |
//Reservamos memoria para los buffers por dataset |
|
| 400 |
IBuffer[] bufferDatasets = mallocBuffersDatasets(bandList, width, height); |
|
| 401 |
|
|
| 402 |
//Si hemos redondeado los pixeles de la petici?n (p1 y p2) por arriba y por abajo deberemos calcular un extent mayor |
|
| 403 |
//equivalente a los pixeles redondeados. |
|
| 404 |
Point2D wc1 = ((RasterDataset)files.get(0)).rasterToWorld(new Point2D.Double(Math.floor(p1.getX()), Math.floor(p1.getY()))); |
|
| 405 |
Point2D wc2 = ((RasterDataset)files.get(0)).rasterToWorld(new Point2D.Double(Math.ceil(p2.getX()), Math.ceil(p2.getY()))); |
|
| 406 |
for(int i = 0; i < getDatasetCount(); i++) |
|
| 407 |
bufferDatasets[i] = ((RasterDataset)files.get(i)).getWindowRaster(wc1.getX(), wc1.getY(), wc2.getX(), wc2.getY(), bandList, bufferDatasets[i]); |
|
| 408 |
|
|
| 409 |
//Mezclamos los buffers de cada dataset en un solo buffer |
|
| 410 |
mergeBuffers(raster, bufferDatasets, bandList); |
|
| 411 |
|
|
| 412 |
return raster; |
|
| 413 |
} |
|
| 334 | 414 |
|
| 335 | 415 |
/** |
| 336 | 416 |
* Obtiene una ventana de datos de la imagen a partir de coordenadas reales. |
| ... | ... | |
| 353 | 433 |
Point2D pEnd = ((RasterDataset)files.get(0)).rasterToWorld(new Point2D.Double((int)getWidth()[0], (int)getHeight()[0])); |
| 354 | 434 |
double wRaster = Math.abs(pEnd.getX() - pInit.getX()); |
| 355 | 435 |
double hRaster = Math.abs(pEnd.getY() - pInit.getY()); |
| 356 |
double lrx = (((ext.getULX() - wRaster) > ext.maxX()) || ((ext.getULX() - wRaster) < ext.minX())) ? (ulx + w) : (ulx - w);
|
|
| 357 |
double lry = (((ext.getULY() - hRaster) > ext.maxY()) || ((ext.getULY() - hRaster) < ext.minY())) ? (uly + h) : (uly - h);
|
|
| 436 |
double lrx = (((int)(ext.getULX() - wRaster)) == ((int)ext.getLRX())) ? (ulx - w) : (ulx + w);
|
|
| 437 |
double lry = (((int)(ext.getULY() - hRaster)) == ((int)ext.getLRY())) ? (uly - h) : (uly + h);
|
|
| 358 | 438 |
|
| 359 | 439 |
Extent selectedExtent = new Extent(ulx, uly, lrx, lry); |
| 360 | 440 |
|
| ... | ... | |
| 429 | 509 |
|
| 430 | 510 |
return raster; |
| 431 | 511 |
} |
| 432 |
|
|
| 512 |
|
|
| 433 | 513 |
/** |
| 434 | 514 |
* Obtiene una ventana de datos de la imagen a partir de coordenadas reales. |
| 435 | 515 |
* Aplica supersampleo o subsampleo en funci?n del tama?o del buffer. Esta operaci?n la gestiona |
| trunk/libraries/libRaster/src/org/gvsig/raster/dataset/io/GdalDriver.java | ||
|---|---|---|
| 216 | 216 |
} |
| 217 | 217 |
|
| 218 | 218 |
/* |
| 219 |
* (non-Javadoc) |
|
| 220 |
* @see org.gvsig.raster.dataset.RasterDataset#getWindowRaster(double, double, double, double, org.gvsig.raster.dataset.BandList, org.gvsig.raster.dataset.IBuffer) |
|
| 221 |
*/ |
|
| 222 |
public IBuffer getWindowRaster(double ulx, double uly, double lrx, double lry, BandList bandList, IBuffer rasterBuf) {
|
|
| 223 |
Extent selectedExtent = new Extent(ulx, uly, lrx, lry); |
|
| 224 |
setView(selectedExtent); |
|
| 225 |
|
|
| 226 |
try {
|
|
| 227 |
file.readWindow(rasterBuf, bandList, viewRequest.getULX(), viewRequest.getULY(), viewRequest.getLRX(), viewRequest.getLRY(), rasterBuf.getWidth(), rasterBuf.getHeight(), true); |
|
| 228 |
} catch (Exception e) {
|
|
| 229 |
e.printStackTrace(); |
|
| 230 |
} |
|
| 231 |
|
|
| 232 |
return rasterBuf; |
|
| 233 |
} |
|
| 234 |
|
|
| 235 |
/* |
|
| 219 | 236 |
* (non-Javadoc) |
| 220 | 237 |
* @see org.gvsig.fmap.driver.GeoRasterFile#getWindowRaster(double, double, double, double, org.gvsig.fmap.driver.BandList, org.gvsig.fmap.driver.IBuffer) |
| 221 | 238 |
*/ |
| ... | ... | |
| 229 | 246 |
double hRaster = Math.abs(pEnd.getY() - pInit.getY()); |
| 230 | 247 |
double lrx = (((ext.getULX() - wRaster) > ext.maxX()) || ((ext.getULX() - wRaster) < ext.minX())) ? (ulx + w) : (ulx - w); |
| 231 | 248 |
double lry = (((ext.getULY() - hRaster) > ext.maxY()) || ((ext.getULY() - hRaster) < ext.minY())) ? (uly + h) : (uly - h); |
| 232 |
|
|
| 233 |
|
|
| 249 |
|
|
| 234 | 250 |
Extent selectedExtent = new Extent(ulx, uly, lrx, lry); |
| 235 | 251 |
setView(selectedExtent); |
| 236 | 252 |
|
| trunk/libraries/libRaster/src/org/gvsig/raster/dataset/io/MemoryRasterDriver.java | ||
|---|---|---|
| 239 | 239 |
if(end.getX() > buffer.getWidth()) |
| 240 | 240 |
begin.setLocation(buffer.getWidth(), begin.getY()); |
| 241 | 241 |
} |
| 242 |
|
|
| 243 |
/* |
|
| 244 |
* (non-Javadoc) |
|
| 245 |
* @see org.gvsig.raster.dataset.RasterDataset#getWindowRaster(double, double, double, double, org.gvsig.raster.dataset.BandList, org.gvsig.raster.dataset.IBuffer) |
|
| 246 |
*/ |
|
| 247 |
public IBuffer getWindowRaster(double ulx, double uly, double lrx, double lry, BandList bandList, IBuffer rasterBuf) {
|
|
| 248 |
Point2D begin = worldToRaster(new Point2D.Double(ulx, uly)); |
|
| 249 |
Point2D end = worldToRaster(new Point2D.Double(lrx, lry)); |
|
| 250 |
setView(new Extent(ulx, uly, lrx, lry)); |
|
| 251 |
|
|
| 252 |
adjustPointsToBufferLimits(begin, end); |
|
| 253 |
|
|
| 254 |
switch(buffer.getDataType()){
|
|
| 255 |
case IBuffer.TYPE_BYTE: writeByteBuffer(rasterBuf, 1, 1, begin, bandList); break; |
|
| 256 |
case IBuffer.TYPE_SHORT: writeShortBuffer(rasterBuf, 1, 1, begin, bandList); break; |
|
| 257 |
case IBuffer.TYPE_INT: writeIntBuffer(rasterBuf, 1, 1, begin, bandList); break; |
|
| 258 |
case IBuffer.TYPE_FLOAT: writeFloatBuffer(rasterBuf, 1, 1, begin, bandList); break; |
|
| 259 |
case IBuffer.TYPE_DOUBLE: writeDoubleBuffer(rasterBuf, 1, 1, begin, bandList); break; |
|
| 260 |
} |
|
| 261 |
return rasterBuf; |
|
| 262 |
} |
|
| 242 | 263 |
|
| 243 | 264 |
/* |
| 244 | 265 |
* (non-Javadoc) |
| trunk/libraries/libRaster/src/org/gvsig/raster/dataset/io/ErmapperDriver.java | ||
|---|---|---|
| 216 | 216 |
|
| 217 | 217 |
/* |
| 218 | 218 |
* (non-Javadoc) |
| 219 |
* @see org.gvsig.raster.dataset.RasterDataset#getWindowRaster(double, double, double, double, org.gvsig.raster.dataset.BandList, org.gvsig.raster.dataset.IBuffer) |
|
| 220 |
*/ |
|
| 221 |
public IBuffer getWindowRaster(double ulx, double uly, double lrx, double lry, BandList bandList, IBuffer rasterBuf) {
|
|
| 222 |
Point2D p1 = new Point2D.Double(ulx, uly); |
|
| 223 |
Point2D p2 = new Point2D.Double(lrx, lry); |
|
| 224 |
try {
|
|
| 225 |
externalTransformation.inverseTransform(p1, p1); |
|
| 226 |
externalTransformation.inverseTransform(p2, p2); |
|
| 227 |
ownTransformation.transform(p1, p1); |
|
| 228 |
ownTransformation.transform(p2, p2); |
|
| 229 |
} catch (NoninvertibleTransformException e) {
|
|
| 230 |
e.printStackTrace(); |
|
| 231 |
} |
|
| 232 |
|
|
| 233 |
Extent selectedExtent = new Extent(p1.getX(), p1.getY(), p2.getX(), p2.getY()); |
|
| 234 |
|
|
| 235 |
setView(selectedExtent); |
|
| 236 |
int wPx = rasterBuf.getWidth(); |
|
| 237 |
int hPx = rasterBuf.getHeight(); |
|
| 238 |
int[] stpBuffer = new int[]{0, 0 , wPx, hPx};
|
|
| 239 |
|
|
| 240 |
loadBuffer(viewRequest, wPx, hPx, rasterBuf, bandList, stpBuffer); |
|
| 241 |
|
|
| 242 |
return rasterBuf; |
|
| 243 |
} |
|
| 244 |
|
|
| 245 |
/* |
|
| 246 |
* (non-Javadoc) |
|
| 219 | 247 |
* @see org.gvsig.fmap.driver.RasterDataset#getWindowRaster(double, double, double, double, org.gvsig.fmap.driver.BandList, org.gvsig.fmap.driver.IBuffer, boolean) |
| 220 | 248 |
*/ |
| 221 | 249 |
public IBuffer getWindowRaster(double ulx, double uly, double w, double h, BandList bandList, IBuffer rasterBuf, boolean adjustToExtent) {
|
| trunk/libraries/libRaster/src/org/gvsig/raster/dataset/io/MrSidDriver.java | ||
|---|---|---|
| 186 | 186 |
return file.isSupersampling; |
| 187 | 187 |
} |
| 188 | 188 |
|
| 189 |
public IBuffer getWindowRaster(double ulx, double uly, double lrx, double lry, BandList bandList, IBuffer rasterBuf) {
|
|
| 190 |
//TODO: FUNCIONALIDAD: Hacer caso del bandList |
|
| 191 |
int width = rasterBuf.getWidth(); |
|
| 192 |
int height = rasterBuf.getHeight(); |
|
| 193 |
|
|
| 194 |
//Impedimos que los valores de ancho y alto de la im?gen sean menores que 1 |
|
| 195 |
if (width <= 0) |
|
| 196 |
width = 1; |
|
| 197 |
|
|
| 198 |
if (height <= 0) |
|
| 199 |
height = 1; |
|
| 200 |
|
|
| 201 |
setView(new Extent(ulx, uly, lrx, lry)); |
|
| 202 |
file.setView(viewRequest.minX(), viewRequest.maxY(), viewRequest.maxX(), viewRequest.minY(), width, height); |
|
| 203 |
|
|
| 204 |
int[] pRGBArray = new int[width * height]; |
|
| 205 |
|
|
| 206 |
try {
|
|
| 207 |
file.readScene(pRGBArray); |
|
| 208 |
int wBuf = rasterBuf.getWidth(); |
|
| 209 |
for (int row = 0; row < rasterBuf.getHeight(); row++) {
|
|
| 210 |
for(int col = 0; col < wBuf; col ++) {
|
|
| 211 |
rasterBuf.setElem(row, col, 0, (byte)((pRGBArray[(row * wBuf) + col] & 0x00ff0000) >> 16)); |
|
| 212 |
rasterBuf.setElem(row, col, 1, (byte)((pRGBArray[(row * wBuf) + col] & 0x0000ff00) >> 8)); |
|
| 213 |
rasterBuf.setElem(row, col, 2, (byte)(pRGBArray[(row * wBuf) + col] & 0x000000ff)); |
|
| 214 |
} |
|
| 215 |
} |
|
| 216 |
} catch (Exception e) {
|
|
| 217 |
e.printStackTrace(); |
|
| 218 |
} |
|
| 219 |
return rasterBuf; |
|
| 220 |
} |
|
| 221 |
|
|
| 189 | 222 |
/* |
| 190 | 223 |
* (non-Javadoc) |
| 191 | 224 |
* @see org.gvsig.raster.dataset.RasterDataset#getWindowRaster(double, double, double, double, org.gvsig.raster.dataset.BandList, org.gvsig.raster.dataset.IBuffer, boolean) |
| trunk/libraries/libRaster/src/org/gvsig/raster/grid/render/Rendering.java | ||
|---|---|---|
| 249 | 249 |
drawer.setPixelsToDrawSize(bufferFactory.getNWidth(), bufferFactory.getNHeight()); // Ancho y alto del buffer |
| 250 | 250 |
geoImage = drawer.drawBufferOverImageObject(replicateBand, getRenderBands()); // Acci?n de renderizado |
| 251 | 251 |
|
| 252 |
//En el caso de no tenga rotaci?n y el tama?o de pixel sea positivo en X y negativo en Y no aplicamos ninguna |
|
| 253 |
//transformaci?n. Esto no es necesario hacerlo, sin ello se visualiza igual. Unicamente se hace porque de esta |
|
| 254 |
//forma el raster resultante mejora un poco en calidad en ciertos niveles de zoom ya que al aplicar transformaciones |
|
| 255 |
//sobre el Graphics parece que pierde algo de calidad. |
|
| 256 |
if(transf.getScaleX() > 0 && transf.getScaleY() < 0 && transf.getShearX() == 0 && transf.getShearY() == 0) {
|
|
| 257 |
Point2D pt = new Point2D.Double(adjustedRotedRequest.getULX(), adjustedRotedRequest.getULY()); |
|
| 258 |
vp.mat.transform(pt, pt); |
|
| 259 |
g.drawImage(geoImage, (int) Math.round(pt.getX()), (int) Math.round(pt.getY()), null); |
|
| 260 |
return; |
|
| 261 |
} |
|
| 262 |
|
|
| 252 | 263 |
/* |
| 253 | 264 |
* Tenemos una matriz con la transformaci?n de la coordenadas de la vista a coordenadas reales vp.mat, adem?s tenemos |
| 254 | 265 |
* la transformaci?n de coordenadas reales a coordenadas pixel (transf). Con ambas podemos obtener una matriz de trasformacion |
| ... | ... | |
| 267 | 278 |
g.transform(at); |
| 268 | 279 |
Point2D.Double pt = null; |
| 269 | 280 |
//El punto sobre el que rota la imagen depende del signo de los tama?os del pixel |
| 270 |
/*if(transf.getScaleX() < 0 && transf.getScaleY() < 0)
|
|
| 281 |
if(transf.getScaleX() < 0 && transf.getScaleY() < 0) |
|
| 271 | 282 |
pt = new Point2D.Double(adjustedRotedRequest.maxX(), adjustedRotedRequest.maxY()); |
| 272 | 283 |
else if(transf.getScaleX() > 0 && transf.getScaleY() > 0) |
| 273 | 284 |
pt = new Point2D.Double(adjustedRotedRequest.minX(), adjustedRotedRequest.minY()); |
| 274 | 285 |
else if(transf.getScaleX() < 0 && transf.getScaleY() > 0) |
| 275 | 286 |
pt = new Point2D.Double(adjustedRotedRequest.maxX(), adjustedRotedRequest.minY()); |
| 276 |
else*/
|
|
| 287 |
else |
|
| 277 | 288 |
pt = new Point2D.Double(adjustedRotedRequest.getULX(), adjustedRotedRequest.getULY()); |
| 278 | 289 |
vp.getMat().transform(pt, pt); |
| 279 | 290 |
at.inverseTransform(pt, pt); |
| ... | ... | |
| 283 | 294 |
e.printStackTrace(); |
| 284 | 295 |
} |
| 285 | 296 |
|
| 286 |
/*Point2D pt = new Point2D.Double(adjustedRotedRequest.minX(), adjustedRotedRequest.maxY()); |
|
| 287 |
vp.mat.transform(pt, pt); |
|
| 288 |
g.drawImage(geoImage, (int) Math.round(pt.getX()), (int) Math.round(pt.getY()), null);*/ |
|
| 289 | 297 |
// long t2 = new Date().getTime(); |
| 290 | 298 |
// System.out.println("Renderizando Raster: " + ((t2 - t1) / 1000D) + ", secs.");
|
| 291 | 299 |
} |
| ... | ... | |
| 338 | 346 |
//Ajustamos la petici?n a los limites del raster, teniendo en cuenta la rotaci?n de este. |
| 339 | 347 |
return new Extent(ulWC, lrWC); |
| 340 | 348 |
} |
| 341 |
Extent adjustedRotExtent = RasterUtilities.calculateAdjustedView(vp.getExtent(), dataset.getAffineTransform(), new Dimension((int)dataset.getWidth()[0], (int)dataset.getHeight()[0])); |
|
| 342 |
widthImage = (int)Math.abs(adjustedRotExtent.width() * vp.getMat().getScaleX()); |
|
| 343 |
heightImage = (int)Math.abs(adjustedRotExtent.height() * vp.getMat().getScaleY()); |
|
| 344 |
Point2D ul = new Point2D.Double(adjustedRotExtent.getULX(), adjustedRotExtent.getULY());
|
|
| 345 |
Point2D lr = new Point2D.Double(adjustedRotExtent.getLRX(), adjustedRotExtent.getLRY());
|
|
| 349 |
Extent adjustedRotedExtent = RasterUtilities.calculateAdjustedView(vp.getExtent(), dataset.getAffineTransform(), new Dimension((int)dataset.getWidth()[0], (int)dataset.getHeight()[0]));
|
|
| 350 |
widthImage = (int)Math.abs(adjustedRotedExtent.width() * vp.getMat().getScaleX());
|
|
| 351 |
heightImage = (int)Math.abs(adjustedRotedExtent.height() * vp.getMat().getScaleY());
|
|
| 352 |
Point2D ul = new Point2D.Double(adjustedRotedExtent.getULX(), adjustedRotedExtent.getULY());
|
|
| 353 |
Point2D lr = new Point2D.Double(adjustedRotedExtent.getLRX(), adjustedRotedExtent.getLRY());
|
|
| 346 | 354 |
ul = dataset.worldToRaster(ul); |
| 347 | 355 |
lr = dataset.worldToRaster(lr); |
| 348 | 356 |
ulPxRequest = new Point2D.Double(ul.getX(), ul.getY()); |
| 349 | 357 |
lrPxRequest = new Point2D.Double(lr.getX(), lr.getY()); |
| 350 |
return adjustedRotExtent; |
|
| 358 |
return adjustedRotedExtent;
|
|
| 351 | 359 |
} |
| 352 |
|
|
| 353 |
/** |
|
| 354 |
* Ajusta la extensi?n pasada por par?metro y que corresponde al extent de la |
|
| 355 |
* vista donde se va a dibujar a los valores m?ximos y m?nimos de la imagen. |
|
| 356 |
* Esto sirve para que la petici?n al driver nunca sobrepase los l?mites de la |
|
| 357 |
* imagen tratada aunque la vista donde se dibuje sea de mayor tama?o. Antes |
|
| 358 |
* de realizar este ajuste hay que transformar la petici?n que puede |
|
| 359 |
* corresponder a una imagen rotada a las coordenadas de la imagen sin rotar |
|
| 360 |
* ya que las peticiones al driver hay que hacerlas con estas coordenadas. |
|
| 361 |
* Para esto trasladamos la petici?n al origen de la imagen (esquina superior |
|
| 362 |
* izquierda), aplicamos la transformaci?n inversa a las cuatro esquinas |
|
| 363 |
* obtenidas y volvemos a trasladar a su posici?n original. Se usa la |
|
| 364 |
* transformaci?n inversa para trasladar un punto del raster rotado al mismo |
|
| 365 |
* sin rotar y la transformaci?n af?n normal para trasladar un punto sin rotar |
|
| 366 |
* a uno rotado. |
|
| 367 |
* |
|
| 368 |
* @param ViewPortData |
|
| 369 |
* @param MultiRasterDataset |
|
| 370 |
*/ |
|
| 371 |
/*protected Extent calculateNewView(ViewPortData vp, MultiRasterDataset dataset) {
|
|
| 372 |
Extent sz = vp.getExtent(); |
|
| 373 |
double vx = sz.minX(); |
|
| 374 |
double vy = sz.minY(); |
|
| 375 |
double vx2 = sz.maxX(); |
|
| 376 |
double vy2 = sz.maxY(); |
|
| 377 |
|
|
| 378 |
// Trasladamos la petici?n si est? rotada a su posici?n sin rotar |
|
| 379 |
|
|
| 380 |
if (dataset.isRotated()) {
|
|
| 381 |
AffineTransform transf = bufferFactory.getCoordsGeoTransformFile(); |
|
| 382 |
|
|
| 383 |
// La transformaci?n se hace en base a una esquina que varia con el signo del pixel size. |
|
| 384 |
double ptoDesplX = (transf.getScaleX() > 0) ? requestExtent.minX() : requestExtent.maxX(); |
|
| 385 |
double ptoDesplY = (transf.getScaleY() < 0) ? requestExtent.maxY() : requestExtent.minY(); |
|
| 386 |
|
|
| 387 |
Point2D ul = new Point2D.Double(vx - ptoDesplX, vy2 - ptoDesplY); |
|
| 388 |
Point2D ur = new Point2D.Double(vx2 - ptoDesplX, vy2 - ptoDesplY); |
|
| 389 |
Point2D ll = new Point2D.Double(vx - ptoDesplX, vy - ptoDesplY); |
|
| 390 |
Point2D lr = new Point2D.Double(vx2 - ptoDesplX, vy - ptoDesplY); |
|
| 391 |
|
|
| 392 |
double shearX = 0; |
|
| 393 |
double shearY = 0; |
|
| 394 |
if (transf.getScaleY() != 0) |
|
| 395 |
shearX = transf.getShearX() / transf.getScaleY(); |
|
| 396 |
else |
|
| 397 |
shearX = transf.getShearX(); |
|
| 398 |
if (transf.getScaleX() != 0) |
|
| 399 |
shearY = transf.getShearY() / transf.getScaleX(); |
|
| 400 |
else |
|
| 401 |
shearY = transf.getShearX(); |
|
| 402 |
|
|
| 403 |
AffineTransform at = new AffineTransform(); |
|
| 404 |
at.setToShear(shearX, shearY); |
|
| 405 |
|
|
| 406 |
try {
|
|
| 407 |
at.inverseTransform(ul, ul); |
|
| 408 |
at.inverseTransform(ur, ur); |
|
| 409 |
at.inverseTransform(ll, ll); |
|
| 410 |
at.inverseTransform(lr, lr); |
|
| 411 |
} catch (NoninvertibleTransformException e) {
|
|
| 412 |
e.printStackTrace(); |
|
| 413 |
} |
|
| 414 |
|
|
| 415 |
ul = new Point2D.Double(ul.getX() + ptoDesplX, ul.getY() + ptoDesplY); |
|
| 416 |
ur = new Point2D.Double(ur.getX() + ptoDesplX, ur.getY() + ptoDesplY); |
|
| 417 |
ll = new Point2D.Double(ll.getX() + ptoDesplX, ll.getY() + ptoDesplY); |
|
| 418 |
lr = new Point2D.Double(lr.getX() + ptoDesplX, lr.getY() + ptoDesplY); |
|
| 419 |
|
|
| 420 |
vx2 = Math.max(Math.max(ul.getX(), ur.getX()), Math.max(ll.getX(), lr.getX())); |
|
| 421 |
vy2 = Math.max(Math.max(ul.getY(), ur.getY()), Math.max(ll.getY(), lr.getY())); |
|
| 422 |
vx = Math.min(Math.min(ul.getX(), ur.getX()), Math.min(ll.getX(), lr.getX())); |
|
| 423 |
vy = Math.min(Math.min(ul.getY(), ur.getY()), Math.min(ll.getY(), lr.getY())); |
|
| 424 |
} |
|
| 425 |
|
|
| 426 |
if (vx < requestExtent.minX()) |
|
| 427 |
vx = requestExtent.minX(); |
|
| 428 |
|
|
| 429 |
if (vy < requestExtent.minY()) |
|
| 430 |
vy = requestExtent.minY(); |
|
| 431 |
|
|
| 432 |
if (vx2 > requestExtent.maxX()) |
|
| 433 |
vx2 = requestExtent.maxX(); |
|
| 434 |
|
|
| 435 |
if (vy2 > requestExtent.maxY()) |
|
| 436 |
vy2 = requestExtent.maxY(); |
|
| 437 |
|
|
| 438 |
return new Extent( vx, vy, vx2, vy2); |
|
| 439 |
}*/ |
|
| 440 | 360 |
|
| 441 | 361 |
/** |
| 442 | 362 |
* Obtiene el n?mero de bandas y el orden de renderizado. Cada posici?n del |
| trunk/libraries/libRaster/src/org/gvsig/raster/buffer/BufferFactory.java | ||
|---|---|---|
| 310 | 310 |
|
| 311 | 311 |
if(bufWidth > Math.ceil(nWidth) && bufHeight > Math.ceil(nHeight)) {
|
| 312 | 312 |
try {
|
| 313 |
rasterBuf = mDataset.getWindowRaster(adjustedDataExtent.getULX(), adjustedDataExtent.getULY(), adjustedDataExtent.width(), adjustedDataExtent.height(), adjustToExtent);
|
|
| 313 |
rasterBuf = mDataset.getWindowRaster(adjustedDataExtent.getULX(), adjustedDataExtent.getULY(), adjustedDataExtent.getLRX(), adjustedDataExtent.getLRY());
|
|
| 314 | 314 |
} catch (InvalidSetViewException e) {
|
| 315 | 315 |
//Esta excepci?n no debe darse ya que se hace un calculateAdjustedView antes de la llamada. |
| 316 | 316 |
} |
| trunk/libraries/libRaster/doc/Notas.txt | ||
|---|---|---|
| 1 |
Orientaci?n de un raster en la vista |
|
| 1 |
Probar tests y Eliminar setAreaOfIntererest con el ancho |
|
| 2 |
Probar loadfRMF para la georreferenciaci?n en los 3 drivers |
|
| 2 | 3 |
Rotaci?n para el driver de memoria |
| 3 |
Meter rotaci?n al recorte |
|
| 4 |
Meter rotaci?n a la georreferenciaci?n del recorte
|
|
| 4 | 5 |
Lectura de georreferenciaci?n desde RMF con rotaci?n |
| 5 | 6 |
Las bandas deber?an llevar asociada siempre la interpretaci?n de color. En el caso de tener un raster con |
| 6 | 7 |
una tabla de color, si le metemos un realce peta porque tiene banda Alpha. Este tipo de bandas no deber?a |
Also available in: Unified diff