svn-gvsig-desktop / tags / v1_1_1_Build_1022 / libraries / libCq CMS for java.old / src-dvp / Tiling.java @ 43233
History | View | Annotate | Download (10.5 KB)
| 1 |
/*
|
|---|---|
| 2 |
* Created on 16-feb-2005
|
| 3 |
*/
|
| 4 |
package com.iver.cit.gvsig.fmap.layers; |
| 5 |
|
| 6 |
import java.awt.Dimension; |
| 7 |
import java.awt.Rectangle; |
| 8 |
import java.awt.geom.AffineTransform; |
| 9 |
import java.awt.geom.NoninvertibleTransformException; |
| 10 |
import java.awt.geom.Rectangle2D; |
| 11 |
|
| 12 |
import org.cresques.px.Extent; |
| 13 |
|
| 14 |
import com.iver.cit.gvsig.fmap.ViewPort; |
| 15 |
|
| 16 |
/**
|
| 17 |
* C?lculo de Partes (Tiles) en las que se divide un raster grande.
|
| 18 |
* Se usa para imprimir rasters y capas raste remotas (WMS).
|
| 19 |
*
|
| 20 |
* Para no pedir imagenes demasiado grandes, vamos
|
| 21 |
* a hacer lo mismo que hace EcwFile: chunkear.
|
| 22 |
* Llamamos a drawView con cuadraditos m?s peque?os
|
| 23 |
* del BufferedImage ni caso, cuando se imprime viene con null
|
| 24 |
* c?digo original de Fran Pe?arrubia
|
| 25 |
* @author Luis W. Sevilla (sevilla_lui@gva.es)
|
| 26 |
*/
|
| 27 |
|
| 28 |
public class Tiling { |
| 29 |
private final static int BORDER_PX = 20; |
| 30 |
boolean debug = true; |
| 31 |
int tileMaxWidth, tileMaxHeight;
|
| 32 |
int numRows, numCols;
|
| 33 |
double [][] srcPts; |
| 34 |
Rectangle [] tile; |
| 35 |
Rectangle [] clip; |
| 36 |
double width = 500, height = 500; |
| 37 |
|
| 38 |
AffineTransform mat;
|
| 39 |
ViewPort vp; |
| 40 |
|
| 41 |
public Tiling(int tileW, int tileH, Rectangle r) { |
| 42 |
tileMaxWidth = tileW; |
| 43 |
tileMaxHeight = tileH; |
| 44 |
|
| 45 |
int stepX, stepY;
|
| 46 |
int xProv, yProv;
|
| 47 |
int altoAux, anchoAux;
|
| 48 |
|
| 49 |
// Vamos a hacerlo en trozos de AxH
|
| 50 |
numCols = 1+(int) (r.width) / tileMaxWidth; |
| 51 |
numRows = 1+(int) (r.height) / tileMaxHeight; |
| 52 |
|
| 53 |
srcPts = new double[numCols*numRows][8]; |
| 54 |
tile = new Rectangle[numCols*numRows]; |
| 55 |
clip = new Rectangle[numCols*numRows]; |
| 56 |
|
| 57 |
yProv = (int) r.y;
|
| 58 |
for (stepY=0; stepY < numRows; stepY++) { |
| 59 |
if ((yProv + tileMaxHeight) > r.getMaxY())
|
| 60 |
altoAux = (int) r.getMaxY() - yProv;
|
| 61 |
else
|
| 62 |
altoAux = tileMaxHeight; |
| 63 |
|
| 64 |
xProv = (int) r.x;
|
| 65 |
for (stepX=0; stepX < numCols; stepX++) { |
| 66 |
if ((xProv + tileMaxWidth) > r.getMaxX())
|
| 67 |
anchoAux = (int) r.getMaxX() - xProv;
|
| 68 |
else
|
| 69 |
anchoAux = tileMaxWidth; |
| 70 |
|
| 71 |
int tileCnt = stepY * numCols + stepX;
|
| 72 |
|
| 73 |
//Esquina superior izquierda
|
| 74 |
if(stepX == 0) |
| 75 |
srcPts[tileCnt][0] = xProv;
|
| 76 |
else
|
| 77 |
srcPts[tileCnt][0] = xProv - BORDER_PX;
|
| 78 |
if(stepY == 0) |
| 79 |
srcPts[tileCnt][1] = yProv;
|
| 80 |
else
|
| 81 |
srcPts[tileCnt][1] = yProv - BORDER_PX;
|
| 82 |
|
| 83 |
//Esquina superior derecha
|
| 84 |
if(stepX == (numCols - 1)) |
| 85 |
srcPts[tileCnt][2] = xProv + anchoAux;
|
| 86 |
else
|
| 87 |
srcPts[tileCnt][2] = xProv + anchoAux + BORDER_PX;
|
| 88 |
if(stepY == 0) |
| 89 |
srcPts[tileCnt][3] = yProv;
|
| 90 |
else
|
| 91 |
srcPts[tileCnt][3] = yProv - BORDER_PX;
|
| 92 |
|
| 93 |
//Esquina inferior derecha
|
| 94 |
if(stepX == (numCols - 1)) |
| 95 |
srcPts[tileCnt][4] = xProv + anchoAux;
|
| 96 |
else
|
| 97 |
srcPts[tileCnt][4] = xProv + anchoAux + BORDER_PX;
|
| 98 |
if(stepY == (numRows -1)) |
| 99 |
srcPts[tileCnt][5] = yProv + altoAux;
|
| 100 |
else
|
| 101 |
srcPts[tileCnt][5] = yProv + altoAux + BORDER_PX;
|
| 102 |
|
| 103 |
//Esquina inferior izquierda
|
| 104 |
if(stepX == 0) |
| 105 |
srcPts[tileCnt][6] = xProv;
|
| 106 |
else
|
| 107 |
srcPts[tileCnt][6] = xProv - BORDER_PX;
|
| 108 |
if(stepY == (numRows -1)) |
| 109 |
srcPts[tileCnt][7] = yProv + altoAux;
|
| 110 |
else
|
| 111 |
srcPts[tileCnt][7] = yProv + altoAux + BORDER_PX;
|
| 112 |
|
| 113 |
//Calculo del ancho y alto del nuevo rectangulo
|
| 114 |
int w = 0, h = 0; |
| 115 |
if(numCols == 1) |
| 116 |
w = anchoAux; |
| 117 |
if(numRows == 1) |
| 118 |
h = altoAux; |
| 119 |
|
| 120 |
if(w == 0){ |
| 121 |
if(stepX == 0 || stepX == (numCols - 1)) |
| 122 |
w = anchoAux + BORDER_PX; |
| 123 |
else
|
| 124 |
w = anchoAux + (BORDER_PX * 2);
|
| 125 |
} |
| 126 |
if(h == 0){ |
| 127 |
if(stepY == 0 || stepY == (numRows - 1)) |
| 128 |
h = altoAux + BORDER_PX; |
| 129 |
else
|
| 130 |
h = altoAux + (BORDER_PX * 2);
|
| 131 |
} |
| 132 |
tile[tileCnt] = new Rectangle(xProv, yProv, w, h); |
| 133 |
clip[tileCnt] = new Rectangle(xProv, yProv, anchoAux, altoAux); |
| 134 |
|
| 135 |
//Calculo de la nueva posici?n de inicio en X
|
| 136 |
xProv += tileMaxWidth; |
| 137 |
} |
| 138 |
//Calculo de la nueva posici?n de inicio en Y
|
| 139 |
yProv += tileMaxHeight; |
| 140 |
} |
| 141 |
} |
| 142 |
|
| 143 |
/*public Tiling(int tileW, int tileH, Rectangle r) {
|
| 144 |
tileMaxWidth = tileW;
|
| 145 |
tileMaxHeight = tileH;
|
| 146 |
|
| 147 |
int stepX, stepY;
|
| 148 |
int xProv, yProv;
|
| 149 |
int altoAux, anchoAux;
|
| 150 |
|
| 151 |
// Vamos a hacerlo en trozos de AxH
|
| 152 |
numCols = 1+(int) (r.width) / tileMaxWidth;
|
| 153 |
numRows = 1+(int) (r.height) / tileMaxHeight;
|
| 154 |
|
| 155 |
srcPts = new double[numCols*numRows][8];
|
| 156 |
tile = new Rectangle[numCols*numRows];
|
| 157 |
|
| 158 |
yProv = (int) r.y;
|
| 159 |
for (stepY=0; stepY < numRows; stepY++) {
|
| 160 |
if ((yProv + tileMaxHeight) > r.getMaxY())
|
| 161 |
altoAux = (int) r.getMaxY() - yProv;
|
| 162 |
else
|
| 163 |
altoAux = tileMaxHeight;
|
| 164 |
|
| 165 |
xProv = (int) r.x;
|
| 166 |
for (stepX=0; stepX < numCols; stepX++) {
|
| 167 |
if ((xProv + tileMaxWidth) > r.getMaxX())
|
| 168 |
anchoAux = (int) r.getMaxX() - xProv;
|
| 169 |
else
|
| 170 |
anchoAux = tileMaxWidth;
|
| 171 |
|
| 172 |
Rectangle newRect = new Rectangle(xProv, yProv, anchoAux, altoAux);
|
| 173 |
int tileCnt = stepY*numCols+stepX;
|
| 174 |
// Parte que dibuja
|
| 175 |
srcPts[tileCnt][0] = xProv;
|
| 176 |
srcPts[tileCnt][1] = yProv;
|
| 177 |
srcPts[tileCnt][2] = xProv + anchoAux+1;
|
| 178 |
srcPts[tileCnt][3] = yProv;
|
| 179 |
srcPts[tileCnt][4] = xProv + anchoAux+1;
|
| 180 |
srcPts[tileCnt][5] = yProv + altoAux+1;
|
| 181 |
srcPts[tileCnt][6] = xProv;
|
| 182 |
srcPts[tileCnt][7] = yProv + altoAux+1;
|
| 183 |
|
| 184 |
tile[tileCnt] = new Rectangle(xProv, yProv, anchoAux+1, altoAux+1);
|
| 185 |
|
| 186 |
xProv = xProv + tileMaxWidth;
|
| 187 |
}
|
| 188 |
yProv = yProv + tileMaxHeight;
|
| 189 |
}
|
| 190 |
}*/
|
| 191 |
|
| 192 |
public double [] getTilePts(int colNr, int rowNr) { |
| 193 |
return srcPts[rowNr*numCols+colNr];
|
| 194 |
} |
| 195 |
|
| 196 |
public double [] getTilePts(int num) { |
| 197 |
return srcPts[num];
|
| 198 |
} |
| 199 |
|
| 200 |
public Rectangle getClip(int i){ |
| 201 |
return clip[i];
|
| 202 |
} |
| 203 |
|
| 204 |
public Rectangle getTileSz(int colNr, int rowNr) { |
| 205 |
return tile[rowNr*numCols+colNr];
|
| 206 |
} |
| 207 |
|
| 208 |
public Rectangle getTile(int num) { |
| 209 |
return tile[num];
|
| 210 |
} |
| 211 |
|
| 212 |
/**
|
| 213 |
* @return Returns the numCols.
|
| 214 |
*/
|
| 215 |
public int getNumCols() { |
| 216 |
return numCols;
|
| 217 |
} |
| 218 |
/**
|
| 219 |
* @return Returns the numRows.
|
| 220 |
*/
|
| 221 |
public int getNumRows() { |
| 222 |
return numRows;
|
| 223 |
} |
| 224 |
|
| 225 |
public int getNumTiles() { return numRows*numCols; } |
| 226 |
/**
|
| 227 |
* @return Returns the tileHeight.
|
| 228 |
*/
|
| 229 |
public int getMaxTileHeight() { |
| 230 |
return tileMaxHeight;
|
| 231 |
} |
| 232 |
/**
|
| 233 |
* @return Returns the tileWidth.
|
| 234 |
*/
|
| 235 |
public int getMaxTileWidth() { |
| 236 |
return tileMaxWidth;
|
| 237 |
} |
| 238 |
|
| 239 |
ViewPort[] viewPortList = null; |
| 240 |
private void calcViewPort(ViewPort viewPort)throws NoninvertibleTransformException{ |
| 241 |
viewPortList = new ViewPort[numCols*numRows];
|
| 242 |
|
| 243 |
if(viewPort.getImageWidth() < width && viewPort.getImageHeight() < height){
|
| 244 |
viewPortList[0] = viewPort;
|
| 245 |
return;
|
| 246 |
} |
| 247 |
|
| 248 |
int vpCnt = 0; |
| 249 |
|
| 250 |
double imgPxX = viewPort.getImageWidth();
|
| 251 |
double dWcX = viewPort.getAdjustedExtent().getWidth();
|
| 252 |
double tileWcW = (getTile(vpCnt).getSize().getWidth() * dWcX) / imgPxX;
|
| 253 |
|
| 254 |
double imgPxY = viewPort.getImageHeight();
|
| 255 |
double dWcY = viewPort.getAdjustedExtent().getHeight();
|
| 256 |
double tileWcH = (getTile(vpCnt).getSize().getHeight() * dWcY) / imgPxY;
|
| 257 |
|
| 258 |
viewPortList[0] = viewPort.cloneViewPort();
|
| 259 |
viewPortList[0].setImageSize(getTile(vpCnt).getSize());
|
| 260 |
viewPortList[0].setExtent(new Rectangle2D.Double(viewPort.getAdjustedExtent().getMinX(), viewPort.getAdjustedExtent().getMaxY() - tileWcH, tileWcW, tileWcH)); |
| 261 |
viewPortList[0].setAffineTransform(mat);
|
| 262 |
|
| 263 |
double wt = tileWcW;
|
| 264 |
double ht = tileWcH;
|
| 265 |
double xt = viewPort.getAdjustedExtent().getMinX();
|
| 266 |
double yt = viewPort.getAdjustedExtent().getMaxY() - tileWcH;
|
| 267 |
|
| 268 |
for (int stepY=0; stepY < numRows; stepY++) { |
| 269 |
wt = tileWcW; |
| 270 |
xt = viewPort.getAdjustedExtent().getMinX(); |
| 271 |
for (int stepX=0; stepX < numCols; stepX++) { |
| 272 |
vpCnt = stepY*numCols+stepX; |
| 273 |
if(vpCnt > 0){ |
| 274 |
if(stepX > 0) |
| 275 |
xt += wt; |
| 276 |
if((xt + wt) > viewPort.getAdjustedExtent().getMaxX())
|
| 277 |
wt = Math.abs(viewPort.getAdjustedExtent().getMaxX() - xt);
|
| 278 |
|
| 279 |
viewPortList[vpCnt] = viewPort.cloneViewPort(); |
| 280 |
viewPortList[vpCnt].setImageSize(getTile(vpCnt).getSize()); |
| 281 |
viewPortList[vpCnt].setExtent(new Rectangle2D.Double(xt, yt, wt, ht)); |
| 282 |
viewPortList[vpCnt].setAffineTransform(mat); |
| 283 |
|
| 284 |
} |
| 285 |
//System.out.println("ViewPort: "+vpCnt+" "+viewPortList[vpCnt].getAdjustedExtent()+" "+getTile(vpCnt).getSize());
|
| 286 |
} |
| 287 |
if((yt - ht) < viewPort.getAdjustedExtent().getMinY()){
|
| 288 |
ht = Math.abs(yt - viewPort.getAdjustedExtent().getMinY());
|
| 289 |
yt = viewPort.getAdjustedExtent().getMinY(); |
| 290 |
}else
|
| 291 |
yt -= ht; |
| 292 |
} |
| 293 |
} |
| 294 |
|
| 295 |
public ViewPort getTileViewPort(ViewPort viewPort, int tileNr) throws NoninvertibleTransformException { |
| 296 |
/*if(viewPortList == null)
|
| 297 |
this.calcViewPort(viewPort);
|
| 298 |
return viewPortList[tileNr];*/
|
| 299 |
|
| 300 |
if(tile.length == 1) |
| 301 |
return viewPort;
|
| 302 |
|
| 303 |
double [] dstPts = new double[8]; |
| 304 |
double [] srcPts = getTilePts(tileNr); |
| 305 |
Rectangle tile = getTile(tileNr);
|
| 306 |
//Rectangle newRect = new Rectangle((int)srcPts[0], (int)srcPts[1], tileSz[0], tileSz[1]);
|
| 307 |
|
| 308 |
mat.inverseTransform(srcPts, 0, dstPts, 0, 4); |
| 309 |
double x = dstPts[0], w = dstPts[2] - dstPts[0]; |
| 310 |
double y = dstPts[1], h = dstPts[5] - dstPts[3]; |
| 311 |
if (w < 0) { x = dstPts[2]; w = dstPts[0] - dstPts[2]; } |
| 312 |
if (h < 0) { y = dstPts[5]; h = dstPts[3] - dstPts[5]; } |
| 313 |
Rectangle2D.Double rectCuadricula = new Rectangle2D.Double(x, y, w, h); |
| 314 |
//Extent extent = new Extent(rectCuadricula);
|
| 315 |
|
| 316 |
ViewPort vp = viewPort.cloneViewPort(); |
| 317 |
vp.setImageSize(tile.getSize()); |
| 318 |
//vp.setOffset(tile.getLocation());
|
| 319 |
vp.setExtent(rectCuadricula); |
| 320 |
vp.setAffineTransform(mat); |
| 321 |
|
| 322 |
if (debug)
|
| 323 |
System.out.println("Tiling.print(): tile "+tileNr+" de " |
| 324 |
+ getNumTiles() + |
| 325 |
"\n, Extent = "+vp.getAdjustedExtent() + " tile: " |
| 326 |
+ tile); |
| 327 |
|
| 328 |
return vp;
|
| 329 |
} |
| 330 |
/**
|
| 331 |
* @return Returns the mat.
|
| 332 |
*/
|
| 333 |
public AffineTransform getAffineTransform() { |
| 334 |
return mat;
|
| 335 |
} |
| 336 |
/**
|
| 337 |
* @param mat The mat to set.
|
| 338 |
*/
|
| 339 |
public void setAffineTransform(AffineTransform mat) { |
| 340 |
this.mat = mat;
|
| 341 |
} |
| 342 |
/**
|
| 343 |
* @return Returns the debug.
|
| 344 |
*/
|
| 345 |
public boolean isDebug() { |
| 346 |
return debug;
|
| 347 |
} |
| 348 |
/**
|
| 349 |
* @param debug The debug to set.
|
| 350 |
*/
|
| 351 |
public void setDebug(boolean debug) { |
| 352 |
this.debug = debug;
|
| 353 |
} |
| 354 |
} |
| 355 |
|
| 356 |
|