svn-gvsig-desktop / tags / Root_v061 / libraries / libFMap / src / com / iver / cit / gvsig / fmap / layers / Tiling.java @ 4812
History | View | Annotate | Download (7.08 KB)
1 | 1488 | luisw | /*
|
---|---|---|---|
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 | boolean debug = true; |
||
30 | int tileMaxWidth, tileMaxHeight;
|
||
31 | int numRows, numCols;
|
||
32 | double [][] srcPts; |
||
33 | 1501 | luisw | Rectangle [] tile; |
34 | 3953 | nacho | double width = 500, height = 500; |
35 | 1488 | luisw | |
36 | AffineTransform mat;
|
||
37 | ViewPort vp; |
||
38 | |||
39 | public Tiling(int tileW, int tileH, Rectangle r) { |
||
40 | tileMaxWidth = tileW; |
||
41 | tileMaxHeight = tileH; |
||
42 | |||
43 | int stepX, stepY;
|
||
44 | 3953 | nacho | int xProv, yProv;
|
45 | 1488 | luisw | int altoAux, anchoAux;
|
46 | |||
47 | // Vamos a hacerlo en trozos de AxH
|
||
48 | numCols = 1+(int) (r.width) / tileMaxWidth; |
||
49 | numRows = 1+(int) (r.height) / tileMaxHeight; |
||
50 | |||
51 | srcPts = new double[numCols*numRows][8]; |
||
52 | 1501 | luisw | tile = new Rectangle[numCols*numRows]; |
53 | 1488 | luisw | |
54 | yProv = (int) r.y;
|
||
55 | for (stepY=0; stepY < numRows; stepY++) { |
||
56 | if ((yProv + tileMaxHeight) > r.getMaxY())
|
||
57 | altoAux = (int) r.getMaxY() - yProv;
|
||
58 | else
|
||
59 | altoAux = tileMaxHeight; |
||
60 | |||
61 | xProv = (int) r.x;
|
||
62 | for (stepX=0; stepX < numCols; stepX++) { |
||
63 | if ((xProv + tileMaxWidth) > r.getMaxX())
|
||
64 | anchoAux = (int) r.getMaxX() - xProv;
|
||
65 | else
|
||
66 | anchoAux = tileMaxWidth; |
||
67 | |||
68 | Rectangle newRect = new Rectangle(xProv, yProv, anchoAux, altoAux); |
||
69 | int tileCnt = stepY*numCols+stepX;
|
||
70 | // Parte que dibuja
|
||
71 | srcPts[tileCnt][0] = xProv;
|
||
72 | srcPts[tileCnt][1] = yProv;
|
||
73 | srcPts[tileCnt][2] = xProv + anchoAux+1; |
||
74 | srcPts[tileCnt][3] = yProv;
|
||
75 | srcPts[tileCnt][4] = xProv + anchoAux+1; |
||
76 | srcPts[tileCnt][5] = yProv + altoAux+1; |
||
77 | srcPts[tileCnt][6] = xProv;
|
||
78 | srcPts[tileCnt][7] = yProv + altoAux+1; |
||
79 | |||
80 | 1501 | luisw | tile[tileCnt] = new Rectangle(xProv, yProv, anchoAux+1, altoAux+1); |
81 | 1488 | luisw | |
82 | xProv = xProv + tileMaxWidth; |
||
83 | } |
||
84 | yProv = yProv + tileMaxHeight; |
||
85 | } |
||
86 | } |
||
87 | |||
88 | public double [] getTilePts(int colNr, int rowNr) { |
||
89 | return srcPts[rowNr*numCols+colNr];
|
||
90 | } |
||
91 | |||
92 | public double [] getTilePts(int num) { |
||
93 | return srcPts[num];
|
||
94 | } |
||
95 | |||
96 | 1501 | luisw | public Rectangle getTileSz(int colNr, int rowNr) { |
97 | return tile[rowNr*numCols+colNr];
|
||
98 | 1488 | luisw | } |
99 | |||
100 | 1501 | luisw | public Rectangle getTile(int num) { |
101 | return tile[num];
|
||
102 | 1488 | luisw | } |
103 | |||
104 | /**
|
||
105 | * @return Returns the numCols.
|
||
106 | */
|
||
107 | public int getNumCols() { |
||
108 | return numCols;
|
||
109 | } |
||
110 | /**
|
||
111 | * @return Returns the numRows.
|
||
112 | */
|
||
113 | public int getNumRows() { |
||
114 | return numRows;
|
||
115 | } |
||
116 | |||
117 | public int getNumTiles() { return numRows*numCols; } |
||
118 | /**
|
||
119 | * @return Returns the tileHeight.
|
||
120 | */
|
||
121 | public int getMaxTileHeight() { |
||
122 | return tileMaxHeight;
|
||
123 | } |
||
124 | /**
|
||
125 | * @return Returns the tileWidth.
|
||
126 | */
|
||
127 | public int getMaxTileWidth() { |
||
128 | return tileMaxWidth;
|
||
129 | } |
||
130 | |||
131 | 3953 | nacho | ViewPort[] viewPortList = null; |
132 | private void calcViewPort(ViewPort viewPort)throws NoninvertibleTransformException{ |
||
133 | viewPortList = new ViewPort[numCols*numRows];
|
||
134 | |||
135 | if(viewPort.getImageWidth() < width && viewPort.getImageHeight() < height){
|
||
136 | viewPortList[0] = viewPort;
|
||
137 | return;
|
||
138 | } |
||
139 | |||
140 | int vpCnt = 0; |
||
141 | |||
142 | double imgPxX = viewPort.getImageWidth();
|
||
143 | double dWcX = viewPort.getAdjustedExtent().getWidth();
|
||
144 | double tileWcW = (getTile(vpCnt).getSize().getWidth() * dWcX) / imgPxX;
|
||
145 | |||
146 | double imgPxY = viewPort.getImageHeight();
|
||
147 | double dWcY = viewPort.getAdjustedExtent().getHeight();
|
||
148 | double tileWcH = (getTile(vpCnt).getSize().getHeight() * dWcY) / imgPxY;
|
||
149 | |||
150 | viewPortList[0] = viewPort.cloneViewPort();
|
||
151 | viewPortList[0].setImageSize(getTile(vpCnt).getSize());
|
||
152 | viewPortList[0].setExtent(new Rectangle2D.Double(viewPort.getAdjustedExtent().getMinX(), viewPort.getAdjustedExtent().getMaxY() - tileWcH, tileWcW, tileWcH)); |
||
153 | viewPortList[0].setAffineTransform(mat);
|
||
154 | |||
155 | double wt = tileWcW;
|
||
156 | double ht = tileWcH;
|
||
157 | double xt = viewPort.getAdjustedExtent().getMinX();
|
||
158 | double yt = viewPort.getAdjustedExtent().getMaxY() - tileWcH;
|
||
159 | |||
160 | for (int stepY=0; stepY < numRows; stepY++) { |
||
161 | wt = tileWcW; |
||
162 | xt = viewPort.getAdjustedExtent().getMinX(); |
||
163 | for (int stepX=0; stepX < numCols; stepX++) { |
||
164 | vpCnt = stepY*numCols+stepX; |
||
165 | if(vpCnt > 0){ |
||
166 | if(stepX > 0) |
||
167 | xt += wt; |
||
168 | if((xt + wt) > viewPort.getAdjustedExtent().getMaxX())
|
||
169 | wt = Math.abs(viewPort.getAdjustedExtent().getMaxX() - xt);
|
||
170 | |||
171 | viewPortList[vpCnt] = viewPort.cloneViewPort(); |
||
172 | viewPortList[vpCnt].setImageSize(getTile(vpCnt).getSize()); |
||
173 | viewPortList[vpCnt].setExtent(new Rectangle2D.Double(xt, yt, wt, ht)); |
||
174 | viewPortList[vpCnt].setAffineTransform(mat); |
||
175 | |||
176 | } |
||
177 | //System.out.println("ViewPort: "+vpCnt+" "+viewPortList[vpCnt].getAdjustedExtent()+" "+getTile(vpCnt).getSize());
|
||
178 | } |
||
179 | if((yt - ht) < viewPort.getAdjustedExtent().getMinY()){
|
||
180 | ht = Math.abs(yt - viewPort.getAdjustedExtent().getMinY());
|
||
181 | yt = viewPort.getAdjustedExtent().getMinY(); |
||
182 | }else
|
||
183 | yt -= ht; |
||
184 | } |
||
185 | } |
||
186 | |||
187 | 1488 | luisw | public ViewPort getTileViewPort(ViewPort viewPort, int tileNr) throws NoninvertibleTransformException { |
188 | 3953 | nacho | /*if(viewPortList == null)
|
189 | this.calcViewPort(viewPort);
|
||
190 | return viewPortList[tileNr];*/
|
||
191 | 1488 | luisw | double [] dstPts = new double[8]; |
192 | double [] srcPts = getTilePts(tileNr); |
||
193 | 1501 | luisw | Rectangle tile = getTile(tileNr);
|
194 | 1488 | luisw | //Rectangle newRect = new Rectangle((int)srcPts[0], (int)srcPts[1], tileSz[0], tileSz[1]);
|
195 | |||
196 | mat.inverseTransform(srcPts, 0, dstPts, 0, 4); |
||
197 | 1501 | luisw | double x = dstPts[0], w = dstPts[2] - dstPts[0]; |
198 | double y = dstPts[1], h = dstPts[5] - dstPts[3]; |
||
199 | if (w < 0) { x = dstPts[2]; w = dstPts[0] - dstPts[2]; } |
||
200 | if (h < 0) { y = dstPts[5]; h = dstPts[3] - dstPts[5]; } |
||
201 | Rectangle2D.Double rectCuadricula = new Rectangle2D.Double(x, y, w, h); |
||
202 | 1488 | luisw | //Extent extent = new Extent(rectCuadricula);
|
203 | |||
204 | ViewPort vp = viewPort.cloneViewPort(); |
||
205 | 1501 | luisw | vp.setImageSize(tile.getSize()); |
206 | //vp.setOffset(tile.getLocation());
|
||
207 | 1488 | luisw | vp.setExtent(rectCuadricula); |
208 | vp.setAffineTransform(mat); |
||
209 | |||
210 | if (debug)
|
||
211 | System.out.println("Tiling.print(): tile "+tileNr+" de " |
||
212 | + getNumTiles() + |
||
213 | 1501 | luisw | "\n, Extent = "+vp.getAdjustedExtent() + " tile: " |
214 | + tile); |
||
215 | 1488 | luisw | return vp;
|
216 | } |
||
217 | 3953 | nacho | |
218 | 1488 | luisw | /**
|
219 | * @return Returns the mat.
|
||
220 | */
|
||
221 | public AffineTransform getAffineTransform() { |
||
222 | return mat;
|
||
223 | } |
||
224 | /**
|
||
225 | * @param mat The mat to set.
|
||
226 | */
|
||
227 | public void setAffineTransform(AffineTransform mat) { |
||
228 | this.mat = mat;
|
||
229 | } |
||
230 | /**
|
||
231 | * @return Returns the debug.
|
||
232 | */
|
||
233 | public boolean isDebug() { |
||
234 | return debug;
|
||
235 | } |
||
236 | /**
|
||
237 | * @param debug The debug to set.
|
||
238 | */
|
||
239 | public void setDebug(boolean debug) { |
||
240 | this.debug = debug;
|
||
241 | } |
||
242 | } |
||
243 |