| gvSIG desktop 1

/*

 * Created on 16-feb-2005

 */

package com.iver.cit.gvsig.fmap.layers;

import java.awt.Dimension;

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Rectangle2D;

import org.cresques.px.Extent;

import com.iver.cit.gvsig.fmap.ViewPort;

/**

 * C?lculo de Partes (Tiles) en las que se divide un raster grande.

 * Se usa para imprimir rasters y capas raste remotas (WMS).

 *

 * Para no pedir imagenes demasiado grandes, vamos

 * a hacer lo mismo que hace EcwFile: chunkear.

 * Llamamos a drawView con cuadraditos m?s peque?os

 * del BufferedImage ni caso, cuando se imprime viene con null

 * c?digo original de Fran Pe?arrubia

 * @author Luis W. Sevilla (sevilla_lui@gva.es)

 */

public class Tiling {

        boolean debug = true;

        int tileMaxWidth, tileMaxHeight;

        int numRows, numCols;

        double [][] srcPts;

        Rectangle [] tile;

        AffineTransform mat;

        ViewPort vp;

        public Tiling(int tileW, int tileH, Rectangle r) {

                tileMaxWidth = tileW;

                tileMaxHeight = tileH;

        int stepX, stepY;

        int xProv, yProv, wProv, hProv;

        double xProvD, yProvD, wProvD, hProvD;

        int altoAux, anchoAux;

        // Vamos a hacerlo en trozos de AxH

        numCols = 1+(int) (r.width) / tileMaxWidth;

        numRows = 1+(int) (r.height) / tileMaxHeight;

        srcPts = new double[numCols*numRows][8];

        tile = new Rectangle[numCols*numRows];

            yProv = (int) r.y;

        for (stepY=0; stepY < numRows; stepY++) {

                    if ((yProv + tileMaxHeight) > r.getMaxY())

                            altoAux = (int) r.getMaxY() - yProv;

                    else

                            altoAux = tileMaxHeight;

                    xProv = (int) r.x;

                for (stepX=0; stepX < numCols; stepX++) {

                            if ((xProv + tileMaxWidth) > r.getMaxX())

                                    anchoAux = (int) r.getMaxX() - xProv;

                            else

                                    anchoAux = tileMaxWidth;

                        Rectangle newRect = new Rectangle(xProv, yProv, anchoAux, altoAux);

                        int tileCnt = stepY*numCols+stepX;

                        // Parte que dibuja

                        srcPts[tileCnt][0] = xProv;

                        srcPts[tileCnt][1] = yProv;

                        srcPts[tileCnt][2] = xProv + anchoAux+1;

                        srcPts[tileCnt][3] = yProv;

                        srcPts[tileCnt][4] = xProv + anchoAux+1;

                        srcPts[tileCnt][5] = yProv + altoAux+1;

                        srcPts[tileCnt][6] = xProv;

                        srcPts[tileCnt][7] = yProv + altoAux+1;

                        tile[tileCnt] = new Rectangle(xProv, yProv, anchoAux+1, altoAux+1);

                                xProv = xProv + tileMaxWidth;

                }

                yProv = yProv + tileMaxHeight;

        }

        }

        public double [] getTilePts(int colNr, int rowNr) {

                return srcPts[rowNr*numCols+colNr];

        }

        public double [] getTilePts(int num) {

                return srcPts[num];

        }

        public Rectangle getTileSz(int colNr, int rowNr) {

                return tile[rowNr*numCols+colNr];

        }

        public Rectangle getTile(int num) {

                return tile[num];

        }

        /**

         * @return Returns the numCols.

         */

        public int getNumCols() {

                return numCols;

        }

        /**

         * @return Returns the numRows.

         */

        public int getNumRows() {

                return numRows;

        }

        public int getNumTiles() { return numRows*numCols; }

        /**

         * @return Returns the tileHeight.

         */

        public int getMaxTileHeight() {

                return tileMaxHeight;

        }

        /**

         * @return Returns the tileWidth.

         */

        public int getMaxTileWidth() {

                return tileMaxWidth;

        }

        public ViewPort getTileViewPort(ViewPort viewPort, int tileNr) throws NoninvertibleTransformException {

                double [] dstPts = new double[8];

                double [] srcPts = getTilePts(tileNr);

                Rectangle tile = getTile(tileNr);

                //Rectangle newRect = new Rectangle((int)srcPts[0], (int)srcPts[1], tileSz[0], tileSz[1]);

                mat.inverseTransform(srcPts, 0, dstPts, 0, 4);

                double x = dstPts[0], w = dstPts[2] - dstPts[0];

                double y = dstPts[1], h = dstPts[5] - dstPts[3];

                if (w < 0) { x = dstPts[2]; w = dstPts[0] - dstPts[2]; }

                if (h < 0) { y = dstPts[5]; h = dstPts[3] - dstPts[5]; }

                Rectangle2D.Double rectCuadricula = new Rectangle2D.Double(x, y, w, h);

                //Extent extent = new Extent(rectCuadricula);

                ViewPort vp = viewPort.cloneViewPort();

                vp.setImageSize(tile.getSize());

                //vp.setOffset(tile.getLocation());

                vp.setExtent(rectCuadricula);

                vp.setAffineTransform(mat);

                if (debug)

                    System.out.println("Tiling.print(): tile "+tileNr+" de "

                            + getNumTiles() +

                            "\n, Extent = "+vp.getAdjustedExtent() + " tile: "

                            + tile);

                return vp;

        }

        /**

         * @return Returns the mat.

         */

        public AffineTransform getAffineTransform() {

                return mat;

        }

        /**

         * @param mat The mat to set.

         */

        public void setAffineTransform(AffineTransform mat) {

                this.mat = mat;

        }

        /**

         * @return Returns the debug.

         */

        public boolean isDebug() {

                return debug;

        }

        /**

         * @param debug The debug to set.

         */

        public void setDebug(boolean debug) {

                this.debug = debug;

        }

}